18185 lines
599 KiB
Java
18185 lines
599 KiB
Java
// Generated from /Users/mannpatel/Desktop/University/25-Fall/CPSC499/CPSC-499 Assignment/Assignment-2/Java-8/Java8Parser.g4 by ANTLR 4.13.1
|
|
import org.antlr.v4.runtime.atn.*;
|
|
import org.antlr.v4.runtime.dfa.DFA;
|
|
import org.antlr.v4.runtime.*;
|
|
import org.antlr.v4.runtime.misc.*;
|
|
import org.antlr.v4.runtime.tree.*;
|
|
import java.util.List;
|
|
import java.util.Iterator;
|
|
import java.util.ArrayList;
|
|
|
|
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
|
|
public class Java8Parser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
|
|
|
|
protected static final DFA[] _decisionToDFA;
|
|
protected static final PredictionContextCache _sharedContextCache =
|
|
new PredictionContextCache();
|
|
public static final int
|
|
ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8,
|
|
CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15,
|
|
ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23,
|
|
IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29,
|
|
NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36,
|
|
SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42,
|
|
THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49,
|
|
WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53,
|
|
CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58,
|
|
LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65,
|
|
ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73,
|
|
LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82,
|
|
MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90,
|
|
ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95,
|
|
OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100,
|
|
URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106,
|
|
LINE_COMMENT=107;
|
|
public static final int
|
|
RULE_literal = 0, RULE_primitiveType = 1, RULE_numericType = 2, RULE_integralType = 3,
|
|
RULE_floatingPointType = 4, RULE_referenceType = 5, RULE_classOrInterfaceType = 6,
|
|
RULE_classType = 7, RULE_classType_lf_classOrInterfaceType = 8, RULE_classType_lfno_classOrInterfaceType = 9,
|
|
RULE_interfaceType = 10, RULE_interfaceType_lf_classOrInterfaceType = 11,
|
|
RULE_interfaceType_lfno_classOrInterfaceType = 12, RULE_typeVariable = 13,
|
|
RULE_arrayType = 14, RULE_dims = 15, RULE_typeParameter = 16, RULE_typeParameterModifier = 17,
|
|
RULE_typeBound = 18, RULE_additionalBound = 19, RULE_typeArguments = 20,
|
|
RULE_typeArgumentList = 21, RULE_typeArgument = 22, RULE_wildcard = 23,
|
|
RULE_wildcardBounds = 24, RULE_packageName = 25, RULE_typeName = 26, RULE_packageOrTypeName = 27,
|
|
RULE_expressionName = 28, RULE_methodName = 29, RULE_ambiguousName = 30,
|
|
RULE_compilationUnit = 31, RULE_packageDeclaration = 32, RULE_packageModifier = 33,
|
|
RULE_importDeclaration = 34, RULE_singleTypeImportDeclaration = 35, RULE_typeImportOnDemandDeclaration = 36,
|
|
RULE_singleStaticImportDeclaration = 37, RULE_staticImportOnDemandDeclaration = 38,
|
|
RULE_typeDeclaration = 39, RULE_classDeclaration = 40, RULE_normalClassDeclaration = 41,
|
|
RULE_classModifier = 42, RULE_typeParameters = 43, RULE_typeParameterList = 44,
|
|
RULE_superclass = 45, RULE_superinterfaces = 46, RULE_interfaceTypeList = 47,
|
|
RULE_classBody = 48, RULE_classBodyDeclaration = 49, RULE_classMemberDeclaration = 50,
|
|
RULE_fieldDeclaration = 51, RULE_fieldModifier = 52, RULE_variableDeclaratorList = 53,
|
|
RULE_variableDeclarator = 54, RULE_variableDeclaratorId = 55, RULE_variableInitializer = 56,
|
|
RULE_unannType = 57, RULE_unannPrimitiveType = 58, RULE_unannReferenceType = 59,
|
|
RULE_unannClassOrInterfaceType = 60, RULE_unannClassType = 61, RULE_unannClassType_lf_unannClassOrInterfaceType = 62,
|
|
RULE_unannClassType_lfno_unannClassOrInterfaceType = 63, RULE_unannInterfaceType = 64,
|
|
RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 65, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 66,
|
|
RULE_unannTypeVariable = 67, RULE_unannArrayType = 68, RULE_methodDeclaration = 69,
|
|
RULE_methodModifier = 70, RULE_methodHeader = 71, RULE_result = 72, RULE_methodDeclarator = 73,
|
|
RULE_formalParameterList = 74, RULE_formalParameters = 75, RULE_formalParameter = 76,
|
|
RULE_variableModifier = 77, RULE_lastFormalParameter = 78, RULE_receiverParameter = 79,
|
|
RULE_throws_ = 80, RULE_exceptionTypeList = 81, RULE_exceptionType = 82,
|
|
RULE_methodBody = 83, RULE_instanceInitializer = 84, RULE_staticInitializer = 85,
|
|
RULE_constructorDeclaration = 86, RULE_constructorModifier = 87, RULE_constructorDeclarator = 88,
|
|
RULE_simpleTypeName = 89, RULE_constructorBody = 90, RULE_explicitConstructorInvocation = 91,
|
|
RULE_enumDeclaration = 92, RULE_enumBody = 93, RULE_enumConstantList = 94,
|
|
RULE_enumConstant = 95, RULE_enumConstantModifier = 96, RULE_enumBodyDeclarations = 97,
|
|
RULE_interfaceDeclaration = 98, RULE_normalInterfaceDeclaration = 99,
|
|
RULE_interfaceModifier = 100, RULE_extendsInterfaces = 101, RULE_interfaceBody = 102,
|
|
RULE_interfaceMemberDeclaration = 103, RULE_constantDeclaration = 104,
|
|
RULE_constantModifier = 105, RULE_interfaceMethodDeclaration = 106, RULE_interfaceMethodModifier = 107,
|
|
RULE_annotationTypeDeclaration = 108, RULE_annotationTypeBody = 109, RULE_annotationTypeMemberDeclaration = 110,
|
|
RULE_annotationTypeElementDeclaration = 111, RULE_annotationTypeElementModifier = 112,
|
|
RULE_defaultValue = 113, RULE_annotation = 114, RULE_normalAnnotation = 115,
|
|
RULE_elementValuePairList = 116, RULE_elementValuePair = 117, RULE_elementValue = 118,
|
|
RULE_elementValueArrayInitializer = 119, RULE_elementValueList = 120,
|
|
RULE_markerAnnotation = 121, RULE_singleElementAnnotation = 122, RULE_arrayInitializer = 123,
|
|
RULE_variableInitializerList = 124, RULE_block = 125, RULE_blockStatements = 126,
|
|
RULE_blockStatement = 127, RULE_localVariableDeclarationStatement = 128,
|
|
RULE_localVariableDeclaration = 129, RULE_statement = 130, RULE_statementNoShortIf = 131,
|
|
RULE_statementWithoutTrailingSubstatement = 132, RULE_emptyStatement_ = 133,
|
|
RULE_labeledStatement = 134, RULE_labeledStatementNoShortIf = 135, RULE_expressionStatement = 136,
|
|
RULE_statementExpression = 137, RULE_ifThenStatement = 138, RULE_ifThenElseStatement = 139,
|
|
RULE_ifThenElseStatementNoShortIf = 140, RULE_assertStatement = 141, RULE_switchStatement = 142,
|
|
RULE_switchBlock = 143, RULE_switchBlockStatementGroup = 144, RULE_switchLabels = 145,
|
|
RULE_switchLabel = 146, RULE_enumConstantName = 147, RULE_whileStatement = 148,
|
|
RULE_whileStatementNoShortIf = 149, RULE_doStatement = 150, RULE_forStatement = 151,
|
|
RULE_forStatementNoShortIf = 152, RULE_basicForStatement = 153, RULE_basicForStatementNoShortIf = 154,
|
|
RULE_forInit = 155, RULE_forUpdate = 156, RULE_statementExpressionList = 157,
|
|
RULE_enhancedForStatement = 158, RULE_enhancedForStatementNoShortIf = 159,
|
|
RULE_breakStatement = 160, RULE_continueStatement = 161, RULE_returnStatement = 162,
|
|
RULE_throwStatement = 163, RULE_synchronizedStatement = 164, RULE_tryStatement = 165,
|
|
RULE_catches = 166, RULE_catchClause = 167, RULE_catchFormalParameter = 168,
|
|
RULE_catchType = 169, RULE_finally_ = 170, RULE_tryWithResourcesStatement = 171,
|
|
RULE_resourceSpecification = 172, RULE_resourceList = 173, RULE_resource = 174,
|
|
RULE_primary = 175, RULE_primaryNoNewArray = 176, RULE_primaryNoNewArray_lf_arrayAccess = 177,
|
|
RULE_primaryNoNewArray_lfno_arrayAccess = 178, RULE_primaryNoNewArray_lf_primary = 179,
|
|
RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 180, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 181,
|
|
RULE_primaryNoNewArray_lfno_primary = 182, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 183,
|
|
RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 184,
|
|
RULE_classInstanceCreationExpression = 185, RULE_classInstanceCreationExpression_lf_primary = 186,
|
|
RULE_classInstanceCreationExpression_lfno_primary = 187, RULE_typeArgumentsOrDiamond = 188,
|
|
RULE_fieldAccess = 189, RULE_fieldAccess_lf_primary = 190, RULE_fieldAccess_lfno_primary = 191,
|
|
RULE_arrayAccess = 192, RULE_arrayAccess_lf_primary = 193, RULE_arrayAccess_lfno_primary = 194,
|
|
RULE_methodInvocation = 195, RULE_methodInvocation_lf_primary = 196, RULE_methodInvocation_lfno_primary = 197,
|
|
RULE_argumentList = 198, RULE_methodReference = 199, RULE_methodReference_lf_primary = 200,
|
|
RULE_methodReference_lfno_primary = 201, RULE_arrayCreationExpression = 202,
|
|
RULE_dimExprs = 203, RULE_dimExpr = 204, RULE_constantExpression = 205,
|
|
RULE_expression = 206, RULE_lambdaExpression = 207, RULE_lambdaParameters = 208,
|
|
RULE_inferredFormalParameterList = 209, RULE_lambdaBody = 210, RULE_assignmentExpression = 211,
|
|
RULE_assignment = 212, RULE_leftHandSide = 213, RULE_assignmentOperator = 214,
|
|
RULE_conditionalExpression = 215, RULE_conditionalOrExpression = 216,
|
|
RULE_conditionalAndExpression = 217, RULE_inclusiveOrExpression = 218,
|
|
RULE_exclusiveOrExpression = 219, RULE_andExpression = 220, RULE_equalityExpression = 221,
|
|
RULE_relationalExpression = 222, RULE_shiftExpression = 223, RULE_additiveExpression = 224,
|
|
RULE_multiplicativeExpression = 225, RULE_unaryExpression = 226, RULE_preIncrementExpression = 227,
|
|
RULE_preDecrementExpression = 228, RULE_unaryExpressionNotPlusMinus = 229,
|
|
RULE_postfixExpression = 230, RULE_postIncrementExpression = 231, RULE_postIncrementExpression_lf_postfixExpression = 232,
|
|
RULE_postDecrementExpression = 233, RULE_postDecrementExpression_lf_postfixExpression = 234,
|
|
RULE_castExpression = 235;
|
|
private static String[] makeRuleNames() {
|
|
return new String[] {
|
|
"literal", "primitiveType", "numericType", "integralType", "floatingPointType",
|
|
"referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType",
|
|
"classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType",
|
|
"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType",
|
|
"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound",
|
|
"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds",
|
|
"packageName", "typeName", "packageOrTypeName", "expressionName", "methodName",
|
|
"ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier",
|
|
"importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration",
|
|
"singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration",
|
|
"classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters",
|
|
"typeParameterList", "superclass", "superinterfaces", "interfaceTypeList",
|
|
"classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration",
|
|
"fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId",
|
|
"variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType",
|
|
"unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType",
|
|
"unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType",
|
|
"unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType",
|
|
"unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier",
|
|
"methodHeader", "result", "methodDeclarator", "formalParameterList",
|
|
"formalParameters", "formalParameter", "variableModifier", "lastFormalParameter",
|
|
"receiverParameter", "throws_", "exceptionTypeList", "exceptionType",
|
|
"methodBody", "instanceInitializer", "staticInitializer", "constructorDeclaration",
|
|
"constructorModifier", "constructorDeclarator", "simpleTypeName", "constructorBody",
|
|
"explicitConstructorInvocation", "enumDeclaration", "enumBody", "enumConstantList",
|
|
"enumConstant", "enumConstantModifier", "enumBodyDeclarations", "interfaceDeclaration",
|
|
"normalInterfaceDeclaration", "interfaceModifier", "extendsInterfaces",
|
|
"interfaceBody", "interfaceMemberDeclaration", "constantDeclaration",
|
|
"constantModifier", "interfaceMethodDeclaration", "interfaceMethodModifier",
|
|
"annotationTypeDeclaration", "annotationTypeBody", "annotationTypeMemberDeclaration",
|
|
"annotationTypeElementDeclaration", "annotationTypeElementModifier",
|
|
"defaultValue", "annotation", "normalAnnotation", "elementValuePairList",
|
|
"elementValuePair", "elementValue", "elementValueArrayInitializer", "elementValueList",
|
|
"markerAnnotation", "singleElementAnnotation", "arrayInitializer", "variableInitializerList",
|
|
"block", "blockStatements", "blockStatement", "localVariableDeclarationStatement",
|
|
"localVariableDeclaration", "statement", "statementNoShortIf", "statementWithoutTrailingSubstatement",
|
|
"emptyStatement_", "labeledStatement", "labeledStatementNoShortIf", "expressionStatement",
|
|
"statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf",
|
|
"assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup",
|
|
"switchLabels", "switchLabel", "enumConstantName", "whileStatement",
|
|
"whileStatementNoShortIf", "doStatement", "forStatement", "forStatementNoShortIf",
|
|
"basicForStatement", "basicForStatementNoShortIf", "forInit", "forUpdate",
|
|
"statementExpressionList", "enhancedForStatement", "enhancedForStatementNoShortIf",
|
|
"breakStatement", "continueStatement", "returnStatement", "throwStatement",
|
|
"synchronizedStatement", "tryStatement", "catches", "catchClause", "catchFormalParameter",
|
|
"catchType", "finally_", "tryWithResourcesStatement", "resourceSpecification",
|
|
"resourceList", "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess",
|
|
"primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary",
|
|
"primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary",
|
|
"primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary",
|
|
"primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression",
|
|
"classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary",
|
|
"typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary",
|
|
"arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary",
|
|
"methodInvocation", "methodInvocation_lf_primary", "methodInvocation_lfno_primary",
|
|
"argumentList", "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
|
|
"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
|
|
"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
|
|
"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
|
|
"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
|
|
"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",
|
|
"relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression",
|
|
"unaryExpression", "preIncrementExpression", "preDecrementExpression",
|
|
"unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression",
|
|
"postIncrementExpression_lf_postfixExpression", "postDecrementExpression",
|
|
"postDecrementExpression_lf_postfixExpression", "castExpression"
|
|
};
|
|
}
|
|
public static final String[] ruleNames = makeRuleNames();
|
|
|
|
private static String[] makeLiteralNames() {
|
|
return new String[] {
|
|
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, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'",
|
|
"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'",
|
|
"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'",
|
|
"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='",
|
|
"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='",
|
|
"'>>>='", null, "'@'", "'...'"
|
|
};
|
|
}
|
|
private static final String[] _LITERAL_NAMES = makeLiteralNames();
|
|
private static String[] makeSymbolicNames() {
|
|
return new String[] {
|
|
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", "IntegerLiteral",
|
|
"FloatingPointLiteral", "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", "ARROW",
|
|
"COLONCOLON", "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"
|
|
};
|
|
}
|
|
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
|
|
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
|
|
|
|
/**
|
|
* @deprecated Use {@link #VOCABULARY} instead.
|
|
*/
|
|
@Deprecated
|
|
public static final String[] tokenNames;
|
|
static {
|
|
tokenNames = new String[_SYMBOLIC_NAMES.length];
|
|
for (int i = 0; i < tokenNames.length; i++) {
|
|
tokenNames[i] = VOCABULARY.getLiteralName(i);
|
|
if (tokenNames[i] == null) {
|
|
tokenNames[i] = VOCABULARY.getSymbolicName(i);
|
|
}
|
|
|
|
if (tokenNames[i] == null) {
|
|
tokenNames[i] = "<INVALID>";
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@Deprecated
|
|
public String[] getTokenNames() {
|
|
return tokenNames;
|
|
}
|
|
|
|
@Override
|
|
|
|
public Vocabulary getVocabulary() {
|
|
return VOCABULARY;
|
|
}
|
|
|
|
@Override
|
|
public String getGrammarFileName() { return "Java8Parser.g4"; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public Java8Parser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LiteralContext extends ParserRuleContext {
|
|
public TerminalNode IntegerLiteral() { return getToken(Java8Parser.IntegerLiteral, 0); }
|
|
public TerminalNode FloatingPointLiteral() { return getToken(Java8Parser.FloatingPointLiteral, 0); }
|
|
public TerminalNode BooleanLiteral() { return getToken(Java8Parser.BooleanLiteral, 0); }
|
|
public TerminalNode CharacterLiteral() { return getToken(Java8Parser.CharacterLiteral, 0); }
|
|
public TerminalNode StringLiteral() { return getToken(Java8Parser.StringLiteral, 0); }
|
|
public TerminalNode NullLiteral() { return getToken(Java8Parser.NullLiteral, 0); }
|
|
public LiteralContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_literal; }
|
|
}
|
|
|
|
public final LiteralContext literal() throws RecognitionException {
|
|
LiteralContext _localctx = new LiteralContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_literal);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(472);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 141863388262170624L) != 0)) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimitiveTypeContext extends ParserRuleContext {
|
|
public NumericTypeContext numericType() {
|
|
return getRuleContext(NumericTypeContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TerminalNode BOOLEAN() { return getToken(Java8Parser.BOOLEAN, 0); }
|
|
public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primitiveType; }
|
|
}
|
|
|
|
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
|
|
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 2, RULE_primitiveType);
|
|
int _la;
|
|
try {
|
|
setState(488);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(477);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(474);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(479);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(480);
|
|
numericType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(484);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(481);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(486);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(487);
|
|
match(BOOLEAN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NumericTypeContext extends ParserRuleContext {
|
|
public IntegralTypeContext integralType() {
|
|
return getRuleContext(IntegralTypeContext.class,0);
|
|
}
|
|
public FloatingPointTypeContext floatingPointType() {
|
|
return getRuleContext(FloatingPointTypeContext.class,0);
|
|
}
|
|
public NumericTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_numericType; }
|
|
}
|
|
|
|
public final NumericTypeContext numericType() throws RecognitionException {
|
|
NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_numericType);
|
|
try {
|
|
setState(492);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case BYTE:
|
|
case CHAR:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(490);
|
|
integralType();
|
|
}
|
|
break;
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(491);
|
|
floatingPointType();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IntegralTypeContext extends ParserRuleContext {
|
|
public TerminalNode BYTE() { return getToken(Java8Parser.BYTE, 0); }
|
|
public TerminalNode SHORT() { return getToken(Java8Parser.SHORT, 0); }
|
|
public TerminalNode INT() { return getToken(Java8Parser.INT, 0); }
|
|
public TerminalNode LONG() { return getToken(Java8Parser.LONG, 0); }
|
|
public TerminalNode CHAR() { return getToken(Java8Parser.CHAR, 0); }
|
|
public IntegralTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_integralType; }
|
|
}
|
|
|
|
public final IntegralTypeContext integralType() throws RecognitionException {
|
|
IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 6, RULE_integralType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(494);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 138110042400L) != 0)) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FloatingPointTypeContext extends ParserRuleContext {
|
|
public TerminalNode FLOAT() { return getToken(Java8Parser.FLOAT, 0); }
|
|
public TerminalNode DOUBLE() { return getToken(Java8Parser.DOUBLE, 0); }
|
|
public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_floatingPointType; }
|
|
}
|
|
|
|
public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
|
|
FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 8, RULE_floatingPointType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(496);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==DOUBLE || _la==FLOAT) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReferenceTypeContext extends ParserRuleContext {
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public TypeVariableContext typeVariable() {
|
|
return getRuleContext(TypeVariableContext.class,0);
|
|
}
|
|
public ArrayTypeContext arrayType() {
|
|
return getRuleContext(ArrayTypeContext.class,0);
|
|
}
|
|
public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_referenceType; }
|
|
}
|
|
|
|
public final ReferenceTypeContext referenceType() throws RecognitionException {
|
|
ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 10, RULE_referenceType);
|
|
try {
|
|
setState(501);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(498);
|
|
classOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(499);
|
|
typeVariable();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(500);
|
|
arrayType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
|
|
return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
|
|
}
|
|
public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() {
|
|
return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0);
|
|
}
|
|
public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() {
|
|
return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class);
|
|
}
|
|
public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) {
|
|
return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i);
|
|
}
|
|
public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() {
|
|
return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class);
|
|
}
|
|
public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) {
|
|
return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i);
|
|
}
|
|
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
|
|
}
|
|
|
|
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
|
|
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 12, RULE_classOrInterfaceType);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(505);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(503);
|
|
classType_lfno_classOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(504);
|
|
interfaceType_lfno_classOrInterfaceType();
|
|
}
|
|
break;
|
|
}
|
|
setState(511);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
setState(509);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(507);
|
|
classType_lf_classOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(508);
|
|
interfaceType_lf_classOrInterfaceType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(513);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassTypeContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public ClassTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classType; }
|
|
}
|
|
|
|
public final ClassTypeContext classType() throws RecognitionException {
|
|
ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 14, RULE_classType);
|
|
int _la;
|
|
try {
|
|
setState(536);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(517);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(514);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(519);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(520);
|
|
match(Identifier);
|
|
setState(522);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(521);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(524);
|
|
classOrInterfaceType();
|
|
setState(525);
|
|
match(DOT);
|
|
setState(529);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(526);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(531);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(532);
|
|
match(Identifier);
|
|
setState(534);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(533);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; }
|
|
}
|
|
|
|
public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
|
|
ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_classType_lf_classOrInterfaceType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(538);
|
|
match(DOT);
|
|
setState(542);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(539);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(544);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(545);
|
|
match(Identifier);
|
|
setState(547);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(546);
|
|
typeArguments();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; }
|
|
}
|
|
|
|
public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
|
|
ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 18, RULE_classType_lfno_classOrInterfaceType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(552);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(549);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(554);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(555);
|
|
match(Identifier);
|
|
setState(557);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(556);
|
|
typeArguments();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceTypeContext extends ParserRuleContext {
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceType; }
|
|
}
|
|
|
|
public final InterfaceTypeContext interfaceType() throws RecognitionException {
|
|
InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 20, RULE_interfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(559);
|
|
classType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
|
|
public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() {
|
|
return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0);
|
|
}
|
|
public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; }
|
|
}
|
|
|
|
public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
|
|
InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 22, RULE_interfaceType_lf_classOrInterfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(561);
|
|
classType_lf_classOrInterfaceType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
|
|
public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
|
|
return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
|
|
}
|
|
public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; }
|
|
}
|
|
|
|
public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
|
|
InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 24, RULE_interfaceType_lfno_classOrInterfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(563);
|
|
classType_lfno_classOrInterfaceType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeVariableContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeVariableContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeVariable; }
|
|
}
|
|
|
|
public final TypeVariableContext typeVariable() throws RecognitionException {
|
|
TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState());
|
|
enterRule(_localctx, 26, RULE_typeVariable);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(568);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(565);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(570);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(571);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayTypeContext extends ParserRuleContext {
|
|
public PrimitiveTypeContext primitiveType() {
|
|
return getRuleContext(PrimitiveTypeContext.class,0);
|
|
}
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public TypeVariableContext typeVariable() {
|
|
return getRuleContext(TypeVariableContext.class,0);
|
|
}
|
|
public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayType; }
|
|
}
|
|
|
|
public final ArrayTypeContext arrayType() throws RecognitionException {
|
|
ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 28, RULE_arrayType);
|
|
try {
|
|
setState(582);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(573);
|
|
primitiveType();
|
|
setState(574);
|
|
dims();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(576);
|
|
classOrInterfaceType();
|
|
setState(577);
|
|
dims();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(579);
|
|
typeVariable();
|
|
setState(580);
|
|
dims();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DimsContext extends ParserRuleContext {
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public DimsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_dims; }
|
|
}
|
|
|
|
public final DimsContext dims() throws RecognitionException {
|
|
DimsContext _localctx = new DimsContext(_ctx, getState());
|
|
enterRule(_localctx, 30, RULE_dims);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(587);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(584);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(589);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(590);
|
|
match(LBRACK);
|
|
setState(591);
|
|
match(RBRACK);
|
|
setState(602);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(595);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(592);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(597);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(598);
|
|
match(LBRACK);
|
|
setState(599);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(604);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeParameterContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<TypeParameterModifierContext> typeParameterModifier() {
|
|
return getRuleContexts(TypeParameterModifierContext.class);
|
|
}
|
|
public TypeParameterModifierContext typeParameterModifier(int i) {
|
|
return getRuleContext(TypeParameterModifierContext.class,i);
|
|
}
|
|
public TypeBoundContext typeBound() {
|
|
return getRuleContext(TypeBoundContext.class,0);
|
|
}
|
|
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeParameter; }
|
|
}
|
|
|
|
public final TypeParameterContext typeParameter() throws RecognitionException {
|
|
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 32, RULE_typeParameter);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(608);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(605);
|
|
typeParameterModifier();
|
|
}
|
|
}
|
|
setState(610);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(611);
|
|
match(Identifier);
|
|
setState(613);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS) {
|
|
{
|
|
setState(612);
|
|
typeBound();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeParameterModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeParameterModifier; }
|
|
}
|
|
|
|
public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
|
|
TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 34, RULE_typeParameterModifier);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(615);
|
|
annotation();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeBoundContext extends ParserRuleContext {
|
|
public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); }
|
|
public TypeVariableContext typeVariable() {
|
|
return getRuleContext(TypeVariableContext.class,0);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public List<AdditionalBoundContext> additionalBound() {
|
|
return getRuleContexts(AdditionalBoundContext.class);
|
|
}
|
|
public AdditionalBoundContext additionalBound(int i) {
|
|
return getRuleContext(AdditionalBoundContext.class,i);
|
|
}
|
|
public TypeBoundContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeBound; }
|
|
}
|
|
|
|
public final TypeBoundContext typeBound() throws RecognitionException {
|
|
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
|
|
enterRule(_localctx, 36, RULE_typeBound);
|
|
int _la;
|
|
try {
|
|
setState(627);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(617);
|
|
match(EXTENDS);
|
|
setState(618);
|
|
typeVariable();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(619);
|
|
match(EXTENDS);
|
|
setState(620);
|
|
classOrInterfaceType();
|
|
setState(624);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITAND) {
|
|
{
|
|
{
|
|
setState(621);
|
|
additionalBound();
|
|
}
|
|
}
|
|
setState(626);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AdditionalBoundContext extends ParserRuleContext {
|
|
public TerminalNode BITAND() { return getToken(Java8Parser.BITAND, 0); }
|
|
public InterfaceTypeContext interfaceType() {
|
|
return getRuleContext(InterfaceTypeContext.class,0);
|
|
}
|
|
public AdditionalBoundContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_additionalBound; }
|
|
}
|
|
|
|
public final AdditionalBoundContext additionalBound() throws RecognitionException {
|
|
AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState());
|
|
enterRule(_localctx, 38, RULE_additionalBound);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(629);
|
|
match(BITAND);
|
|
setState(630);
|
|
interfaceType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeArgumentsContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java8Parser.LT, 0); }
|
|
public TypeArgumentListContext typeArgumentList() {
|
|
return getRuleContext(TypeArgumentListContext.class,0);
|
|
}
|
|
public TerminalNode GT() { return getToken(Java8Parser.GT, 0); }
|
|
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArguments; }
|
|
}
|
|
|
|
public final TypeArgumentsContext typeArguments() throws RecognitionException {
|
|
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
|
|
enterRule(_localctx, 40, RULE_typeArguments);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(632);
|
|
match(LT);
|
|
setState(633);
|
|
typeArgumentList();
|
|
setState(634);
|
|
match(GT);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeArgumentListContext extends ParserRuleContext {
|
|
public List<TypeArgumentContext> typeArgument() {
|
|
return getRuleContexts(TypeArgumentContext.class);
|
|
}
|
|
public TypeArgumentContext typeArgument(int i) {
|
|
return getRuleContext(TypeArgumentContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArgumentList; }
|
|
}
|
|
|
|
public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
|
|
TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
|
|
enterRule(_localctx, 42, RULE_typeArgumentList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(636);
|
|
typeArgument();
|
|
setState(641);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(637);
|
|
match(COMMA);
|
|
setState(638);
|
|
typeArgument();
|
|
}
|
|
}
|
|
setState(643);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeArgumentContext extends ParserRuleContext {
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public WildcardContext wildcard() {
|
|
return getRuleContext(WildcardContext.class,0);
|
|
}
|
|
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArgument; }
|
|
}
|
|
|
|
public final TypeArgumentContext typeArgument() throws RecognitionException {
|
|
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
|
|
enterRule(_localctx, 44, RULE_typeArgument);
|
|
try {
|
|
setState(646);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(644);
|
|
referenceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(645);
|
|
wildcard();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WildcardContext extends ParserRuleContext {
|
|
public TerminalNode QUESTION() { return getToken(Java8Parser.QUESTION, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public WildcardBoundsContext wildcardBounds() {
|
|
return getRuleContext(WildcardBoundsContext.class,0);
|
|
}
|
|
public WildcardContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_wildcard; }
|
|
}
|
|
|
|
public final WildcardContext wildcard() throws RecognitionException {
|
|
WildcardContext _localctx = new WildcardContext(_ctx, getState());
|
|
enterRule(_localctx, 46, RULE_wildcard);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(651);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(648);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(653);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(654);
|
|
match(QUESTION);
|
|
setState(656);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS || _la==SUPER) {
|
|
{
|
|
setState(655);
|
|
wildcardBounds();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WildcardBoundsContext extends ParserRuleContext {
|
|
public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); }
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_wildcardBounds; }
|
|
}
|
|
|
|
public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
|
|
WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
|
|
enterRule(_localctx, 48, RULE_wildcardBounds);
|
|
try {
|
|
setState(662);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case EXTENDS:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(658);
|
|
match(EXTENDS);
|
|
setState(659);
|
|
referenceType();
|
|
}
|
|
break;
|
|
case SUPER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(660);
|
|
match(SUPER);
|
|
setState(661);
|
|
referenceType();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PackageNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public PackageNameContext packageName() {
|
|
return getRuleContext(PackageNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public PackageNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_packageName; }
|
|
}
|
|
|
|
public final PackageNameContext packageName() throws RecognitionException {
|
|
return packageName(0);
|
|
}
|
|
|
|
private PackageNameContext packageName(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState);
|
|
PackageNameContext _prevctx = _localctx;
|
|
int _startState = 50;
|
|
enterRecursionRule(_localctx, 50, RULE_packageName, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(665);
|
|
match(Identifier);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(672);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new PackageNameContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_packageName);
|
|
setState(667);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(668);
|
|
match(DOT);
|
|
setState(669);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
}
|
|
setState(674);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public PackageOrTypeNameContext packageOrTypeName() {
|
|
return getRuleContext(PackageOrTypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TypeNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeName; }
|
|
}
|
|
|
|
public final TypeNameContext typeName() throws RecognitionException {
|
|
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
|
|
enterRule(_localctx, 52, RULE_typeName);
|
|
try {
|
|
setState(680);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(675);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(676);
|
|
packageOrTypeName(0);
|
|
setState(677);
|
|
match(DOT);
|
|
setState(678);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PackageOrTypeNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public PackageOrTypeNameContext packageOrTypeName() {
|
|
return getRuleContext(PackageOrTypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_packageOrTypeName; }
|
|
}
|
|
|
|
public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
|
|
return packageOrTypeName(0);
|
|
}
|
|
|
|
private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState);
|
|
PackageOrTypeNameContext _prevctx = _localctx;
|
|
int _startState = 54;
|
|
enterRecursionRule(_localctx, 54, RULE_packageOrTypeName, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(683);
|
|
match(Identifier);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(690);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
|
|
setState(685);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(686);
|
|
match(DOT);
|
|
setState(687);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
}
|
|
setState(692);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,33,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExpressionNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public AmbiguousNameContext ambiguousName() {
|
|
return getRuleContext(AmbiguousNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expressionName; }
|
|
}
|
|
|
|
public final ExpressionNameContext expressionName() throws RecognitionException {
|
|
ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
|
|
enterRule(_localctx, 56, RULE_expressionName);
|
|
try {
|
|
setState(698);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(693);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(694);
|
|
ambiguousName(0);
|
|
setState(695);
|
|
match(DOT);
|
|
setState(696);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public MethodNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodName; }
|
|
}
|
|
|
|
public final MethodNameContext methodName() throws RecognitionException {
|
|
MethodNameContext _localctx = new MethodNameContext(_ctx, getState());
|
|
enterRule(_localctx, 58, RULE_methodName);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(700);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AmbiguousNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public AmbiguousNameContext ambiguousName() {
|
|
return getRuleContext(AmbiguousNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ambiguousName; }
|
|
}
|
|
|
|
public final AmbiguousNameContext ambiguousName() throws RecognitionException {
|
|
return ambiguousName(0);
|
|
}
|
|
|
|
private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
|
|
AmbiguousNameContext _prevctx = _localctx;
|
|
int _startState = 60;
|
|
enterRecursionRule(_localctx, 60, RULE_ambiguousName, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(703);
|
|
match(Identifier);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(710);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new AmbiguousNameContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
|
|
setState(705);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(706);
|
|
match(DOT);
|
|
setState(707);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
}
|
|
setState(712);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,35,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CompilationUnitContext extends ParserRuleContext {
|
|
public TerminalNode EOF() { return getToken(Java8Parser.EOF, 0); }
|
|
public PackageDeclarationContext packageDeclaration() {
|
|
return getRuleContext(PackageDeclarationContext.class,0);
|
|
}
|
|
public List<ImportDeclarationContext> importDeclaration() {
|
|
return getRuleContexts(ImportDeclarationContext.class);
|
|
}
|
|
public ImportDeclarationContext importDeclaration(int i) {
|
|
return getRuleContext(ImportDeclarationContext.class,i);
|
|
}
|
|
public List<TypeDeclarationContext> 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; }
|
|
}
|
|
|
|
public final CompilationUnitContext compilationUnit() throws RecognitionException {
|
|
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
|
|
enterRule(_localctx, 62, RULE_compilationUnit);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(714);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(713);
|
|
packageDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
setState(719);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==IMPORT) {
|
|
{
|
|
{
|
|
setState(716);
|
|
importDeclaration();
|
|
}
|
|
}
|
|
setState(721);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(725);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223371151822749182L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(722);
|
|
typeDeclaration();
|
|
}
|
|
}
|
|
setState(727);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(728);
|
|
match(EOF);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PackageDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode PACKAGE() { return getToken(Java8Parser.PACKAGE, 0); }
|
|
public PackageNameContext packageName() {
|
|
return getRuleContext(PackageNameContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public List<PackageModifierContext> packageModifier() {
|
|
return getRuleContexts(PackageModifierContext.class);
|
|
}
|
|
public PackageModifierContext packageModifier(int i) {
|
|
return getRuleContext(PackageModifierContext.class,i);
|
|
}
|
|
public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_packageDeclaration; }
|
|
}
|
|
|
|
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
|
|
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 64, RULE_packageDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(733);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(730);
|
|
packageModifier();
|
|
}
|
|
}
|
|
setState(735);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(736);
|
|
match(PACKAGE);
|
|
setState(737);
|
|
packageName(0);
|
|
setState(738);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PackageModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public PackageModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_packageModifier; }
|
|
}
|
|
|
|
public final PackageModifierContext packageModifier() throws RecognitionException {
|
|
PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 66, RULE_packageModifier);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(740);
|
|
annotation();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ImportDeclarationContext extends ParserRuleContext {
|
|
public SingleTypeImportDeclarationContext singleTypeImportDeclaration() {
|
|
return getRuleContext(SingleTypeImportDeclarationContext.class,0);
|
|
}
|
|
public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() {
|
|
return getRuleContext(TypeImportOnDemandDeclarationContext.class,0);
|
|
}
|
|
public SingleStaticImportDeclarationContext singleStaticImportDeclaration() {
|
|
return getRuleContext(SingleStaticImportDeclarationContext.class,0);
|
|
}
|
|
public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() {
|
|
return getRuleContext(StaticImportOnDemandDeclarationContext.class,0);
|
|
}
|
|
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_importDeclaration; }
|
|
}
|
|
|
|
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
|
|
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 68, RULE_importDeclaration);
|
|
try {
|
|
setState(746);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(742);
|
|
singleTypeImportDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(743);
|
|
typeImportOnDemandDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(744);
|
|
singleStaticImportDeclaration();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(745);
|
|
staticImportOnDemandDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SingleTypeImportDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; }
|
|
}
|
|
|
|
public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
|
|
SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 70, RULE_singleTypeImportDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(748);
|
|
match(IMPORT);
|
|
setState(749);
|
|
typeName();
|
|
setState(750);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); }
|
|
public PackageOrTypeNameContext packageOrTypeName() {
|
|
return getRuleContext(PackageOrTypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; }
|
|
}
|
|
|
|
public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
|
|
TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 72, RULE_typeImportOnDemandDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(752);
|
|
match(IMPORT);
|
|
setState(753);
|
|
packageOrTypeName(0);
|
|
setState(754);
|
|
match(DOT);
|
|
setState(755);
|
|
match(MUL);
|
|
setState(756);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SingleStaticImportDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; }
|
|
}
|
|
|
|
public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
|
|
SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 74, RULE_singleStaticImportDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(758);
|
|
match(IMPORT);
|
|
setState(759);
|
|
match(STATIC);
|
|
setState(760);
|
|
typeName();
|
|
setState(761);
|
|
match(DOT);
|
|
setState(762);
|
|
match(Identifier);
|
|
setState(763);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode IMPORT() { return getToken(Java8Parser.IMPORT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; }
|
|
}
|
|
|
|
public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
|
|
StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 76, RULE_staticImportOnDemandDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(765);
|
|
match(IMPORT);
|
|
setState(766);
|
|
match(STATIC);
|
|
setState(767);
|
|
typeName();
|
|
setState(768);
|
|
match(DOT);
|
|
setState(769);
|
|
match(MUL);
|
|
setState(770);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeDeclarationContext extends ParserRuleContext {
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeDeclaration; }
|
|
}
|
|
|
|
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
|
|
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 78, RULE_typeDeclaration);
|
|
try {
|
|
setState(775);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(772);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(773);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(774);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassDeclarationContext extends ParserRuleContext {
|
|
public NormalClassDeclarationContext normalClassDeclaration() {
|
|
return getRuleContext(NormalClassDeclarationContext.class,0);
|
|
}
|
|
public EnumDeclarationContext enumDeclaration() {
|
|
return getRuleContext(EnumDeclarationContext.class,0);
|
|
}
|
|
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classDeclaration; }
|
|
}
|
|
|
|
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
|
|
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 80, RULE_classDeclaration);
|
|
try {
|
|
setState(779);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(777);
|
|
normalClassDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(778);
|
|
enumDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NormalClassDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public List<ClassModifierContext> classModifier() {
|
|
return getRuleContexts(ClassModifierContext.class);
|
|
}
|
|
public ClassModifierContext classModifier(int i) {
|
|
return getRuleContext(ClassModifierContext.class,i);
|
|
}
|
|
public TypeParametersContext typeParameters() {
|
|
return getRuleContext(TypeParametersContext.class,0);
|
|
}
|
|
public SuperclassContext superclass() {
|
|
return getRuleContext(SuperclassContext.class,0);
|
|
}
|
|
public SuperinterfacesContext superinterfaces() {
|
|
return getRuleContext(SuperinterfacesContext.class,0);
|
|
}
|
|
public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
|
|
}
|
|
|
|
public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
|
|
NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 82, RULE_normalClassDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(784);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 884763525122L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(781);
|
|
classModifier();
|
|
}
|
|
}
|
|
setState(786);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(787);
|
|
match(CLASS);
|
|
setState(788);
|
|
match(Identifier);
|
|
setState(790);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(789);
|
|
typeParameters();
|
|
}
|
|
}
|
|
|
|
setState(793);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS) {
|
|
{
|
|
setState(792);
|
|
superclass();
|
|
}
|
|
}
|
|
|
|
setState(796);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==IMPLEMENTS) {
|
|
{
|
|
setState(795);
|
|
superinterfaces();
|
|
}
|
|
}
|
|
|
|
setState(798);
|
|
classBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); }
|
|
public ClassModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classModifier; }
|
|
}
|
|
|
|
public final ClassModifierContext classModifier() throws RecognitionException {
|
|
ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 84, RULE_classModifier);
|
|
try {
|
|
setState(808);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(800);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(801);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case PROTECTED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(802);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case PRIVATE:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(803);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(804);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(805);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case FINAL:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(806);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
case STRICTFP:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(807);
|
|
match(STRICTFP);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeParametersContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java8Parser.LT, 0); }
|
|
public TypeParameterListContext typeParameterList() {
|
|
return getRuleContext(TypeParameterListContext.class,0);
|
|
}
|
|
public TerminalNode GT() { return getToken(Java8Parser.GT, 0); }
|
|
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeParameters; }
|
|
}
|
|
|
|
public final TypeParametersContext typeParameters() throws RecognitionException {
|
|
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
|
|
enterRule(_localctx, 86, RULE_typeParameters);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(810);
|
|
match(LT);
|
|
setState(811);
|
|
typeParameterList();
|
|
setState(812);
|
|
match(GT);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeParameterListContext extends ParserRuleContext {
|
|
public List<TypeParameterContext> typeParameter() {
|
|
return getRuleContexts(TypeParameterContext.class);
|
|
}
|
|
public TypeParameterContext typeParameter(int i) {
|
|
return getRuleContext(TypeParameterContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeParameterList; }
|
|
}
|
|
|
|
public final TypeParameterListContext typeParameterList() throws RecognitionException {
|
|
TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
|
|
enterRule(_localctx, 88, RULE_typeParameterList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(814);
|
|
typeParameter();
|
|
setState(819);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(815);
|
|
match(COMMA);
|
|
setState(816);
|
|
typeParameter();
|
|
}
|
|
}
|
|
setState(821);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SuperclassContext extends ParserRuleContext {
|
|
public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); }
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public SuperclassContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_superclass; }
|
|
}
|
|
|
|
public final SuperclassContext superclass() throws RecognitionException {
|
|
SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
|
|
enterRule(_localctx, 90, RULE_superclass);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(822);
|
|
match(EXTENDS);
|
|
setState(823);
|
|
classType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SuperinterfacesContext extends ParserRuleContext {
|
|
public TerminalNode IMPLEMENTS() { return getToken(Java8Parser.IMPLEMENTS, 0); }
|
|
public InterfaceTypeListContext interfaceTypeList() {
|
|
return getRuleContext(InterfaceTypeListContext.class,0);
|
|
}
|
|
public SuperinterfacesContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_superinterfaces; }
|
|
}
|
|
|
|
public final SuperinterfacesContext superinterfaces() throws RecognitionException {
|
|
SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
|
|
enterRule(_localctx, 92, RULE_superinterfaces);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(825);
|
|
match(IMPLEMENTS);
|
|
setState(826);
|
|
interfaceTypeList();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceTypeListContext extends ParserRuleContext {
|
|
public List<InterfaceTypeContext> interfaceType() {
|
|
return getRuleContexts(InterfaceTypeContext.class);
|
|
}
|
|
public InterfaceTypeContext interfaceType(int i) {
|
|
return getRuleContext(InterfaceTypeContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceTypeList; }
|
|
}
|
|
|
|
public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
|
|
InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
|
|
enterRule(_localctx, 94, RULE_interfaceTypeList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(828);
|
|
interfaceType();
|
|
setState(833);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(829);
|
|
match(COMMA);
|
|
setState(830);
|
|
interfaceType();
|
|
}
|
|
}
|
|
setState(835);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public List<ClassBodyDeclarationContext> 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; }
|
|
}
|
|
|
|
public final ClassBodyContext classBody() throws RecognitionException {
|
|
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 96, RULE_classBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(836);
|
|
match(LBRACE);
|
|
setState(840);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8645991068613655766L) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 51539607553L) != 0)) {
|
|
{
|
|
{
|
|
setState(837);
|
|
classBodyDeclaration();
|
|
}
|
|
}
|
|
setState(842);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(843);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassBodyDeclarationContext extends ParserRuleContext {
|
|
public ClassMemberDeclarationContext classMemberDeclaration() {
|
|
return getRuleContext(ClassMemberDeclarationContext.class,0);
|
|
}
|
|
public InstanceInitializerContext instanceInitializer() {
|
|
return getRuleContext(InstanceInitializerContext.class,0);
|
|
}
|
|
public StaticInitializerContext staticInitializer() {
|
|
return getRuleContext(StaticInitializerContext.class,0);
|
|
}
|
|
public ConstructorDeclarationContext constructorDeclaration() {
|
|
return getRuleContext(ConstructorDeclarationContext.class,0);
|
|
}
|
|
public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
|
|
}
|
|
|
|
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
|
|
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 98, RULE_classBodyDeclaration);
|
|
try {
|
|
setState(849);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(845);
|
|
classMemberDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(846);
|
|
instanceInitializer();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(847);
|
|
staticInitializer();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(848);
|
|
constructorDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassMemberDeclarationContext extends ParserRuleContext {
|
|
public FieldDeclarationContext fieldDeclaration() {
|
|
return getRuleContext(FieldDeclarationContext.class,0);
|
|
}
|
|
public MethodDeclarationContext methodDeclaration() {
|
|
return getRuleContext(MethodDeclarationContext.class,0);
|
|
}
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classMemberDeclaration; }
|
|
}
|
|
|
|
public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
|
|
ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 100, RULE_classMemberDeclaration);
|
|
try {
|
|
setState(856);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(851);
|
|
fieldDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(852);
|
|
methodDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(853);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(854);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(855);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FieldDeclarationContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorListContext variableDeclaratorList() {
|
|
return getRuleContext(VariableDeclaratorListContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public List<FieldModifierContext> fieldModifier() {
|
|
return getRuleContexts(FieldModifierContext.class);
|
|
}
|
|
public FieldModifierContext fieldModifier(int i) {
|
|
return getRuleContext(FieldModifierContext.class,i);
|
|
}
|
|
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
|
|
}
|
|
|
|
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
|
|
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 102, RULE_fieldDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(861);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 633653705310208L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(858);
|
|
fieldModifier();
|
|
}
|
|
}
|
|
setState(863);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(864);
|
|
unannType();
|
|
setState(865);
|
|
variableDeclaratorList();
|
|
setState(866);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FieldModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); }
|
|
public TerminalNode TRANSIENT() { return getToken(Java8Parser.TRANSIENT, 0); }
|
|
public TerminalNode VOLATILE() { return getToken(Java8Parser.VOLATILE, 0); }
|
|
public FieldModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldModifier; }
|
|
}
|
|
|
|
public final FieldModifierContext fieldModifier() throws RecognitionException {
|
|
FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 104, RULE_fieldModifier);
|
|
try {
|
|
setState(876);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(868);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(869);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case PROTECTED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(870);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case PRIVATE:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(871);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(872);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case FINAL:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(873);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
case TRANSIENT:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(874);
|
|
match(TRANSIENT);
|
|
}
|
|
break;
|
|
case VOLATILE:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(875);
|
|
match(VOLATILE);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableDeclaratorListContext extends ParserRuleContext {
|
|
public List<VariableDeclaratorContext> variableDeclarator() {
|
|
return getRuleContexts(VariableDeclaratorContext.class);
|
|
}
|
|
public VariableDeclaratorContext variableDeclarator(int i) {
|
|
return getRuleContext(VariableDeclaratorContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
|
|
}
|
|
|
|
public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
|
|
VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
|
|
enterRule(_localctx, 106, RULE_variableDeclaratorList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(878);
|
|
variableDeclarator();
|
|
setState(883);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(879);
|
|
match(COMMA);
|
|
setState(880);
|
|
variableDeclarator();
|
|
}
|
|
}
|
|
setState(885);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableDeclaratorContext extends ParserRuleContext {
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 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; }
|
|
}
|
|
|
|
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
|
|
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
|
|
enterRule(_localctx, 108, RULE_variableDeclarator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(886);
|
|
variableDeclaratorId();
|
|
setState(889);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==ASSIGN) {
|
|
{
|
|
setState(887);
|
|
match(ASSIGN);
|
|
setState(888);
|
|
variableInitializer();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableDeclaratorIdContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
|
|
}
|
|
|
|
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
|
|
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
|
|
enterRule(_localctx, 110, RULE_variableDeclaratorId);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(891);
|
|
match(Identifier);
|
|
setState(893);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACK || _la==AT) {
|
|
{
|
|
setState(892);
|
|
dims();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableInitializerContext extends ParserRuleContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public ArrayInitializerContext arrayInitializer() {
|
|
return getRuleContext(ArrayInitializerContext.class,0);
|
|
}
|
|
public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableInitializer; }
|
|
}
|
|
|
|
public final VariableInitializerContext variableInitializer() throws RecognitionException {
|
|
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 112, RULE_variableInitializer);
|
|
try {
|
|
setState(897);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
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 IntegerLiteral:
|
|
case FloatingPointLiteral:
|
|
case BooleanLiteral:
|
|
case CharacterLiteral:
|
|
case StringLiteral:
|
|
case NullLiteral:
|
|
case LPAREN:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case Identifier:
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(895);
|
|
expression();
|
|
}
|
|
break;
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(896);
|
|
arrayInitializer();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannTypeContext extends ParserRuleContext {
|
|
public UnannPrimitiveTypeContext unannPrimitiveType() {
|
|
return getRuleContext(UnannPrimitiveTypeContext.class,0);
|
|
}
|
|
public UnannReferenceTypeContext unannReferenceType() {
|
|
return getRuleContext(UnannReferenceTypeContext.class,0);
|
|
}
|
|
public UnannTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannType; }
|
|
}
|
|
|
|
public final UnannTypeContext unannType() throws RecognitionException {
|
|
UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 114, RULE_unannType);
|
|
try {
|
|
setState(901);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(899);
|
|
unannPrimitiveType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(900);
|
|
unannReferenceType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannPrimitiveTypeContext extends ParserRuleContext {
|
|
public NumericTypeContext numericType() {
|
|
return getRuleContext(NumericTypeContext.class,0);
|
|
}
|
|
public TerminalNode BOOLEAN() { return getToken(Java8Parser.BOOLEAN, 0); }
|
|
public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannPrimitiveType; }
|
|
}
|
|
|
|
public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
|
|
UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 116, RULE_unannPrimitiveType);
|
|
try {
|
|
setState(905);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(903);
|
|
numericType();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(904);
|
|
match(BOOLEAN);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannReferenceTypeContext extends ParserRuleContext {
|
|
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public UnannTypeVariableContext unannTypeVariable() {
|
|
return getRuleContext(UnannTypeVariableContext.class,0);
|
|
}
|
|
public UnannArrayTypeContext unannArrayType() {
|
|
return getRuleContext(UnannArrayTypeContext.class,0);
|
|
}
|
|
public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannReferenceType; }
|
|
}
|
|
|
|
public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
|
|
UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 118, RULE_unannReferenceType);
|
|
try {
|
|
setState(910);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(907);
|
|
unannClassOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(908);
|
|
unannTypeVariable();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(909);
|
|
unannArrayType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() {
|
|
return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class);
|
|
}
|
|
public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) {
|
|
return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i);
|
|
}
|
|
public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() {
|
|
return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class);
|
|
}
|
|
public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) {
|
|
return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i);
|
|
}
|
|
public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; }
|
|
}
|
|
|
|
public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
|
|
UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 120, RULE_unannClassOrInterfaceType);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(914);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(912);
|
|
unannClassType_lfno_unannClassOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(913);
|
|
unannInterfaceType_lfno_unannClassOrInterfaceType();
|
|
}
|
|
break;
|
|
}
|
|
setState(920);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
setState(918);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(916);
|
|
unannClassType_lf_unannClassOrInterfaceType();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(917);
|
|
unannInterfaceType_lf_unannClassOrInterfaceType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(922);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannClassTypeContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public UnannClassTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannClassType; }
|
|
}
|
|
|
|
public final UnannClassTypeContext unannClassType() throws RecognitionException {
|
|
UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 122, RULE_unannClassType);
|
|
int _la;
|
|
try {
|
|
setState(939);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(923);
|
|
match(Identifier);
|
|
setState(925);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(924);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(927);
|
|
unannClassOrInterfaceType();
|
|
setState(928);
|
|
match(DOT);
|
|
setState(932);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(929);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(934);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(935);
|
|
match(Identifier);
|
|
setState(937);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(936);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; }
|
|
}
|
|
|
|
public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
|
|
UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 124, RULE_unannClassType_lf_unannClassOrInterfaceType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(941);
|
|
match(DOT);
|
|
setState(945);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(942);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(947);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(948);
|
|
match(Identifier);
|
|
setState(950);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(949);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; }
|
|
}
|
|
|
|
public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
|
|
UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 126, RULE_unannClassType_lfno_unannClassOrInterfaceType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(952);
|
|
match(Identifier);
|
|
setState(954);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(953);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannInterfaceTypeContext extends ParserRuleContext {
|
|
public UnannClassTypeContext unannClassType() {
|
|
return getRuleContext(UnannClassTypeContext.class,0);
|
|
}
|
|
public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannInterfaceType; }
|
|
}
|
|
|
|
public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException {
|
|
UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 128, RULE_unannInterfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(956);
|
|
unannClassType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; }
|
|
}
|
|
|
|
public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
|
|
UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 130, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(958);
|
|
unannClassType_lf_unannClassOrInterfaceType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; }
|
|
}
|
|
|
|
public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
|
|
UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 132, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(960);
|
|
unannClassType_lfno_unannClassOrInterfaceType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannTypeVariableContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannTypeVariable; }
|
|
}
|
|
|
|
public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
|
|
UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
|
|
enterRule(_localctx, 134, RULE_unannTypeVariable);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(962);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnannArrayTypeContext extends ParserRuleContext {
|
|
public UnannPrimitiveTypeContext unannPrimitiveType() {
|
|
return getRuleContext(UnannPrimitiveTypeContext.class,0);
|
|
}
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
|
|
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public UnannTypeVariableContext unannTypeVariable() {
|
|
return getRuleContext(UnannTypeVariableContext.class,0);
|
|
}
|
|
public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unannArrayType; }
|
|
}
|
|
|
|
public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
|
|
UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 136, RULE_unannArrayType);
|
|
try {
|
|
setState(973);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(964);
|
|
unannPrimitiveType();
|
|
setState(965);
|
|
dims();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(967);
|
|
unannClassOrInterfaceType();
|
|
setState(968);
|
|
dims();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(970);
|
|
unannTypeVariable();
|
|
setState(971);
|
|
dims();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodDeclarationContext extends ParserRuleContext {
|
|
public MethodHeaderContext methodHeader() {
|
|
return getRuleContext(MethodHeaderContext.class,0);
|
|
}
|
|
public MethodBodyContext methodBody() {
|
|
return getRuleContext(MethodBodyContext.class,0);
|
|
}
|
|
public List<MethodModifierContext> methodModifier() {
|
|
return getRuleContexts(MethodModifierContext.class);
|
|
}
|
|
public MethodModifierContext methodModifier(int i) {
|
|
return getRuleContext(MethodModifierContext.class,i);
|
|
}
|
|
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
|
|
}
|
|
|
|
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
|
|
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 138, RULE_methodDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(978);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 5283883778050L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(975);
|
|
methodModifier();
|
|
}
|
|
}
|
|
setState(980);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(981);
|
|
methodHeader();
|
|
setState(982);
|
|
methodBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); }
|
|
public TerminalNode SYNCHRONIZED() { return getToken(Java8Parser.SYNCHRONIZED, 0); }
|
|
public TerminalNode NATIVE() { return getToken(Java8Parser.NATIVE, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); }
|
|
public MethodModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodModifier; }
|
|
}
|
|
|
|
public final MethodModifierContext methodModifier() throws RecognitionException {
|
|
MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 140, RULE_methodModifier);
|
|
try {
|
|
setState(994);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(984);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(985);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case PROTECTED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(986);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case PRIVATE:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(987);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(988);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(989);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case FINAL:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(990);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
case SYNCHRONIZED:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(991);
|
|
match(SYNCHRONIZED);
|
|
}
|
|
break;
|
|
case NATIVE:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(992);
|
|
match(NATIVE);
|
|
}
|
|
break;
|
|
case STRICTFP:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(993);
|
|
match(STRICTFP);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodHeaderContext extends ParserRuleContext {
|
|
public ResultContext result() {
|
|
return getRuleContext(ResultContext.class,0);
|
|
}
|
|
public MethodDeclaratorContext methodDeclarator() {
|
|
return getRuleContext(MethodDeclaratorContext.class,0);
|
|
}
|
|
public Throws_Context throws_() {
|
|
return getRuleContext(Throws_Context.class,0);
|
|
}
|
|
public TypeParametersContext typeParameters() {
|
|
return getRuleContext(TypeParametersContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodHeader; }
|
|
}
|
|
|
|
public final MethodHeaderContext methodHeader() throws RecognitionException {
|
|
MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
|
|
enterRule(_localctx, 142, RULE_methodHeader);
|
|
int _la;
|
|
try {
|
|
setState(1013);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
case VOID:
|
|
case Identifier:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(996);
|
|
result();
|
|
setState(997);
|
|
methodDeclarator();
|
|
setState(999);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(998);
|
|
throws_();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case LT:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1001);
|
|
typeParameters();
|
|
setState(1005);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(1002);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(1007);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1008);
|
|
result();
|
|
setState(1009);
|
|
methodDeclarator();
|
|
setState(1011);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(1010);
|
|
throws_();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ResultContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); }
|
|
public ResultContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_result; }
|
|
}
|
|
|
|
public final ResultContext result() throws RecognitionException {
|
|
ResultContext _localctx = new ResultContext(_ctx, getState());
|
|
enterRule(_localctx, 144, RULE_result);
|
|
try {
|
|
setState(1017);
|
|
_errHandler.sync(this);
|
|
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(1015);
|
|
unannType();
|
|
}
|
|
break;
|
|
case VOID:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1016);
|
|
match(VOID);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodDeclaratorContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public FormalParameterListContext formalParameterList() {
|
|
return getRuleContext(FormalParameterListContext.class,0);
|
|
}
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodDeclarator; }
|
|
}
|
|
|
|
public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
|
|
MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
|
|
enterRule(_localctx, 146, RULE_methodDeclarator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1019);
|
|
match(Identifier);
|
|
setState(1020);
|
|
match(LPAREN);
|
|
setState(1022);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 138111369512L) != 0) || _la==Identifier || _la==AT) {
|
|
{
|
|
setState(1021);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
setState(1024);
|
|
match(RPAREN);
|
|
setState(1026);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACK || _la==AT) {
|
|
{
|
|
setState(1025);
|
|
dims();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FormalParameterListContext extends ParserRuleContext {
|
|
public ReceiverParameterContext receiverParameter() {
|
|
return getRuleContext(ReceiverParameterContext.class,0);
|
|
}
|
|
public FormalParametersContext formalParameters() {
|
|
return getRuleContext(FormalParametersContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); }
|
|
public LastFormalParameterContext lastFormalParameter() {
|
|
return getRuleContext(LastFormalParameterContext.class,0);
|
|
}
|
|
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_formalParameterList; }
|
|
}
|
|
|
|
public final FormalParameterListContext formalParameterList() throws RecognitionException {
|
|
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
|
|
enterRule(_localctx, 148, RULE_formalParameterList);
|
|
try {
|
|
setState(1034);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1028);
|
|
receiverParameter();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1029);
|
|
formalParameters();
|
|
setState(1030);
|
|
match(COMMA);
|
|
setState(1031);
|
|
lastFormalParameter();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1033);
|
|
lastFormalParameter();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FormalParametersContext extends ParserRuleContext {
|
|
public List<FormalParameterContext> formalParameter() {
|
|
return getRuleContexts(FormalParameterContext.class);
|
|
}
|
|
public FormalParameterContext formalParameter(int i) {
|
|
return getRuleContext(FormalParameterContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public ReceiverParameterContext receiverParameter() {
|
|
return getRuleContext(ReceiverParameterContext.class,0);
|
|
}
|
|
public FormalParametersContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_formalParameters; }
|
|
}
|
|
|
|
public final FormalParametersContext formalParameters() throws RecognitionException {
|
|
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
|
|
enterRule(_localctx, 150, RULE_formalParameters);
|
|
try {
|
|
int _alt;
|
|
setState(1052);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1036);
|
|
formalParameter();
|
|
setState(1041);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1037);
|
|
match(COMMA);
|
|
setState(1038);
|
|
formalParameter();
|
|
}
|
|
}
|
|
}
|
|
setState(1043);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,83,_ctx);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1044);
|
|
receiverParameter();
|
|
setState(1049);
|
|
_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(1045);
|
|
match(COMMA);
|
|
setState(1046);
|
|
formalParameter();
|
|
}
|
|
}
|
|
}
|
|
setState(1051);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,84,_ctx);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FormalParameterContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> 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; }
|
|
}
|
|
|
|
public final FormalParameterContext formalParameter() throws RecognitionException {
|
|
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 152, RULE_formalParameter);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1057);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1054);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1059);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1060);
|
|
unannType();
|
|
setState(1061);
|
|
variableDeclaratorId();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); }
|
|
public VariableModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableModifier; }
|
|
}
|
|
|
|
public final VariableModifierContext variableModifier() throws RecognitionException {
|
|
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 154, RULE_variableModifier);
|
|
try {
|
|
setState(1065);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1063);
|
|
annotation();
|
|
}
|
|
break;
|
|
case FINAL:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1064);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LastFormalParameterContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public TerminalNode ELLIPSIS() { return getToken(Java8Parser.ELLIPSIS, 0); }
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public FormalParameterContext formalParameter() {
|
|
return getRuleContext(FormalParameterContext.class,0);
|
|
}
|
|
public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
|
|
}
|
|
|
|
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
|
|
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 156, RULE_lastFormalParameter);
|
|
int _la;
|
|
try {
|
|
setState(1084);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1070);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1067);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1072);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1073);
|
|
unannType();
|
|
setState(1077);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(1074);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(1079);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1080);
|
|
match(ELLIPSIS);
|
|
setState(1081);
|
|
variableDeclaratorId();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1083);
|
|
formalParameter();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReceiverParameterContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_receiverParameter; }
|
|
}
|
|
|
|
public final ReceiverParameterContext receiverParameter() throws RecognitionException {
|
|
ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 158, RULE_receiverParameter);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1089);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(1086);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(1091);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1092);
|
|
unannType();
|
|
setState(1095);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==Identifier) {
|
|
{
|
|
setState(1093);
|
|
match(Identifier);
|
|
setState(1094);
|
|
match(DOT);
|
|
}
|
|
}
|
|
|
|
setState(1097);
|
|
match(THIS);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Throws_Context extends ParserRuleContext {
|
|
public TerminalNode THROWS() { return getToken(Java8Parser.THROWS, 0); }
|
|
public ExceptionTypeListContext exceptionTypeList() {
|
|
return getRuleContext(ExceptionTypeListContext.class,0);
|
|
}
|
|
public Throws_Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_throws_; }
|
|
}
|
|
|
|
public final Throws_Context throws_() throws RecognitionException {
|
|
Throws_Context _localctx = new Throws_Context(_ctx, getState());
|
|
enterRule(_localctx, 160, RULE_throws_);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1099);
|
|
match(THROWS);
|
|
setState(1100);
|
|
exceptionTypeList();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExceptionTypeListContext extends ParserRuleContext {
|
|
public List<ExceptionTypeContext> exceptionType() {
|
|
return getRuleContexts(ExceptionTypeContext.class);
|
|
}
|
|
public ExceptionTypeContext exceptionType(int i) {
|
|
return getRuleContext(ExceptionTypeContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_exceptionTypeList; }
|
|
}
|
|
|
|
public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
|
|
ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
|
|
enterRule(_localctx, 162, RULE_exceptionTypeList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1102);
|
|
exceptionType();
|
|
setState(1107);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1103);
|
|
match(COMMA);
|
|
setState(1104);
|
|
exceptionType();
|
|
}
|
|
}
|
|
setState(1109);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExceptionTypeContext extends ParserRuleContext {
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public TypeVariableContext typeVariable() {
|
|
return getRuleContext(TypeVariableContext.class,0);
|
|
}
|
|
public ExceptionTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_exceptionType; }
|
|
}
|
|
|
|
public final ExceptionTypeContext exceptionType() throws RecognitionException {
|
|
ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 164, RULE_exceptionType);
|
|
try {
|
|
setState(1112);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1110);
|
|
classType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1111);
|
|
typeVariable();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodBodyContext extends ParserRuleContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public MethodBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodBody; }
|
|
}
|
|
|
|
public final MethodBodyContext methodBody() throws RecognitionException {
|
|
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 166, RULE_methodBody);
|
|
try {
|
|
setState(1116);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1114);
|
|
block();
|
|
}
|
|
break;
|
|
case SEMI:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1115);
|
|
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;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InstanceInitializerContext extends ParserRuleContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public InstanceInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_instanceInitializer; }
|
|
}
|
|
|
|
public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
|
|
InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 168, RULE_instanceInitializer);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1118);
|
|
block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StaticInitializerContext extends ParserRuleContext {
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public StaticInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_staticInitializer; }
|
|
}
|
|
|
|
public final StaticInitializerContext staticInitializer() throws RecognitionException {
|
|
StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 170, RULE_staticInitializer);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1120);
|
|
match(STATIC);
|
|
setState(1121);
|
|
block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructorDeclarationContext extends ParserRuleContext {
|
|
public ConstructorDeclaratorContext constructorDeclarator() {
|
|
return getRuleContext(ConstructorDeclaratorContext.class,0);
|
|
}
|
|
public ConstructorBodyContext constructorBody() {
|
|
return getRuleContext(ConstructorBodyContext.class,0);
|
|
}
|
|
public List<ConstructorModifierContext> constructorModifier() {
|
|
return getRuleContexts(ConstructorModifierContext.class);
|
|
}
|
|
public ConstructorModifierContext constructorModifier(int i) {
|
|
return getRuleContext(ConstructorModifierContext.class,i);
|
|
}
|
|
public Throws_Context throws_() {
|
|
return getRuleContext(Throws_Context.class,0);
|
|
}
|
|
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
|
|
}
|
|
|
|
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
|
|
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 172, RULE_constructorDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1126);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 60129542144L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(1123);
|
|
constructorModifier();
|
|
}
|
|
}
|
|
setState(1128);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1129);
|
|
constructorDeclarator();
|
|
setState(1131);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(1130);
|
|
throws_();
|
|
}
|
|
}
|
|
|
|
setState(1133);
|
|
constructorBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructorModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); }
|
|
public ConstructorModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructorModifier; }
|
|
}
|
|
|
|
public final ConstructorModifierContext constructorModifier() throws RecognitionException {
|
|
ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 174, RULE_constructorModifier);
|
|
try {
|
|
setState(1139);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1135);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1136);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case PROTECTED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1137);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case PRIVATE:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1138);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructorDeclaratorContext extends ParserRuleContext {
|
|
public SimpleTypeNameContext simpleTypeName() {
|
|
return getRuleContext(SimpleTypeNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TypeParametersContext typeParameters() {
|
|
return getRuleContext(TypeParametersContext.class,0);
|
|
}
|
|
public FormalParameterListContext formalParameterList() {
|
|
return getRuleContext(FormalParameterListContext.class,0);
|
|
}
|
|
public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructorDeclarator; }
|
|
}
|
|
|
|
public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
|
|
ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
|
|
enterRule(_localctx, 176, RULE_constructorDeclarator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1142);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1141);
|
|
typeParameters();
|
|
}
|
|
}
|
|
|
|
setState(1144);
|
|
simpleTypeName();
|
|
setState(1145);
|
|
match(LPAREN);
|
|
setState(1147);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 138111369512L) != 0) || _la==Identifier || _la==AT) {
|
|
{
|
|
setState(1146);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
setState(1149);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SimpleTypeNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_simpleTypeName; }
|
|
}
|
|
|
|
public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
|
|
SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
|
|
enterRule(_localctx, 178, RULE_simpleTypeName);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1151);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructorBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
|
|
return getRuleContext(ExplicitConstructorInvocationContext.class,0);
|
|
}
|
|
public BlockStatementsContext blockStatements() {
|
|
return getRuleContext(BlockStatementsContext.class,0);
|
|
}
|
|
public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructorBody; }
|
|
}
|
|
|
|
public final ConstructorBodyContext constructorBody() throws RecognitionException {
|
|
ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 180, RULE_constructorBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1153);
|
|
match(LBRACE);
|
|
setState(1155);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1154);
|
|
explicitConstructorInvocation();
|
|
}
|
|
break;
|
|
}
|
|
setState(1158);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8359349417232995522L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1157);
|
|
blockStatements();
|
|
}
|
|
}
|
|
|
|
setState(1160);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
|
|
}
|
|
|
|
public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
|
|
ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
|
|
enterRule(_localctx, 182, RULE_explicitConstructorInvocation);
|
|
int _la;
|
|
try {
|
|
setState(1208);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1163);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1162);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1165);
|
|
match(THIS);
|
|
setState(1166);
|
|
match(LPAREN);
|
|
setState(1168);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1167);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(1170);
|
|
match(RPAREN);
|
|
setState(1171);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1173);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1172);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1175);
|
|
match(SUPER);
|
|
setState(1176);
|
|
match(LPAREN);
|
|
setState(1178);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1177);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(1180);
|
|
match(RPAREN);
|
|
setState(1181);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1182);
|
|
expressionName();
|
|
setState(1183);
|
|
match(DOT);
|
|
setState(1185);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1184);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1187);
|
|
match(SUPER);
|
|
setState(1188);
|
|
match(LPAREN);
|
|
setState(1190);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1189);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(1192);
|
|
match(RPAREN);
|
|
setState(1193);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1195);
|
|
primary();
|
|
setState(1196);
|
|
match(DOT);
|
|
setState(1198);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1197);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1200);
|
|
match(SUPER);
|
|
setState(1201);
|
|
match(LPAREN);
|
|
setState(1203);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1202);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(1205);
|
|
match(RPAREN);
|
|
setState(1206);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode ENUM() { return getToken(Java8Parser.ENUM, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public EnumBodyContext enumBody() {
|
|
return getRuleContext(EnumBodyContext.class,0);
|
|
}
|
|
public List<ClassModifierContext> classModifier() {
|
|
return getRuleContexts(ClassModifierContext.class);
|
|
}
|
|
public ClassModifierContext classModifier(int i) {
|
|
return getRuleContext(ClassModifierContext.class,i);
|
|
}
|
|
public SuperinterfacesContext superinterfaces() {
|
|
return getRuleContext(SuperinterfacesContext.class,0);
|
|
}
|
|
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
|
|
}
|
|
|
|
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
|
|
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 184, RULE_enumDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1213);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 884763525122L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(1210);
|
|
classModifier();
|
|
}
|
|
}
|
|
setState(1215);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1216);
|
|
match(ENUM);
|
|
setState(1217);
|
|
match(Identifier);
|
|
setState(1219);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==IMPLEMENTS) {
|
|
{
|
|
setState(1218);
|
|
superinterfaces();
|
|
}
|
|
}
|
|
|
|
setState(1221);
|
|
enumBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public EnumConstantListContext enumConstantList() {
|
|
return getRuleContext(EnumConstantListContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); }
|
|
public EnumBodyDeclarationsContext enumBodyDeclarations() {
|
|
return getRuleContext(EnumBodyDeclarationsContext.class,0);
|
|
}
|
|
public EnumBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumBody; }
|
|
}
|
|
|
|
public final EnumBodyContext enumBody() throws RecognitionException {
|
|
EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 186, RULE_enumBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1223);
|
|
match(LBRACE);
|
|
setState(1225);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==Identifier || _la==AT) {
|
|
{
|
|
setState(1224);
|
|
enumConstantList();
|
|
}
|
|
}
|
|
|
|
setState(1228);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1227);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
setState(1231);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==SEMI) {
|
|
{
|
|
setState(1230);
|
|
enumBodyDeclarations();
|
|
}
|
|
}
|
|
|
|
setState(1233);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumConstantListContext extends ParserRuleContext {
|
|
public List<EnumConstantContext> enumConstant() {
|
|
return getRuleContexts(EnumConstantContext.class);
|
|
}
|
|
public EnumConstantContext enumConstant(int i) {
|
|
return getRuleContext(EnumConstantContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public EnumConstantListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstantList; }
|
|
}
|
|
|
|
public final EnumConstantListContext enumConstantList() throws RecognitionException {
|
|
EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState());
|
|
enterRule(_localctx, 188, RULE_enumConstantList);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1235);
|
|
enumConstant();
|
|
setState(1240);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1236);
|
|
match(COMMA);
|
|
setState(1237);
|
|
enumConstant();
|
|
}
|
|
}
|
|
}
|
|
setState(1242);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,117,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumConstantContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public List<EnumConstantModifierContext> enumConstantModifier() {
|
|
return getRuleContexts(EnumConstantModifierContext.class);
|
|
}
|
|
public EnumConstantModifierContext enumConstantModifier(int i) {
|
|
return getRuleContext(EnumConstantModifierContext.class,i);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstant; }
|
|
}
|
|
|
|
public final EnumConstantContext enumConstant() throws RecognitionException {
|
|
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
|
|
enterRule(_localctx, 190, RULE_enumConstant);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1246);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(1243);
|
|
enumConstantModifier();
|
|
}
|
|
}
|
|
setState(1248);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1249);
|
|
match(Identifier);
|
|
setState(1255);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LPAREN) {
|
|
{
|
|
setState(1250);
|
|
match(LPAREN);
|
|
setState(1252);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1251);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(1254);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
|
|
setState(1258);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACE) {
|
|
{
|
|
setState(1257);
|
|
classBody();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumConstantModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstantModifier; }
|
|
}
|
|
|
|
public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
|
|
EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 192, RULE_enumConstantModifier);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1260);
|
|
annotation();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumBodyDeclarationsContext extends ParserRuleContext {
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public List<ClassBodyDeclarationContext> 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; }
|
|
}
|
|
|
|
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
|
|
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
|
|
enterRule(_localctx, 194, RULE_enumBodyDeclarations);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1262);
|
|
match(SEMI);
|
|
setState(1266);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8645991068613655766L) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 51539607553L) != 0)) {
|
|
{
|
|
{
|
|
setState(1263);
|
|
classBodyDeclaration();
|
|
}
|
|
}
|
|
setState(1268);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceDeclarationContext extends ParserRuleContext {
|
|
public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
|
|
return getRuleContext(NormalInterfaceDeclarationContext.class,0);
|
|
}
|
|
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
|
|
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
|
|
}
|
|
|
|
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
|
|
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 196, RULE_interfaceDeclaration);
|
|
try {
|
|
setState(1271);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1269);
|
|
normalInterfaceDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1270);
|
|
annotationTypeDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode INTERFACE() { return getToken(Java8Parser.INTERFACE, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public InterfaceBodyContext interfaceBody() {
|
|
return getRuleContext(InterfaceBodyContext.class,0);
|
|
}
|
|
public List<InterfaceModifierContext> interfaceModifier() {
|
|
return getRuleContexts(InterfaceModifierContext.class);
|
|
}
|
|
public InterfaceModifierContext interfaceModifier(int i) {
|
|
return getRuleContext(InterfaceModifierContext.class,i);
|
|
}
|
|
public TypeParametersContext typeParameters() {
|
|
return getRuleContext(TypeParametersContext.class,0);
|
|
}
|
|
public ExtendsInterfacesContext extendsInterfaces() {
|
|
return getRuleContext(ExtendsInterfacesContext.class,0);
|
|
}
|
|
public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
|
|
}
|
|
|
|
public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
|
|
NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 198, RULE_normalInterfaceDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1276);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 884763262978L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(1273);
|
|
interfaceModifier();
|
|
}
|
|
}
|
|
setState(1278);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1279);
|
|
match(INTERFACE);
|
|
setState(1280);
|
|
match(Identifier);
|
|
setState(1282);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1281);
|
|
typeParameters();
|
|
}
|
|
}
|
|
|
|
setState(1285);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS) {
|
|
{
|
|
setState(1284);
|
|
extendsInterfaces();
|
|
}
|
|
}
|
|
|
|
setState(1287);
|
|
interfaceBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java8Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java8Parser.PRIVATE, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); }
|
|
public InterfaceModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceModifier; }
|
|
}
|
|
|
|
public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
|
|
InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 200, RULE_interfaceModifier);
|
|
try {
|
|
setState(1296);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1289);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1290);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case PROTECTED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1291);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case PRIVATE:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1292);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1293);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1294);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case STRICTFP:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1295);
|
|
match(STRICTFP);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExtendsInterfacesContext extends ParserRuleContext {
|
|
public TerminalNode EXTENDS() { return getToken(Java8Parser.EXTENDS, 0); }
|
|
public InterfaceTypeListContext interfaceTypeList() {
|
|
return getRuleContext(InterfaceTypeListContext.class,0);
|
|
}
|
|
public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_extendsInterfaces; }
|
|
}
|
|
|
|
public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
|
|
ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
|
|
enterRule(_localctx, 202, RULE_extendsInterfaces);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1298);
|
|
match(EXTENDS);
|
|
setState(1299);
|
|
interfaceTypeList();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() {
|
|
return getRuleContexts(InterfaceMemberDeclarationContext.class);
|
|
}
|
|
public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) {
|
|
return getRuleContext(InterfaceMemberDeclarationContext.class,i);
|
|
}
|
|
public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceBody; }
|
|
}
|
|
|
|
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
|
|
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 204, RULE_interfaceBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1301);
|
|
match(LBRACE);
|
|
setState(1305);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223089538734927062L) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & 51539607553L) != 0)) {
|
|
{
|
|
{
|
|
setState(1302);
|
|
interfaceMemberDeclaration();
|
|
}
|
|
}
|
|
setState(1307);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1308);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
|
|
public ConstantDeclarationContext constantDeclaration() {
|
|
return getRuleContext(ConstantDeclarationContext.class,0);
|
|
}
|
|
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
|
|
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
|
|
}
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
|
|
}
|
|
|
|
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
|
|
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 206, RULE_interfaceMemberDeclaration);
|
|
try {
|
|
setState(1315);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1310);
|
|
constantDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1311);
|
|
interfaceMethodDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1312);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1313);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1314);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstantDeclarationContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorListContext variableDeclaratorList() {
|
|
return getRuleContext(VariableDeclaratorListContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public List<ConstantModifierContext> constantModifier() {
|
|
return getRuleContexts(ConstantModifierContext.class);
|
|
}
|
|
public ConstantModifierContext constantModifier(int i) {
|
|
return getRuleContext(ConstantModifierContext.class,i);
|
|
}
|
|
public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constantDeclaration; }
|
|
}
|
|
|
|
public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
|
|
ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 208, RULE_constantDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1320);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 309237907456L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(1317);
|
|
constantModifier();
|
|
}
|
|
}
|
|
setState(1322);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1323);
|
|
unannType();
|
|
setState(1324);
|
|
variableDeclaratorList();
|
|
setState(1325);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstantModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode FINAL() { return getToken(Java8Parser.FINAL, 0); }
|
|
public ConstantModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constantModifier; }
|
|
}
|
|
|
|
public final ConstantModifierContext constantModifier() throws RecognitionException {
|
|
ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 210, RULE_constantModifier);
|
|
try {
|
|
setState(1331);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1327);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1328);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1329);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case FINAL:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1330);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
|
|
public MethodHeaderContext methodHeader() {
|
|
return getRuleContext(MethodHeaderContext.class,0);
|
|
}
|
|
public MethodBodyContext methodBody() {
|
|
return getRuleContext(MethodBodyContext.class,0);
|
|
}
|
|
public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
|
|
return getRuleContexts(InterfaceMethodModifierContext.class);
|
|
}
|
|
public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
|
|
return getRuleContext(InterfaceMethodModifierContext.class,i);
|
|
}
|
|
public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
|
|
}
|
|
|
|
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
|
|
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 212, RULE_interfaceMethodDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1336);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 858993463298L) != 0) || _la==AT) {
|
|
{
|
|
{
|
|
setState(1333);
|
|
interfaceMethodModifier();
|
|
}
|
|
}
|
|
setState(1338);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1339);
|
|
methodHeader();
|
|
setState(1340);
|
|
methodBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceMethodModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); }
|
|
public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java8Parser.STATIC, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java8Parser.STRICTFP, 0); }
|
|
public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
|
|
}
|
|
|
|
public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
|
|
InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 214, RULE_interfaceMethodModifier);
|
|
try {
|
|
setState(1348);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1342);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1343);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1344);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case DEFAULT:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1345);
|
|
match(DEFAULT);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1346);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case STRICTFP:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1347);
|
|
match(STRICTFP);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java8Parser.AT, 0); }
|
|
public TerminalNode INTERFACE() { return getToken(Java8Parser.INTERFACE, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public AnnotationTypeBodyContext annotationTypeBody() {
|
|
return getRuleContext(AnnotationTypeBodyContext.class,0);
|
|
}
|
|
public List<InterfaceModifierContext> interfaceModifier() {
|
|
return getRuleContexts(InterfaceModifierContext.class);
|
|
}
|
|
public InterfaceModifierContext interfaceModifier(int i) {
|
|
return getRuleContext(InterfaceModifierContext.class,i);
|
|
}
|
|
public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
|
|
}
|
|
|
|
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
|
|
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 216, RULE_annotationTypeDeclaration);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1353);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1350);
|
|
interfaceModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1355);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
|
|
}
|
|
setState(1356);
|
|
match(AT);
|
|
setState(1357);
|
|
match(INTERFACE);
|
|
setState(1358);
|
|
match(Identifier);
|
|
setState(1359);
|
|
annotationTypeBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationTypeBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public List<AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() {
|
|
return getRuleContexts(AnnotationTypeMemberDeclarationContext.class);
|
|
}
|
|
public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) {
|
|
return getRuleContext(AnnotationTypeMemberDeclarationContext.class,i);
|
|
}
|
|
public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
|
|
}
|
|
|
|
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
|
|
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 218, RULE_annotationTypeBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1361);
|
|
match(LBRACE);
|
|
setState(1365);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223371013711641814L) != 0) || _la==Identifier || _la==AT) {
|
|
{
|
|
{
|
|
setState(1362);
|
|
annotationTypeMemberDeclaration();
|
|
}
|
|
}
|
|
setState(1367);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1368);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext {
|
|
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() {
|
|
return getRuleContext(AnnotationTypeElementDeclarationContext.class,0);
|
|
}
|
|
public ConstantDeclarationContext constantDeclaration() {
|
|
return getRuleContext(ConstantDeclarationContext.class,0);
|
|
}
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeMemberDeclaration; }
|
|
}
|
|
|
|
public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException {
|
|
AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 220, RULE_annotationTypeMemberDeclaration);
|
|
try {
|
|
setState(1375);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1370);
|
|
annotationTypeElementDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1371);
|
|
constantDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1372);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1373);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1374);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public List<AnnotationTypeElementModifierContext> annotationTypeElementModifier() {
|
|
return getRuleContexts(AnnotationTypeElementModifierContext.class);
|
|
}
|
|
public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) {
|
|
return getRuleContext(AnnotationTypeElementModifierContext.class,i);
|
|
}
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public DefaultValueContext defaultValue() {
|
|
return getRuleContext(DefaultValueContext.class,0);
|
|
}
|
|
public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
|
|
}
|
|
|
|
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
|
|
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 222, RULE_annotationTypeElementDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1380);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==ABSTRACT || _la==PUBLIC || _la==AT) {
|
|
{
|
|
{
|
|
setState(1377);
|
|
annotationTypeElementModifier();
|
|
}
|
|
}
|
|
setState(1382);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1383);
|
|
unannType();
|
|
setState(1384);
|
|
match(Identifier);
|
|
setState(1385);
|
|
match(LPAREN);
|
|
setState(1386);
|
|
match(RPAREN);
|
|
setState(1388);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACK || _la==AT) {
|
|
{
|
|
setState(1387);
|
|
dims();
|
|
}
|
|
}
|
|
|
|
setState(1391);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==DEFAULT) {
|
|
{
|
|
setState(1390);
|
|
defaultValue();
|
|
}
|
|
}
|
|
|
|
setState(1393);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationTypeElementModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java8Parser.PUBLIC, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java8Parser.ABSTRACT, 0); }
|
|
public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeElementModifier; }
|
|
}
|
|
|
|
public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException {
|
|
AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 224, RULE_annotationTypeElementModifier);
|
|
try {
|
|
setState(1398);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1395);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1396);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1397);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DefaultValueContext extends ParserRuleContext {
|
|
public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); }
|
|
public ElementValueContext elementValue() {
|
|
return getRuleContext(ElementValueContext.class,0);
|
|
}
|
|
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_defaultValue; }
|
|
}
|
|
|
|
public final DefaultValueContext defaultValue() throws RecognitionException {
|
|
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
|
|
enterRule(_localctx, 226, RULE_defaultValue);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1400);
|
|
match(DEFAULT);
|
|
setState(1401);
|
|
elementValue();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationContext extends ParserRuleContext {
|
|
public NormalAnnotationContext normalAnnotation() {
|
|
return getRuleContext(NormalAnnotationContext.class,0);
|
|
}
|
|
public MarkerAnnotationContext markerAnnotation() {
|
|
return getRuleContext(MarkerAnnotationContext.class,0);
|
|
}
|
|
public SingleElementAnnotationContext singleElementAnnotation() {
|
|
return getRuleContext(SingleElementAnnotationContext.class,0);
|
|
}
|
|
public AnnotationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotation; }
|
|
}
|
|
|
|
public final AnnotationContext annotation() throws RecognitionException {
|
|
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
|
|
enterRule(_localctx, 228, RULE_annotation);
|
|
try {
|
|
setState(1406);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1403);
|
|
normalAnnotation();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1404);
|
|
markerAnnotation();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1405);
|
|
singleElementAnnotation();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NormalAnnotationContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java8Parser.AT, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ElementValuePairListContext elementValuePairList() {
|
|
return getRuleContext(ElementValuePairListContext.class,0);
|
|
}
|
|
public NormalAnnotationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_normalAnnotation; }
|
|
}
|
|
|
|
public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
|
|
NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
|
|
enterRule(_localctx, 230, RULE_normalAnnotation);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1408);
|
|
match(AT);
|
|
setState(1409);
|
|
typeName();
|
|
setState(1410);
|
|
match(LPAREN);
|
|
setState(1412);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==Identifier) {
|
|
{
|
|
setState(1411);
|
|
elementValuePairList();
|
|
}
|
|
}
|
|
|
|
setState(1414);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElementValuePairListContext extends ParserRuleContext {
|
|
public List<ElementValuePairContext> elementValuePair() {
|
|
return getRuleContexts(ElementValuePairContext.class);
|
|
}
|
|
public ElementValuePairContext elementValuePair(int i) {
|
|
return getRuleContext(ElementValuePairContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public ElementValuePairListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValuePairList; }
|
|
}
|
|
|
|
public final ElementValuePairListContext elementValuePairList() throws RecognitionException {
|
|
ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState());
|
|
enterRule(_localctx, 232, RULE_elementValuePairList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1416);
|
|
elementValuePair();
|
|
setState(1421);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1417);
|
|
match(COMMA);
|
|
setState(1418);
|
|
elementValuePair();
|
|
}
|
|
}
|
|
setState(1423);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElementValuePairContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 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; }
|
|
}
|
|
|
|
public final ElementValuePairContext elementValuePair() throws RecognitionException {
|
|
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
|
|
enterRule(_localctx, 234, RULE_elementValuePair);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1424);
|
|
match(Identifier);
|
|
setState(1425);
|
|
match(ASSIGN);
|
|
setState(1426);
|
|
elementValue();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElementValueContext extends ParserRuleContext {
|
|
public ConditionalExpressionContext conditionalExpression() {
|
|
return getRuleContext(ConditionalExpressionContext.class,0);
|
|
}
|
|
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
|
|
return getRuleContext(ElementValueArrayInitializerContext.class,0);
|
|
}
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public ElementValueContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValue; }
|
|
}
|
|
|
|
public final ElementValueContext elementValue() throws RecognitionException {
|
|
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
|
|
enterRule(_localctx, 236, RULE_elementValue);
|
|
try {
|
|
setState(1431);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1428);
|
|
conditionalExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1429);
|
|
elementValueArrayInitializer();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1430);
|
|
annotation();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElementValueArrayInitializerContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public ElementValueListContext elementValueList() {
|
|
return getRuleContext(ElementValueListContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); }
|
|
public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
|
|
}
|
|
|
|
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
|
|
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 238, RULE_elementValueArrayInitializer);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1433);
|
|
match(LBRACE);
|
|
setState(1435);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 862730839481401640L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1434);
|
|
elementValueList();
|
|
}
|
|
}
|
|
|
|
setState(1438);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1437);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
setState(1440);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ElementValueListContext extends ParserRuleContext {
|
|
public List<ElementValueContext> elementValue() {
|
|
return getRuleContexts(ElementValueContext.class);
|
|
}
|
|
public ElementValueContext elementValue(int i) {
|
|
return getRuleContext(ElementValueContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public ElementValueListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValueList; }
|
|
}
|
|
|
|
public final ElementValueListContext elementValueList() throws RecognitionException {
|
|
ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState());
|
|
enterRule(_localctx, 240, RULE_elementValueList);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1442);
|
|
elementValue();
|
|
setState(1447);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1443);
|
|
match(COMMA);
|
|
setState(1444);
|
|
elementValue();
|
|
}
|
|
}
|
|
}
|
|
setState(1449);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MarkerAnnotationContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java8Parser.AT, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_markerAnnotation; }
|
|
}
|
|
|
|
public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
|
|
MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
|
|
enterRule(_localctx, 242, RULE_markerAnnotation);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1450);
|
|
match(AT);
|
|
setState(1451);
|
|
typeName();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SingleElementAnnotationContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java8Parser.AT, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ElementValueContext elementValue() {
|
|
return getRuleContext(ElementValueContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_singleElementAnnotation; }
|
|
}
|
|
|
|
public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
|
|
SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
|
|
enterRule(_localctx, 244, RULE_singleElementAnnotation);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1453);
|
|
match(AT);
|
|
setState(1454);
|
|
typeName();
|
|
setState(1455);
|
|
match(LPAREN);
|
|
setState(1456);
|
|
elementValue();
|
|
setState(1457);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayInitializerContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public VariableInitializerListContext variableInitializerList() {
|
|
return getRuleContext(VariableInitializerListContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java8Parser.COMMA, 0); }
|
|
public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayInitializer; }
|
|
}
|
|
|
|
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
|
|
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 246, RULE_arrayInitializer);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1459);
|
|
match(LBRACE);
|
|
setState(1461);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 862730839481401640L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1460);
|
|
variableInitializerList();
|
|
}
|
|
}
|
|
|
|
setState(1464);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(1463);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
setState(1466);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableInitializerListContext extends ParserRuleContext {
|
|
public List<VariableInitializerContext> variableInitializer() {
|
|
return getRuleContexts(VariableInitializerContext.class);
|
|
}
|
|
public VariableInitializerContext variableInitializer(int i) {
|
|
return getRuleContext(VariableInitializerContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public VariableInitializerListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableInitializerList; }
|
|
}
|
|
|
|
public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
|
|
VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
|
|
enterRule(_localctx, 248, RULE_variableInitializerList);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1468);
|
|
variableInitializer();
|
|
setState(1473);
|
|
_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(1469);
|
|
match(COMMA);
|
|
setState(1470);
|
|
variableInitializer();
|
|
}
|
|
}
|
|
}
|
|
setState(1475);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,150,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public BlockStatementsContext blockStatements() {
|
|
return getRuleContext(BlockStatementsContext.class,0);
|
|
}
|
|
public BlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_block; }
|
|
}
|
|
|
|
public final BlockContext block() throws RecognitionException {
|
|
BlockContext _localctx = new BlockContext(_ctx, getState());
|
|
enterRule(_localctx, 250, RULE_block);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1476);
|
|
match(LBRACE);
|
|
setState(1478);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8359349417232995522L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1477);
|
|
blockStatements();
|
|
}
|
|
}
|
|
|
|
setState(1480);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockStatementsContext extends ParserRuleContext {
|
|
public List<BlockStatementContext> blockStatement() {
|
|
return getRuleContexts(BlockStatementContext.class);
|
|
}
|
|
public BlockStatementContext blockStatement(int i) {
|
|
return getRuleContext(BlockStatementContext.class,i);
|
|
}
|
|
public BlockStatementsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_blockStatements; }
|
|
}
|
|
|
|
public final BlockStatementsContext blockStatements() throws RecognitionException {
|
|
BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
|
|
enterRule(_localctx, 252, RULE_blockStatements);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1483);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1482);
|
|
blockStatement();
|
|
}
|
|
}
|
|
setState(1485);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & -8359349417232995522L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0) );
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockStatementContext extends ParserRuleContext {
|
|
public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() {
|
|
return getRuleContext(LocalVariableDeclarationStatementContext.class,0);
|
|
}
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public BlockStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_blockStatement; }
|
|
}
|
|
|
|
public final BlockStatementContext blockStatement() throws RecognitionException {
|
|
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 254, RULE_blockStatement);
|
|
try {
|
|
setState(1490);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1487);
|
|
localVariableDeclarationStatement();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1488);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1489);
|
|
statement();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LocalVariableDeclarationStatementContext extends ParserRuleContext {
|
|
public LocalVariableDeclarationContext localVariableDeclaration() {
|
|
return getRuleContext(LocalVariableDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; }
|
|
}
|
|
|
|
public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException {
|
|
LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 256, RULE_localVariableDeclarationStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1492);
|
|
localVariableDeclaration();
|
|
setState(1493);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LocalVariableDeclarationContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorListContext variableDeclaratorList() {
|
|
return getRuleContext(VariableDeclaratorListContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> 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; }
|
|
}
|
|
|
|
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
|
|
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 258, RULE_localVariableDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1498);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1495);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1500);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1501);
|
|
unannType();
|
|
setState(1502);
|
|
variableDeclaratorList();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StatementContext extends ParserRuleContext {
|
|
public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
|
|
return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
|
|
}
|
|
public LabeledStatementContext labeledStatement() {
|
|
return getRuleContext(LabeledStatementContext.class,0);
|
|
}
|
|
public IfThenStatementContext ifThenStatement() {
|
|
return getRuleContext(IfThenStatementContext.class,0);
|
|
}
|
|
public IfThenElseStatementContext ifThenElseStatement() {
|
|
return getRuleContext(IfThenElseStatementContext.class,0);
|
|
}
|
|
public WhileStatementContext whileStatement() {
|
|
return getRuleContext(WhileStatementContext.class,0);
|
|
}
|
|
public ForStatementContext forStatement() {
|
|
return getRuleContext(ForStatementContext.class,0);
|
|
}
|
|
public StatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statement; }
|
|
}
|
|
|
|
public final StatementContext statement() throws RecognitionException {
|
|
StatementContext _localctx = new StatementContext(_ctx, getState());
|
|
enterRule(_localctx, 260, RULE_statement);
|
|
try {
|
|
setState(1510);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1504);
|
|
statementWithoutTrailingSubstatement();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1505);
|
|
labeledStatement();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1506);
|
|
ifThenStatement();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1507);
|
|
ifThenElseStatement();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1508);
|
|
whileStatement();
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1509);
|
|
forStatement();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StatementNoShortIfContext extends ParserRuleContext {
|
|
public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
|
|
return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
|
|
}
|
|
public LabeledStatementNoShortIfContext labeledStatementNoShortIf() {
|
|
return getRuleContext(LabeledStatementNoShortIfContext.class,0);
|
|
}
|
|
public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() {
|
|
return getRuleContext(IfThenElseStatementNoShortIfContext.class,0);
|
|
}
|
|
public WhileStatementNoShortIfContext whileStatementNoShortIf() {
|
|
return getRuleContext(WhileStatementNoShortIfContext.class,0);
|
|
}
|
|
public ForStatementNoShortIfContext forStatementNoShortIf() {
|
|
return getRuleContext(ForStatementNoShortIfContext.class,0);
|
|
}
|
|
public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statementNoShortIf; }
|
|
}
|
|
|
|
public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException {
|
|
StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 262, RULE_statementNoShortIf);
|
|
try {
|
|
setState(1517);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1512);
|
|
statementWithoutTrailingSubstatement();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1513);
|
|
labeledStatementNoShortIf();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1514);
|
|
ifThenElseStatementNoShortIf();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1515);
|
|
whileStatementNoShortIf();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1516);
|
|
forStatementNoShortIf();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public EmptyStatement_Context emptyStatement_() {
|
|
return getRuleContext(EmptyStatement_Context.class,0);
|
|
}
|
|
public ExpressionStatementContext expressionStatement() {
|
|
return getRuleContext(ExpressionStatementContext.class,0);
|
|
}
|
|
public AssertStatementContext assertStatement() {
|
|
return getRuleContext(AssertStatementContext.class,0);
|
|
}
|
|
public SwitchStatementContext switchStatement() {
|
|
return getRuleContext(SwitchStatementContext.class,0);
|
|
}
|
|
public DoStatementContext doStatement() {
|
|
return getRuleContext(DoStatementContext.class,0);
|
|
}
|
|
public BreakStatementContext breakStatement() {
|
|
return getRuleContext(BreakStatementContext.class,0);
|
|
}
|
|
public ContinueStatementContext continueStatement() {
|
|
return getRuleContext(ContinueStatementContext.class,0);
|
|
}
|
|
public ReturnStatementContext returnStatement() {
|
|
return getRuleContext(ReturnStatementContext.class,0);
|
|
}
|
|
public SynchronizedStatementContext synchronizedStatement() {
|
|
return getRuleContext(SynchronizedStatementContext.class,0);
|
|
}
|
|
public ThrowStatementContext throwStatement() {
|
|
return getRuleContext(ThrowStatementContext.class,0);
|
|
}
|
|
public TryStatementContext tryStatement() {
|
|
return getRuleContext(TryStatementContext.class,0);
|
|
}
|
|
public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statementWithoutTrailingSubstatement; }
|
|
}
|
|
|
|
public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException {
|
|
StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState());
|
|
enterRule(_localctx, 264, RULE_statementWithoutTrailingSubstatement);
|
|
try {
|
|
setState(1531);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1519);
|
|
block();
|
|
}
|
|
break;
|
|
case SEMI:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1520);
|
|
emptyStatement_();
|
|
}
|
|
break;
|
|
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 IntegerLiteral:
|
|
case FloatingPointLiteral:
|
|
case BooleanLiteral:
|
|
case CharacterLiteral:
|
|
case StringLiteral:
|
|
case NullLiteral:
|
|
case LPAREN:
|
|
case INC:
|
|
case DEC:
|
|
case Identifier:
|
|
case AT:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1521);
|
|
expressionStatement();
|
|
}
|
|
break;
|
|
case ASSERT:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1522);
|
|
assertStatement();
|
|
}
|
|
break;
|
|
case SWITCH:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1523);
|
|
switchStatement();
|
|
}
|
|
break;
|
|
case DO:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1524);
|
|
doStatement();
|
|
}
|
|
break;
|
|
case BREAK:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1525);
|
|
breakStatement();
|
|
}
|
|
break;
|
|
case CONTINUE:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1526);
|
|
continueStatement();
|
|
}
|
|
break;
|
|
case RETURN:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1527);
|
|
returnStatement();
|
|
}
|
|
break;
|
|
case SYNCHRONIZED:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1528);
|
|
synchronizedStatement();
|
|
}
|
|
break;
|
|
case THROW:
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1529);
|
|
throwStatement();
|
|
}
|
|
break;
|
|
case TRY:
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(1530);
|
|
tryStatement();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EmptyStatement_Context extends ParserRuleContext {
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public EmptyStatement_Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_emptyStatement_; }
|
|
}
|
|
|
|
public final EmptyStatement_Context emptyStatement_() throws RecognitionException {
|
|
EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState());
|
|
enterRule(_localctx, 266, RULE_emptyStatement_);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1533);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledStatementContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public LabeledStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_labeledStatement; }
|
|
}
|
|
|
|
public final LabeledStatementContext labeledStatement() throws RecognitionException {
|
|
LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 268, RULE_labeledStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1535);
|
|
match(Identifier);
|
|
setState(1536);
|
|
match(COLON);
|
|
setState(1537);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledStatementNoShortIfContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public StatementNoShortIfContext statementNoShortIf() {
|
|
return getRuleContext(StatementNoShortIfContext.class,0);
|
|
}
|
|
public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_labeledStatementNoShortIf; }
|
|
}
|
|
|
|
public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException {
|
|
LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 270, RULE_labeledStatementNoShortIf);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1539);
|
|
match(Identifier);
|
|
setState(1540);
|
|
match(COLON);
|
|
setState(1541);
|
|
statementNoShortIf();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExpressionStatementContext extends ParserRuleContext {
|
|
public StatementExpressionContext statementExpression() {
|
|
return getRuleContext(StatementExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expressionStatement; }
|
|
}
|
|
|
|
public final ExpressionStatementContext expressionStatement() throws RecognitionException {
|
|
ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 272, RULE_expressionStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1543);
|
|
statementExpression();
|
|
setState(1544);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StatementExpressionContext extends ParserRuleContext {
|
|
public AssignmentContext assignment() {
|
|
return getRuleContext(AssignmentContext.class,0);
|
|
}
|
|
public PreIncrementExpressionContext preIncrementExpression() {
|
|
return getRuleContext(PreIncrementExpressionContext.class,0);
|
|
}
|
|
public PreDecrementExpressionContext preDecrementExpression() {
|
|
return getRuleContext(PreDecrementExpressionContext.class,0);
|
|
}
|
|
public PostIncrementExpressionContext postIncrementExpression() {
|
|
return getRuleContext(PostIncrementExpressionContext.class,0);
|
|
}
|
|
public PostDecrementExpressionContext postDecrementExpression() {
|
|
return getRuleContext(PostDecrementExpressionContext.class,0);
|
|
}
|
|
public MethodInvocationContext methodInvocation() {
|
|
return getRuleContext(MethodInvocationContext.class,0);
|
|
}
|
|
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
|
|
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
|
|
}
|
|
public StatementExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statementExpression; }
|
|
}
|
|
|
|
public final StatementExpressionContext statementExpression() throws RecognitionException {
|
|
StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 274, RULE_statementExpression);
|
|
try {
|
|
setState(1553);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1546);
|
|
assignment();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1547);
|
|
preIncrementExpression();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1548);
|
|
preDecrementExpression();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1549);
|
|
postIncrementExpression();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1550);
|
|
postDecrementExpression();
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1551);
|
|
methodInvocation();
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1552);
|
|
classInstanceCreationExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IfThenStatementContext extends ParserRuleContext {
|
|
public TerminalNode IF() { return getToken(Java8Parser.IF, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public IfThenStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ifThenStatement; }
|
|
}
|
|
|
|
public final IfThenStatementContext ifThenStatement() throws RecognitionException {
|
|
IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 276, RULE_ifThenStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1555);
|
|
match(IF);
|
|
setState(1556);
|
|
match(LPAREN);
|
|
setState(1557);
|
|
expression();
|
|
setState(1558);
|
|
match(RPAREN);
|
|
setState(1559);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IfThenElseStatementContext extends ParserRuleContext {
|
|
public TerminalNode IF() { return getToken(Java8Parser.IF, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementNoShortIfContext statementNoShortIf() {
|
|
return getRuleContext(StatementNoShortIfContext.class,0);
|
|
}
|
|
public TerminalNode ELSE() { return getToken(Java8Parser.ELSE, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ifThenElseStatement; }
|
|
}
|
|
|
|
public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException {
|
|
IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 278, RULE_ifThenElseStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1561);
|
|
match(IF);
|
|
setState(1562);
|
|
match(LPAREN);
|
|
setState(1563);
|
|
expression();
|
|
setState(1564);
|
|
match(RPAREN);
|
|
setState(1565);
|
|
statementNoShortIf();
|
|
setState(1566);
|
|
match(ELSE);
|
|
setState(1567);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext {
|
|
public TerminalNode IF() { return getToken(Java8Parser.IF, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public List<StatementNoShortIfContext> statementNoShortIf() {
|
|
return getRuleContexts(StatementNoShortIfContext.class);
|
|
}
|
|
public StatementNoShortIfContext statementNoShortIf(int i) {
|
|
return getRuleContext(StatementNoShortIfContext.class,i);
|
|
}
|
|
public TerminalNode ELSE() { return getToken(Java8Parser.ELSE, 0); }
|
|
public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_ifThenElseStatementNoShortIf; }
|
|
}
|
|
|
|
public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException {
|
|
IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 280, RULE_ifThenElseStatementNoShortIf);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1569);
|
|
match(IF);
|
|
setState(1570);
|
|
match(LPAREN);
|
|
setState(1571);
|
|
expression();
|
|
setState(1572);
|
|
match(RPAREN);
|
|
setState(1573);
|
|
statementNoShortIf();
|
|
setState(1574);
|
|
match(ELSE);
|
|
setState(1575);
|
|
statementNoShortIf();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssertStatementContext extends ParserRuleContext {
|
|
public TerminalNode ASSERT() { return getToken(Java8Parser.ASSERT, 0); }
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public AssertStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_assertStatement; }
|
|
}
|
|
|
|
public final AssertStatementContext assertStatement() throws RecognitionException {
|
|
AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 282, RULE_assertStatement);
|
|
try {
|
|
setState(1587);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1577);
|
|
match(ASSERT);
|
|
setState(1578);
|
|
expression();
|
|
setState(1579);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1581);
|
|
match(ASSERT);
|
|
setState(1582);
|
|
expression();
|
|
setState(1583);
|
|
match(COLON);
|
|
setState(1584);
|
|
expression();
|
|
setState(1585);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchStatementContext extends ParserRuleContext {
|
|
public TerminalNode SWITCH() { return getToken(Java8Parser.SWITCH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public SwitchBlockContext switchBlock() {
|
|
return getRuleContext(SwitchBlockContext.class,0);
|
|
}
|
|
public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchStatement; }
|
|
}
|
|
|
|
public final SwitchStatementContext switchStatement() throws RecognitionException {
|
|
SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 284, RULE_switchStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1589);
|
|
match(SWITCH);
|
|
setState(1590);
|
|
match(LPAREN);
|
|
setState(1591);
|
|
expression();
|
|
setState(1592);
|
|
match(RPAREN);
|
|
setState(1593);
|
|
switchBlock();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchBlockContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java8Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java8Parser.RBRACE, 0); }
|
|
public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() {
|
|
return getRuleContexts(SwitchBlockStatementGroupContext.class);
|
|
}
|
|
public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
|
|
return getRuleContext(SwitchBlockStatementGroupContext.class,i);
|
|
}
|
|
public List<SwitchLabelContext> switchLabel() {
|
|
return getRuleContexts(SwitchLabelContext.class);
|
|
}
|
|
public SwitchLabelContext switchLabel(int i) {
|
|
return getRuleContext(SwitchLabelContext.class,i);
|
|
}
|
|
public SwitchBlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchBlock; }
|
|
}
|
|
|
|
public final SwitchBlockContext switchBlock() throws RecognitionException {
|
|
SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState());
|
|
enterRule(_localctx, 286, RULE_switchBlock);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1595);
|
|
match(LBRACE);
|
|
setState(1599);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1596);
|
|
switchBlockStatementGroup();
|
|
}
|
|
}
|
|
}
|
|
setState(1601);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
|
|
}
|
|
setState(1605);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CASE || _la==DEFAULT) {
|
|
{
|
|
{
|
|
setState(1602);
|
|
switchLabel();
|
|
}
|
|
}
|
|
setState(1607);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1608);
|
|
match(RBRACE);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchBlockStatementGroupContext extends ParserRuleContext {
|
|
public SwitchLabelsContext switchLabels() {
|
|
return getRuleContext(SwitchLabelsContext.class,0);
|
|
}
|
|
public BlockStatementsContext blockStatements() {
|
|
return getRuleContext(BlockStatementsContext.class,0);
|
|
}
|
|
public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
|
|
}
|
|
|
|
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
|
|
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
|
|
enterRule(_localctx, 288, RULE_switchBlockStatementGroup);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1610);
|
|
switchLabels();
|
|
setState(1611);
|
|
blockStatements();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelsContext extends ParserRuleContext {
|
|
public List<SwitchLabelContext> switchLabel() {
|
|
return getRuleContexts(SwitchLabelContext.class);
|
|
}
|
|
public SwitchLabelContext switchLabel(int i) {
|
|
return getRuleContext(SwitchLabelContext.class,i);
|
|
}
|
|
public SwitchLabelsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchLabels; }
|
|
}
|
|
|
|
public final SwitchLabelsContext switchLabels() throws RecognitionException {
|
|
SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState());
|
|
enterRule(_localctx, 290, RULE_switchLabels);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1613);
|
|
switchLabel();
|
|
setState(1617);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CASE || _la==DEFAULT) {
|
|
{
|
|
{
|
|
setState(1614);
|
|
switchLabel();
|
|
}
|
|
}
|
|
setState(1619);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelContext extends ParserRuleContext {
|
|
public TerminalNode CASE() { return getToken(Java8Parser.CASE, 0); }
|
|
public ConstantExpressionContext constantExpression() {
|
|
return getRuleContext(ConstantExpressionContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public EnumConstantNameContext enumConstantName() {
|
|
return getRuleContext(EnumConstantNameContext.class,0);
|
|
}
|
|
public TerminalNode DEFAULT() { return getToken(Java8Parser.DEFAULT, 0); }
|
|
public SwitchLabelContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchLabel; }
|
|
}
|
|
|
|
public final SwitchLabelContext switchLabel() throws RecognitionException {
|
|
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
|
|
enterRule(_localctx, 292, RULE_switchLabel);
|
|
try {
|
|
setState(1630);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1620);
|
|
match(CASE);
|
|
setState(1621);
|
|
constantExpression();
|
|
setState(1622);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1624);
|
|
match(CASE);
|
|
setState(1625);
|
|
enumConstantName();
|
|
setState(1626);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1628);
|
|
match(DEFAULT);
|
|
setState(1629);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnumConstantNameContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public EnumConstantNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstantName; }
|
|
}
|
|
|
|
public final EnumConstantNameContext enumConstantName() throws RecognitionException {
|
|
EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState());
|
|
enterRule(_localctx, 294, RULE_enumConstantName);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1632);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhileStatementContext extends ParserRuleContext {
|
|
public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public WhileStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_whileStatement; }
|
|
}
|
|
|
|
public final WhileStatementContext whileStatement() throws RecognitionException {
|
|
WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 296, RULE_whileStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1634);
|
|
match(WHILE);
|
|
setState(1635);
|
|
match(LPAREN);
|
|
setState(1636);
|
|
expression();
|
|
setState(1637);
|
|
match(RPAREN);
|
|
setState(1638);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhileStatementNoShortIfContext extends ParserRuleContext {
|
|
public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementNoShortIfContext statementNoShortIf() {
|
|
return getRuleContext(StatementNoShortIfContext.class,0);
|
|
}
|
|
public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_whileStatementNoShortIf; }
|
|
}
|
|
|
|
public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException {
|
|
WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 298, RULE_whileStatementNoShortIf);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1640);
|
|
match(WHILE);
|
|
setState(1641);
|
|
match(LPAREN);
|
|
setState(1642);
|
|
expression();
|
|
setState(1643);
|
|
match(RPAREN);
|
|
setState(1644);
|
|
statementNoShortIf();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DoStatementContext extends ParserRuleContext {
|
|
public TerminalNode DO() { return getToken(Java8Parser.DO, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public TerminalNode WHILE() { return getToken(Java8Parser.WHILE, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public DoStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_doStatement; }
|
|
}
|
|
|
|
public final DoStatementContext doStatement() throws RecognitionException {
|
|
DoStatementContext _localctx = new DoStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 300, RULE_doStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1646);
|
|
match(DO);
|
|
setState(1647);
|
|
statement();
|
|
setState(1648);
|
|
match(WHILE);
|
|
setState(1649);
|
|
match(LPAREN);
|
|
setState(1650);
|
|
expression();
|
|
setState(1651);
|
|
match(RPAREN);
|
|
setState(1652);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForStatementContext extends ParserRuleContext {
|
|
public BasicForStatementContext basicForStatement() {
|
|
return getRuleContext(BasicForStatementContext.class,0);
|
|
}
|
|
public EnhancedForStatementContext enhancedForStatement() {
|
|
return getRuleContext(EnhancedForStatementContext.class,0);
|
|
}
|
|
public ForStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forStatement; }
|
|
}
|
|
|
|
public final ForStatementContext forStatement() throws RecognitionException {
|
|
ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 302, RULE_forStatement);
|
|
try {
|
|
setState(1656);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1654);
|
|
basicForStatement();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1655);
|
|
enhancedForStatement();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForStatementNoShortIfContext extends ParserRuleContext {
|
|
public BasicForStatementNoShortIfContext basicForStatementNoShortIf() {
|
|
return getRuleContext(BasicForStatementNoShortIfContext.class,0);
|
|
}
|
|
public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() {
|
|
return getRuleContext(EnhancedForStatementNoShortIfContext.class,0);
|
|
}
|
|
public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forStatementNoShortIf; }
|
|
}
|
|
|
|
public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException {
|
|
ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 304, RULE_forStatementNoShortIf);
|
|
try {
|
|
setState(1660);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1658);
|
|
basicForStatementNoShortIf();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1659);
|
|
enhancedForStatementNoShortIf();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BasicForStatementContext extends ParserRuleContext {
|
|
public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public List<TerminalNode> SEMI() { return getTokens(Java8Parser.SEMI); }
|
|
public TerminalNode SEMI(int i) {
|
|
return getToken(Java8Parser.SEMI, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.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 BasicForStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_basicForStatement; }
|
|
}
|
|
|
|
public final BasicForStatementContext basicForStatement() throws RecognitionException {
|
|
BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 306, RULE_basicForStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1662);
|
|
match(FOR);
|
|
setState(1663);
|
|
match(LPAREN);
|
|
setState(1665);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087178240296L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1664);
|
|
forInit();
|
|
}
|
|
}
|
|
|
|
setState(1667);
|
|
match(SEMI);
|
|
setState(1669);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1668);
|
|
expression();
|
|
}
|
|
}
|
|
|
|
setState(1671);
|
|
match(SEMI);
|
|
setState(1673);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1672);
|
|
forUpdate();
|
|
}
|
|
}
|
|
|
|
setState(1675);
|
|
match(RPAREN);
|
|
setState(1676);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BasicForStatementNoShortIfContext extends ParserRuleContext {
|
|
public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public List<TerminalNode> SEMI() { return getTokens(Java8Parser.SEMI); }
|
|
public TerminalNode SEMI(int i) {
|
|
return getToken(Java8Parser.SEMI, i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementNoShortIfContext statementNoShortIf() {
|
|
return getRuleContext(StatementNoShortIfContext.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 BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_basicForStatementNoShortIf; }
|
|
}
|
|
|
|
public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException {
|
|
BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 308, RULE_basicForStatementNoShortIf);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1678);
|
|
match(FOR);
|
|
setState(1679);
|
|
match(LPAREN);
|
|
setState(1681);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087178240296L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1680);
|
|
forInit();
|
|
}
|
|
}
|
|
|
|
setState(1683);
|
|
match(SEMI);
|
|
setState(1685);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1684);
|
|
expression();
|
|
}
|
|
}
|
|
|
|
setState(1687);
|
|
match(SEMI);
|
|
setState(1689);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & 25165827L) != 0)) {
|
|
{
|
|
setState(1688);
|
|
forUpdate();
|
|
}
|
|
}
|
|
|
|
setState(1691);
|
|
match(RPAREN);
|
|
setState(1692);
|
|
statementNoShortIf();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForInitContext extends ParserRuleContext {
|
|
public StatementExpressionListContext statementExpressionList() {
|
|
return getRuleContext(StatementExpressionListContext.class,0);
|
|
}
|
|
public LocalVariableDeclarationContext localVariableDeclaration() {
|
|
return getRuleContext(LocalVariableDeclarationContext.class,0);
|
|
}
|
|
public ForInitContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forInit; }
|
|
}
|
|
|
|
public final ForInitContext forInit() throws RecognitionException {
|
|
ForInitContext _localctx = new ForInitContext(_ctx, getState());
|
|
enterRule(_localctx, 310, RULE_forInit);
|
|
try {
|
|
setState(1696);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1694);
|
|
statementExpressionList();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1695);
|
|
localVariableDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForUpdateContext extends ParserRuleContext {
|
|
public StatementExpressionListContext statementExpressionList() {
|
|
return getRuleContext(StatementExpressionListContext.class,0);
|
|
}
|
|
public ForUpdateContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forUpdate; }
|
|
}
|
|
|
|
public final ForUpdateContext forUpdate() throws RecognitionException {
|
|
ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
|
|
enterRule(_localctx, 312, RULE_forUpdate);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1698);
|
|
statementExpressionList();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StatementExpressionListContext extends ParserRuleContext {
|
|
public List<StatementExpressionContext> statementExpression() {
|
|
return getRuleContexts(StatementExpressionContext.class);
|
|
}
|
|
public StatementExpressionContext statementExpression(int i) {
|
|
return getRuleContext(StatementExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public StatementExpressionListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statementExpressionList; }
|
|
}
|
|
|
|
public final StatementExpressionListContext statementExpressionList() throws RecognitionException {
|
|
StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState());
|
|
enterRule(_localctx, 314, RULE_statementExpressionList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1700);
|
|
statementExpression();
|
|
setState(1705);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1701);
|
|
match(COMMA);
|
|
setState(1702);
|
|
statementExpression();
|
|
}
|
|
}
|
|
setState(1707);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnhancedForStatementContext extends ParserRuleContext {
|
|
public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enhancedForStatement; }
|
|
}
|
|
|
|
public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException {
|
|
EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 316, RULE_enhancedForStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1708);
|
|
match(FOR);
|
|
setState(1709);
|
|
match(LPAREN);
|
|
setState(1713);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1710);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1715);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1716);
|
|
unannType();
|
|
setState(1717);
|
|
variableDeclaratorId();
|
|
setState(1718);
|
|
match(COLON);
|
|
setState(1719);
|
|
expression();
|
|
setState(1720);
|
|
match(RPAREN);
|
|
setState(1721);
|
|
statement();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext {
|
|
public TerminalNode FOR() { return getToken(Java8Parser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public StatementNoShortIfContext statementNoShortIf() {
|
|
return getRuleContext(StatementNoShortIfContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enhancedForStatementNoShortIf; }
|
|
}
|
|
|
|
public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException {
|
|
EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState());
|
|
enterRule(_localctx, 318, RULE_enhancedForStatementNoShortIf);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1723);
|
|
match(FOR);
|
|
setState(1724);
|
|
match(LPAREN);
|
|
setState(1728);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1725);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1730);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1731);
|
|
unannType();
|
|
setState(1732);
|
|
variableDeclaratorId();
|
|
setState(1733);
|
|
match(COLON);
|
|
setState(1734);
|
|
expression();
|
|
setState(1735);
|
|
match(RPAREN);
|
|
setState(1736);
|
|
statementNoShortIf();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BreakStatementContext extends ParserRuleContext {
|
|
public TerminalNode BREAK() { return getToken(Java8Parser.BREAK, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public BreakStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_breakStatement; }
|
|
}
|
|
|
|
public final BreakStatementContext breakStatement() throws RecognitionException {
|
|
BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 320, RULE_breakStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1738);
|
|
match(BREAK);
|
|
setState(1740);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==Identifier) {
|
|
{
|
|
setState(1739);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
|
|
setState(1742);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ContinueStatementContext extends ParserRuleContext {
|
|
public TerminalNode CONTINUE() { return getToken(Java8Parser.CONTINUE, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_continueStatement; }
|
|
}
|
|
|
|
public final ContinueStatementContext continueStatement() throws RecognitionException {
|
|
ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 322, RULE_continueStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1744);
|
|
match(CONTINUE);
|
|
setState(1746);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==Identifier) {
|
|
{
|
|
setState(1745);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
|
|
setState(1748);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReturnStatementContext extends ParserRuleContext {
|
|
public TerminalNode RETURN() { return getToken(Java8Parser.RETURN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_returnStatement; }
|
|
}
|
|
|
|
public final ReturnStatementContext returnStatement() throws RecognitionException {
|
|
ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 324, RULE_returnStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1750);
|
|
match(RETURN);
|
|
setState(1752);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(1751);
|
|
expression();
|
|
}
|
|
}
|
|
|
|
setState(1754);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ThrowStatementContext extends ParserRuleContext {
|
|
public TerminalNode THROW() { return getToken(Java8Parser.THROW, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_throwStatement; }
|
|
}
|
|
|
|
public final ThrowStatementContext throwStatement() throws RecognitionException {
|
|
ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 326, RULE_throwStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1756);
|
|
match(THROW);
|
|
setState(1757);
|
|
expression();
|
|
setState(1758);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SynchronizedStatementContext extends ParserRuleContext {
|
|
public TerminalNode SYNCHRONIZED() { return getToken(Java8Parser.SYNCHRONIZED, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_synchronizedStatement; }
|
|
}
|
|
|
|
public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException {
|
|
SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 328, RULE_synchronizedStatement);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1760);
|
|
match(SYNCHRONIZED);
|
|
setState(1761);
|
|
match(LPAREN);
|
|
setState(1762);
|
|
expression();
|
|
setState(1763);
|
|
match(RPAREN);
|
|
setState(1764);
|
|
block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TryStatementContext extends ParserRuleContext {
|
|
public TerminalNode TRY() { return getToken(Java8Parser.TRY, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public CatchesContext catches() {
|
|
return getRuleContext(CatchesContext.class,0);
|
|
}
|
|
public Finally_Context finally_() {
|
|
return getRuleContext(Finally_Context.class,0);
|
|
}
|
|
public TryWithResourcesStatementContext tryWithResourcesStatement() {
|
|
return getRuleContext(TryWithResourcesStatementContext.class,0);
|
|
}
|
|
public TryStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_tryStatement; }
|
|
}
|
|
|
|
public final TryStatementContext tryStatement() throws RecognitionException {
|
|
TryStatementContext _localctx = new TryStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 330, RULE_tryStatement);
|
|
int _la;
|
|
try {
|
|
setState(1778);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1766);
|
|
match(TRY);
|
|
setState(1767);
|
|
block();
|
|
setState(1768);
|
|
catches();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1770);
|
|
match(TRY);
|
|
setState(1771);
|
|
block();
|
|
setState(1773);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==CATCH) {
|
|
{
|
|
setState(1772);
|
|
catches();
|
|
}
|
|
}
|
|
|
|
setState(1775);
|
|
finally_();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1777);
|
|
tryWithResourcesStatement();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CatchesContext extends ParserRuleContext {
|
|
public List<CatchClauseContext> catchClause() {
|
|
return getRuleContexts(CatchClauseContext.class);
|
|
}
|
|
public CatchClauseContext catchClause(int i) {
|
|
return getRuleContext(CatchClauseContext.class,i);
|
|
}
|
|
public CatchesContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catches; }
|
|
}
|
|
|
|
public final CatchesContext catches() throws RecognitionException {
|
|
CatchesContext _localctx = new CatchesContext(_ctx, getState());
|
|
enterRule(_localctx, 332, RULE_catches);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1780);
|
|
catchClause();
|
|
setState(1784);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CATCH) {
|
|
{
|
|
{
|
|
setState(1781);
|
|
catchClause();
|
|
}
|
|
}
|
|
setState(1786);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CatchClauseContext extends ParserRuleContext {
|
|
public TerminalNode CATCH() { return getToken(Java8Parser.CATCH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public CatchFormalParameterContext catchFormalParameter() {
|
|
return getRuleContext(CatchFormalParameterContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public CatchClauseContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catchClause; }
|
|
}
|
|
|
|
public final CatchClauseContext catchClause() throws RecognitionException {
|
|
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
|
|
enterRule(_localctx, 334, RULE_catchClause);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1787);
|
|
match(CATCH);
|
|
setState(1788);
|
|
match(LPAREN);
|
|
setState(1789);
|
|
catchFormalParameter();
|
|
setState(1790);
|
|
match(RPAREN);
|
|
setState(1791);
|
|
block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CatchFormalParameterContext extends ParserRuleContext {
|
|
public CatchTypeContext catchType() {
|
|
return getRuleContext(CatchTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catchFormalParameter; }
|
|
}
|
|
|
|
public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException {
|
|
CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 336, RULE_catchFormalParameter);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1796);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1793);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1798);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1799);
|
|
catchType();
|
|
setState(1800);
|
|
variableDeclaratorId();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CatchTypeContext extends ParserRuleContext {
|
|
public UnannClassTypeContext unannClassType() {
|
|
return getRuleContext(UnannClassTypeContext.class,0);
|
|
}
|
|
public List<TerminalNode> BITOR() { return getTokens(Java8Parser.BITOR); }
|
|
public TerminalNode BITOR(int i) {
|
|
return getToken(Java8Parser.BITOR, i);
|
|
}
|
|
public List<ClassTypeContext> classType() {
|
|
return getRuleContexts(ClassTypeContext.class);
|
|
}
|
|
public ClassTypeContext classType(int i) {
|
|
return getRuleContext(ClassTypeContext.class,i);
|
|
}
|
|
public CatchTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catchType; }
|
|
}
|
|
|
|
public final CatchTypeContext catchType() throws RecognitionException {
|
|
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 338, RULE_catchType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1802);
|
|
unannClassType();
|
|
setState(1807);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITOR) {
|
|
{
|
|
{
|
|
setState(1803);
|
|
match(BITOR);
|
|
setState(1804);
|
|
classType();
|
|
}
|
|
}
|
|
setState(1809);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class Finally_Context extends ParserRuleContext {
|
|
public TerminalNode FINALLY() { return getToken(Java8Parser.FINALLY, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public Finally_Context(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_finally_; }
|
|
}
|
|
|
|
public final Finally_Context finally_() throws RecognitionException {
|
|
Finally_Context _localctx = new Finally_Context(_ctx, getState());
|
|
enterRule(_localctx, 340, RULE_finally_);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1810);
|
|
match(FINALLY);
|
|
setState(1811);
|
|
block();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TryWithResourcesStatementContext extends ParserRuleContext {
|
|
public TerminalNode TRY() { return getToken(Java8Parser.TRY, 0); }
|
|
public ResourceSpecificationContext resourceSpecification() {
|
|
return getRuleContext(ResourceSpecificationContext.class,0);
|
|
}
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public CatchesContext catches() {
|
|
return getRuleContext(CatchesContext.class,0);
|
|
}
|
|
public Finally_Context finally_() {
|
|
return getRuleContext(Finally_Context.class,0);
|
|
}
|
|
public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_tryWithResourcesStatement; }
|
|
}
|
|
|
|
public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException {
|
|
TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 342, RULE_tryWithResourcesStatement);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1813);
|
|
match(TRY);
|
|
setState(1814);
|
|
resourceSpecification();
|
|
setState(1815);
|
|
block();
|
|
setState(1817);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==CATCH) {
|
|
{
|
|
setState(1816);
|
|
catches();
|
|
}
|
|
}
|
|
|
|
setState(1820);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==FINALLY) {
|
|
{
|
|
setState(1819);
|
|
finally_();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ResourceSpecificationContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ResourceListContext resourceList() {
|
|
return getRuleContext(ResourceListContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java8Parser.SEMI, 0); }
|
|
public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_resourceSpecification; }
|
|
}
|
|
|
|
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
|
|
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
|
|
enterRule(_localctx, 344, RULE_resourceSpecification);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1822);
|
|
match(LPAREN);
|
|
setState(1823);
|
|
resourceList();
|
|
setState(1825);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==SEMI) {
|
|
{
|
|
setState(1824);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
|
|
setState(1827);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ResourceListContext extends ParserRuleContext {
|
|
public List<ResourceContext> resource() {
|
|
return getRuleContexts(ResourceContext.class);
|
|
}
|
|
public ResourceContext resource(int i) {
|
|
return getRuleContext(ResourceContext.class,i);
|
|
}
|
|
public List<TerminalNode> SEMI() { return getTokens(Java8Parser.SEMI); }
|
|
public TerminalNode SEMI(int i) {
|
|
return getToken(Java8Parser.SEMI, i);
|
|
}
|
|
public ResourceListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_resourceList; }
|
|
}
|
|
|
|
public final ResourceListContext resourceList() throws RecognitionException {
|
|
ResourceListContext _localctx = new ResourceListContext(_ctx, getState());
|
|
enterRule(_localctx, 346, RULE_resourceList);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1829);
|
|
resource();
|
|
setState(1834);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1830);
|
|
match(SEMI);
|
|
setState(1831);
|
|
resource();
|
|
}
|
|
}
|
|
}
|
|
setState(1836);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ResourceContext extends ParserRuleContext {
|
|
public UnannTypeContext unannType() {
|
|
return getRuleContext(UnannTypeContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> 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; }
|
|
}
|
|
|
|
public final ResourceContext resource() throws RecognitionException {
|
|
ResourceContext _localctx = new ResourceContext(_ctx, getState());
|
|
enterRule(_localctx, 348, RULE_resource);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1840);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==FINAL || _la==AT) {
|
|
{
|
|
{
|
|
setState(1837);
|
|
variableModifier();
|
|
}
|
|
}
|
|
setState(1842);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1843);
|
|
unannType();
|
|
setState(1844);
|
|
variableDeclaratorId();
|
|
setState(1845);
|
|
match(ASSIGN);
|
|
setState(1846);
|
|
expression();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryContext extends ParserRuleContext {
|
|
public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() {
|
|
return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class,0);
|
|
}
|
|
public ArrayCreationExpressionContext arrayCreationExpression() {
|
|
return getRuleContext(ArrayCreationExpressionContext.class,0);
|
|
}
|
|
public List<PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() {
|
|
return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class);
|
|
}
|
|
public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) {
|
|
return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class,i);
|
|
}
|
|
public PrimaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primary; }
|
|
}
|
|
|
|
public final PrimaryContext primary() throws RecognitionException {
|
|
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
|
|
enterRule(_localctx, 350, RULE_primary);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1850);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1848);
|
|
primaryNoNewArray_lfno_primary();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1849);
|
|
arrayCreationExpression();
|
|
}
|
|
break;
|
|
}
|
|
setState(1855);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,190,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1852);
|
|
primaryNoNewArray_lf_primary();
|
|
}
|
|
}
|
|
}
|
|
setState(1857);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,190,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArrayContext extends ParserRuleContext {
|
|
public LiteralContext literal() {
|
|
return getRuleContext(LiteralContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); }
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); }
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
|
|
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
|
|
}
|
|
public FieldAccessContext fieldAccess() {
|
|
return getRuleContext(FieldAccessContext.class,0);
|
|
}
|
|
public ArrayAccessContext arrayAccess() {
|
|
return getRuleContext(ArrayAccessContext.class,0);
|
|
}
|
|
public MethodInvocationContext methodInvocation() {
|
|
return getRuleContext(MethodInvocationContext.class,0);
|
|
}
|
|
public MethodReferenceContext methodReference() {
|
|
return getRuleContext(MethodReferenceContext.class,0);
|
|
}
|
|
public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray; }
|
|
}
|
|
|
|
public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException {
|
|
PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState());
|
|
enterRule(_localctx, 352, RULE_primaryNoNewArray);
|
|
int _la;
|
|
try {
|
|
setState(1887);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1858);
|
|
literal();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1859);
|
|
typeName();
|
|
setState(1864);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1860);
|
|
match(LBRACK);
|
|
setState(1861);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1866);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1867);
|
|
match(DOT);
|
|
setState(1868);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1870);
|
|
match(VOID);
|
|
setState(1871);
|
|
match(DOT);
|
|
setState(1872);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1873);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1874);
|
|
typeName();
|
|
setState(1875);
|
|
match(DOT);
|
|
setState(1876);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1878);
|
|
match(LPAREN);
|
|
setState(1879);
|
|
expression();
|
|
setState(1880);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1882);
|
|
classInstanceCreationExpression();
|
|
}
|
|
break;
|
|
case 8:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1883);
|
|
fieldAccess();
|
|
}
|
|
break;
|
|
case 9:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1884);
|
|
arrayAccess();
|
|
}
|
|
break;
|
|
case 10:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1885);
|
|
methodInvocation();
|
|
}
|
|
break;
|
|
case 11:
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1886);
|
|
methodReference();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext {
|
|
public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_arrayAccess; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException {
|
|
PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState());
|
|
enterRule(_localctx, 354, RULE_primaryNoNewArray_lf_arrayAccess);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext {
|
|
public LiteralContext literal() {
|
|
return getRuleContext(LiteralContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); }
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); }
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
|
|
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
|
|
}
|
|
public FieldAccessContext fieldAccess() {
|
|
return getRuleContext(FieldAccessContext.class,0);
|
|
}
|
|
public MethodInvocationContext methodInvocation() {
|
|
return getRuleContext(MethodInvocationContext.class,0);
|
|
}
|
|
public MethodReferenceContext methodReference() {
|
|
return getRuleContext(MethodReferenceContext.class,0);
|
|
}
|
|
public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_arrayAccess; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException {
|
|
PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState());
|
|
enterRule(_localctx, 356, RULE_primaryNoNewArray_lfno_arrayAccess);
|
|
int _la;
|
|
try {
|
|
setState(1919);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1891);
|
|
literal();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1892);
|
|
typeName();
|
|
setState(1897);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1893);
|
|
match(LBRACK);
|
|
setState(1894);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1899);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1900);
|
|
match(DOT);
|
|
setState(1901);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1903);
|
|
match(VOID);
|
|
setState(1904);
|
|
match(DOT);
|
|
setState(1905);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1906);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1907);
|
|
typeName();
|
|
setState(1908);
|
|
match(DOT);
|
|
setState(1909);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1911);
|
|
match(LPAREN);
|
|
setState(1912);
|
|
expression();
|
|
setState(1913);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1915);
|
|
classInstanceCreationExpression();
|
|
}
|
|
break;
|
|
case 8:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1916);
|
|
fieldAccess();
|
|
}
|
|
break;
|
|
case 9:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1917);
|
|
methodInvocation();
|
|
}
|
|
break;
|
|
case 10:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1918);
|
|
methodReference();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext {
|
|
public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
|
|
return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
|
|
}
|
|
public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
|
|
return getRuleContext(FieldAccess_lf_primaryContext.class,0);
|
|
}
|
|
public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() {
|
|
return getRuleContext(ArrayAccess_lf_primaryContext.class,0);
|
|
}
|
|
public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
|
|
return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
|
|
}
|
|
public MethodReference_lf_primaryContext methodReference_lf_primary() {
|
|
return getRuleContext(MethodReference_lf_primaryContext.class,0);
|
|
}
|
|
public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 358, RULE_primaryNoNewArray_lf_primary);
|
|
try {
|
|
setState(1926);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1921);
|
|
classInstanceCreationExpression_lf_primary();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1922);
|
|
fieldAccess_lf_primary();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1923);
|
|
arrayAccess_lf_primary();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1924);
|
|
methodInvocation_lf_primary();
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1925);
|
|
methodReference_lf_primary();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext {
|
|
public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 360, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext {
|
|
public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
|
|
return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
|
|
}
|
|
public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
|
|
return getRuleContext(FieldAccess_lf_primaryContext.class,0);
|
|
}
|
|
public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
|
|
return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
|
|
}
|
|
public MethodReference_lf_primaryContext methodReference_lf_primary() {
|
|
return getRuleContext(MethodReference_lf_primaryContext.class,0);
|
|
}
|
|
public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 362, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary);
|
|
try {
|
|
setState(1934);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1930);
|
|
classInstanceCreationExpression_lf_primary();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1931);
|
|
fieldAccess_lf_primary();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1932);
|
|
methodInvocation_lf_primary();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1933);
|
|
methodReference_lf_primary();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext {
|
|
public LiteralContext literal() {
|
|
return getRuleContext(LiteralContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); }
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public UnannPrimitiveTypeContext unannPrimitiveType() {
|
|
return getRuleContext(UnannPrimitiveTypeContext.class,0);
|
|
}
|
|
public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); }
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
|
|
return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
|
|
}
|
|
public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
|
|
return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
|
|
}
|
|
public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() {
|
|
return getRuleContext(ArrayAccess_lfno_primaryContext.class,0);
|
|
}
|
|
public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
|
|
return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
|
|
}
|
|
public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
|
|
return getRuleContext(MethodReference_lfno_primaryContext.class,0);
|
|
}
|
|
public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 364, RULE_primaryNoNewArray_lfno_primary);
|
|
int _la;
|
|
try {
|
|
setState(1976);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1936);
|
|
literal();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1937);
|
|
typeName();
|
|
setState(1942);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1938);
|
|
match(LBRACK);
|
|
setState(1939);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1944);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1945);
|
|
match(DOT);
|
|
setState(1946);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1948);
|
|
unannPrimitiveType();
|
|
setState(1953);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1949);
|
|
match(LBRACK);
|
|
setState(1950);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1955);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1956);
|
|
match(DOT);
|
|
setState(1957);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1959);
|
|
match(VOID);
|
|
setState(1960);
|
|
match(DOT);
|
|
setState(1961);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1962);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1963);
|
|
typeName();
|
|
setState(1964);
|
|
match(DOT);
|
|
setState(1965);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1967);
|
|
match(LPAREN);
|
|
setState(1968);
|
|
expression();
|
|
setState(1969);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 8:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1971);
|
|
classInstanceCreationExpression_lfno_primary();
|
|
}
|
|
break;
|
|
case 9:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1972);
|
|
fieldAccess_lfno_primary();
|
|
}
|
|
break;
|
|
case 10:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1973);
|
|
arrayAccess_lfno_primary();
|
|
}
|
|
break;
|
|
case 11:
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1974);
|
|
methodInvocation_lfno_primary();
|
|
}
|
|
break;
|
|
case 12:
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(1975);
|
|
methodReference_lfno_primary();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext {
|
|
public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 366, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext {
|
|
public LiteralContext literal() {
|
|
return getRuleContext(LiteralContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode CLASS() { return getToken(Java8Parser.CLASS, 0); }
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public UnannPrimitiveTypeContext unannPrimitiveType() {
|
|
return getRuleContext(UnannPrimitiveTypeContext.class,0);
|
|
}
|
|
public TerminalNode VOID() { return getToken(Java8Parser.VOID, 0); }
|
|
public TerminalNode THIS() { return getToken(Java8Parser.THIS, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
|
|
return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
|
|
}
|
|
public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
|
|
return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
|
|
}
|
|
public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
|
|
return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
|
|
}
|
|
public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
|
|
return getRuleContext(MethodReference_lfno_primaryContext.class,0);
|
|
}
|
|
public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; }
|
|
}
|
|
|
|
public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException {
|
|
PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 368, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary);
|
|
int _la;
|
|
try {
|
|
setState(2019);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1980);
|
|
literal();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1981);
|
|
typeName();
|
|
setState(1986);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1982);
|
|
match(LBRACK);
|
|
setState(1983);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1988);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1989);
|
|
match(DOT);
|
|
setState(1990);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1992);
|
|
unannPrimitiveType();
|
|
setState(1997);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1993);
|
|
match(LBRACK);
|
|
setState(1994);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1999);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2000);
|
|
match(DOT);
|
|
setState(2001);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2003);
|
|
match(VOID);
|
|
setState(2004);
|
|
match(DOT);
|
|
setState(2005);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2006);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(2007);
|
|
typeName();
|
|
setState(2008);
|
|
match(DOT);
|
|
setState(2009);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(2011);
|
|
match(LPAREN);
|
|
setState(2012);
|
|
expression();
|
|
setState(2013);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 8:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(2015);
|
|
classInstanceCreationExpression_lfno_primary();
|
|
}
|
|
break;
|
|
case 9:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(2016);
|
|
fieldAccess_lfno_primary();
|
|
}
|
|
break;
|
|
case 10:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(2017);
|
|
methodInvocation_lfno_primary();
|
|
}
|
|
break;
|
|
case 11:
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(2018);
|
|
methodReference_lfno_primary();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassInstanceCreationExpressionContext extends ParserRuleContext {
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); }
|
|
public TerminalNode Identifier(int i) {
|
|
return getToken(Java8Parser.Identifier, i);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
|
|
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression; }
|
|
}
|
|
|
|
public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException {
|
|
ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 370, RULE_classInstanceCreationExpression);
|
|
int _la;
|
|
try {
|
|
setState(2104);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2021);
|
|
match(NEW);
|
|
setState(2023);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2022);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2028);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2025);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2030);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2031);
|
|
match(Identifier);
|
|
setState(2042);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==DOT) {
|
|
{
|
|
{
|
|
setState(2032);
|
|
match(DOT);
|
|
setState(2036);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2033);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2038);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2039);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
setState(2044);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2046);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2045);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2048);
|
|
match(LPAREN);
|
|
setState(2050);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2049);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2052);
|
|
match(RPAREN);
|
|
setState(2054);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACE) {
|
|
{
|
|
setState(2053);
|
|
classBody();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2056);
|
|
expressionName();
|
|
setState(2057);
|
|
match(DOT);
|
|
setState(2058);
|
|
match(NEW);
|
|
setState(2060);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2059);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2065);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2062);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2067);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2068);
|
|
match(Identifier);
|
|
setState(2070);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2069);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2072);
|
|
match(LPAREN);
|
|
setState(2074);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2073);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2076);
|
|
match(RPAREN);
|
|
setState(2078);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACE) {
|
|
{
|
|
setState(2077);
|
|
classBody();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2080);
|
|
primary();
|
|
setState(2081);
|
|
match(DOT);
|
|
setState(2082);
|
|
match(NEW);
|
|
setState(2084);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2083);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2089);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2086);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2091);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2092);
|
|
match(Identifier);
|
|
setState(2094);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2093);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2096);
|
|
match(LPAREN);
|
|
setState(2098);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2097);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2100);
|
|
match(RPAREN);
|
|
setState(2102);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACE) {
|
|
{
|
|
setState(2101);
|
|
classBody();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext {
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
|
|
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lf_primary; }
|
|
}
|
|
|
|
public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException {
|
|
ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 372, RULE_classInstanceCreationExpression_lf_primary);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2106);
|
|
match(DOT);
|
|
setState(2107);
|
|
match(NEW);
|
|
setState(2109);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2108);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2114);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2111);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2116);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2117);
|
|
match(Identifier);
|
|
setState(2119);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2118);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2121);
|
|
match(LPAREN);
|
|
setState(2123);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2122);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2125);
|
|
match(RPAREN);
|
|
setState(2127);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2126);
|
|
classBody();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext {
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); }
|
|
public TerminalNode Identifier(int i) {
|
|
return getToken(Java8Parser.Identifier, i);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
|
|
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lfno_primary; }
|
|
}
|
|
|
|
public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException {
|
|
ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 374, RULE_classInstanceCreationExpression_lfno_primary);
|
|
int _la;
|
|
try {
|
|
setState(2188);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case NEW:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2129);
|
|
match(NEW);
|
|
setState(2131);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2130);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2136);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2133);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2138);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2139);
|
|
match(Identifier);
|
|
setState(2150);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==DOT) {
|
|
{
|
|
{
|
|
setState(2140);
|
|
match(DOT);
|
|
setState(2144);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2141);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2146);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2147);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
setState(2152);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2154);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2153);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2156);
|
|
match(LPAREN);
|
|
setState(2158);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2157);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2160);
|
|
match(RPAREN);
|
|
setState(2162);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2161);
|
|
classBody();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case Identifier:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2164);
|
|
expressionName();
|
|
setState(2165);
|
|
match(DOT);
|
|
setState(2166);
|
|
match(NEW);
|
|
setState(2168);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2167);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2173);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2170);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2175);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2176);
|
|
match(Identifier);
|
|
setState(2178);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2177);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(2180);
|
|
match(LPAREN);
|
|
setState(2182);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2181);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2184);
|
|
match(RPAREN);
|
|
setState(2186);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,237,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2185);
|
|
classBody();
|
|
}
|
|
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;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TypeArgumentsOrDiamondContext extends ParserRuleContext {
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public TerminalNode LT() { return getToken(Java8Parser.LT, 0); }
|
|
public TerminalNode GT() { return getToken(Java8Parser.GT, 0); }
|
|
public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
|
|
}
|
|
|
|
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
|
|
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
|
|
enterRule(_localctx, 376, RULE_typeArgumentsOrDiamond);
|
|
try {
|
|
setState(2193);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2190);
|
|
typeArguments();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2191);
|
|
match(LT);
|
|
setState(2192);
|
|
match(GT);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FieldAccessContext extends ParserRuleContext {
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public FieldAccessContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldAccess; }
|
|
}
|
|
|
|
public final FieldAccessContext fieldAccess() throws RecognitionException {
|
|
FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState());
|
|
enterRule(_localctx, 378, RULE_fieldAccess);
|
|
try {
|
|
setState(2208);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2195);
|
|
primary();
|
|
setState(2196);
|
|
match(DOT);
|
|
setState(2197);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2199);
|
|
match(SUPER);
|
|
setState(2200);
|
|
match(DOT);
|
|
setState(2201);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2202);
|
|
typeName();
|
|
setState(2203);
|
|
match(DOT);
|
|
setState(2204);
|
|
match(SUPER);
|
|
setState(2205);
|
|
match(DOT);
|
|
setState(2206);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FieldAccess_lf_primaryContext extends ParserRuleContext {
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldAccess_lf_primary; }
|
|
}
|
|
|
|
public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException {
|
|
FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 380, RULE_fieldAccess_lf_primary);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2210);
|
|
match(DOT);
|
|
setState(2211);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FieldAccess_lfno_primaryContext extends ParserRuleContext {
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldAccess_lfno_primary; }
|
|
}
|
|
|
|
public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException {
|
|
FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 382, RULE_fieldAccess_lfno_primary);
|
|
try {
|
|
setState(2222);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SUPER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2213);
|
|
match(SUPER);
|
|
setState(2214);
|
|
match(DOT);
|
|
setState(2215);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case Identifier:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2216);
|
|
typeName();
|
|
setState(2217);
|
|
match(DOT);
|
|
setState(2218);
|
|
match(SUPER);
|
|
setState(2219);
|
|
match(DOT);
|
|
setState(2220);
|
|
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;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayAccessContext extends ParserRuleContext {
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() {
|
|
return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0);
|
|
}
|
|
public List<PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() {
|
|
return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class);
|
|
}
|
|
public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) {
|
|
return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class,i);
|
|
}
|
|
public ArrayAccessContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayAccess; }
|
|
}
|
|
|
|
public final ArrayAccessContext arrayAccess() throws RecognitionException {
|
|
ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState());
|
|
enterRule(_localctx, 384, RULE_arrayAccess);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2234);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2224);
|
|
expressionName();
|
|
setState(2225);
|
|
match(LBRACK);
|
|
setState(2226);
|
|
expression();
|
|
setState(2227);
|
|
match(RBRACK);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(2229);
|
|
primaryNoNewArray_lfno_arrayAccess();
|
|
setState(2230);
|
|
match(LBRACK);
|
|
setState(2231);
|
|
expression();
|
|
setState(2232);
|
|
match(RBRACK);
|
|
}
|
|
break;
|
|
}
|
|
setState(2243);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(2236);
|
|
primaryNoNewArray_lf_arrayAccess();
|
|
setState(2237);
|
|
match(LBRACK);
|
|
setState(2238);
|
|
expression();
|
|
setState(2239);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(2245);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayAccess_lf_primaryContext extends ParserRuleContext {
|
|
public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() {
|
|
return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public List<PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() {
|
|
return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class);
|
|
}
|
|
public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) {
|
|
return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class,i);
|
|
}
|
|
public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayAccess_lf_primary; }
|
|
}
|
|
|
|
public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException {
|
|
ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 386, RULE_arrayAccess_lf_primary);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2246);
|
|
primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary();
|
|
setState(2247);
|
|
match(LBRACK);
|
|
setState(2248);
|
|
expression();
|
|
setState(2249);
|
|
match(RBRACK);
|
|
setState(2257);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,244,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(2250);
|
|
primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary();
|
|
setState(2251);
|
|
match(LBRACK);
|
|
setState(2252);
|
|
expression();
|
|
setState(2253);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(2259);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,244,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext {
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java8Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java8Parser.LBRACK, i);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java8Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java8Parser.RBRACK, i);
|
|
}
|
|
public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() {
|
|
return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0);
|
|
}
|
|
public List<PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() {
|
|
return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class);
|
|
}
|
|
public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) {
|
|
return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class,i);
|
|
}
|
|
public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayAccess_lfno_primary; }
|
|
}
|
|
|
|
public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException {
|
|
ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 388, RULE_arrayAccess_lfno_primary);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2270);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,245,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2260);
|
|
expressionName();
|
|
setState(2261);
|
|
match(LBRACK);
|
|
setState(2262);
|
|
expression();
|
|
setState(2263);
|
|
match(RBRACK);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(2265);
|
|
primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary();
|
|
setState(2266);
|
|
match(LBRACK);
|
|
setState(2267);
|
|
expression();
|
|
setState(2268);
|
|
match(RBRACK);
|
|
}
|
|
break;
|
|
}
|
|
setState(2279);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,246,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(2272);
|
|
primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary();
|
|
setState(2273);
|
|
match(LBRACK);
|
|
setState(2274);
|
|
expression();
|
|
setState(2275);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(2281);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,246,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodInvocationContext extends ParserRuleContext {
|
|
public MethodNameContext methodName() {
|
|
return getRuleContext(MethodNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public MethodInvocationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodInvocation; }
|
|
}
|
|
|
|
public final MethodInvocationContext methodInvocation() throws RecognitionException {
|
|
MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState());
|
|
enterRule(_localctx, 390, RULE_methodInvocation);
|
|
int _la;
|
|
try {
|
|
setState(2350);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,258,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2282);
|
|
methodName();
|
|
setState(2283);
|
|
match(LPAREN);
|
|
setState(2285);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2284);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2287);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2289);
|
|
typeName();
|
|
setState(2290);
|
|
match(DOT);
|
|
setState(2292);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2291);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2294);
|
|
match(Identifier);
|
|
setState(2295);
|
|
match(LPAREN);
|
|
setState(2297);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2296);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2299);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2301);
|
|
expressionName();
|
|
setState(2302);
|
|
match(DOT);
|
|
setState(2304);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2303);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2306);
|
|
match(Identifier);
|
|
setState(2307);
|
|
match(LPAREN);
|
|
setState(2309);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2308);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2311);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2313);
|
|
primary();
|
|
setState(2314);
|
|
match(DOT);
|
|
setState(2316);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2315);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2318);
|
|
match(Identifier);
|
|
setState(2319);
|
|
match(LPAREN);
|
|
setState(2321);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2320);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2323);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2325);
|
|
match(SUPER);
|
|
setState(2326);
|
|
match(DOT);
|
|
setState(2328);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2327);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2330);
|
|
match(Identifier);
|
|
setState(2331);
|
|
match(LPAREN);
|
|
setState(2333);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2332);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2335);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(2336);
|
|
typeName();
|
|
setState(2337);
|
|
match(DOT);
|
|
setState(2338);
|
|
match(SUPER);
|
|
setState(2339);
|
|
match(DOT);
|
|
setState(2341);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2340);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2343);
|
|
match(Identifier);
|
|
setState(2344);
|
|
match(LPAREN);
|
|
setState(2346);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2345);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2348);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodInvocation_lf_primaryContext extends ParserRuleContext {
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodInvocation_lf_primary; }
|
|
}
|
|
|
|
public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException {
|
|
MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 392, RULE_methodInvocation_lf_primary);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2352);
|
|
match(DOT);
|
|
setState(2354);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2353);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2356);
|
|
match(Identifier);
|
|
setState(2357);
|
|
match(LPAREN);
|
|
setState(2359);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2358);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2361);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext {
|
|
public MethodNameContext methodName() {
|
|
return getRuleContext(MethodNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public ArgumentListContext argumentList() {
|
|
return getRuleContext(ArgumentListContext.class,0);
|
|
}
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java8Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java8Parser.DOT, i);
|
|
}
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodInvocation_lfno_primary; }
|
|
}
|
|
|
|
public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException {
|
|
MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 394, RULE_methodInvocation_lfno_primary);
|
|
int _la;
|
|
try {
|
|
setState(2419);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,270,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2363);
|
|
methodName();
|
|
setState(2364);
|
|
match(LPAREN);
|
|
setState(2366);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2365);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2368);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2370);
|
|
typeName();
|
|
setState(2371);
|
|
match(DOT);
|
|
setState(2373);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2372);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2375);
|
|
match(Identifier);
|
|
setState(2376);
|
|
match(LPAREN);
|
|
setState(2378);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2377);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2380);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2382);
|
|
expressionName();
|
|
setState(2383);
|
|
match(DOT);
|
|
setState(2385);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2384);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2387);
|
|
match(Identifier);
|
|
setState(2388);
|
|
match(LPAREN);
|
|
setState(2390);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2389);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2392);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2394);
|
|
match(SUPER);
|
|
setState(2395);
|
|
match(DOT);
|
|
setState(2397);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2396);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2399);
|
|
match(Identifier);
|
|
setState(2400);
|
|
match(LPAREN);
|
|
setState(2402);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2401);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2404);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2405);
|
|
typeName();
|
|
setState(2406);
|
|
match(DOT);
|
|
setState(2407);
|
|
match(SUPER);
|
|
setState(2408);
|
|
match(DOT);
|
|
setState(2410);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2409);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2412);
|
|
match(Identifier);
|
|
setState(2413);
|
|
match(LPAREN);
|
|
setState(2415);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 286270087177978152L) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 25769819139L) != 0)) {
|
|
{
|
|
setState(2414);
|
|
argumentList();
|
|
}
|
|
}
|
|
|
|
setState(2417);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArgumentListContext extends ParserRuleContext {
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public ArgumentListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_argumentList; }
|
|
}
|
|
|
|
public final ArgumentListContext argumentList() throws RecognitionException {
|
|
ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
|
|
enterRule(_localctx, 396, RULE_argumentList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2421);
|
|
expression();
|
|
setState(2426);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(2422);
|
|
match(COMMA);
|
|
setState(2423);
|
|
expression();
|
|
}
|
|
}
|
|
setState(2428);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodReferenceContext extends ParserRuleContext {
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public ArrayTypeContext arrayType() {
|
|
return getRuleContext(ArrayTypeContext.class,0);
|
|
}
|
|
public MethodReferenceContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodReference; }
|
|
}
|
|
|
|
public final MethodReferenceContext methodReference() throws RecognitionException {
|
|
MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState());
|
|
enterRule(_localctx, 398, RULE_methodReference);
|
|
int _la;
|
|
try {
|
|
setState(2476);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2429);
|
|
expressionName();
|
|
setState(2430);
|
|
match(COLONCOLON);
|
|
setState(2432);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2431);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2434);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2436);
|
|
referenceType();
|
|
setState(2437);
|
|
match(COLONCOLON);
|
|
setState(2439);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2438);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2441);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2443);
|
|
primary();
|
|
setState(2444);
|
|
match(COLONCOLON);
|
|
setState(2446);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2445);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2448);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2450);
|
|
match(SUPER);
|
|
setState(2451);
|
|
match(COLONCOLON);
|
|
setState(2453);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2452);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2455);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2456);
|
|
typeName();
|
|
setState(2457);
|
|
match(DOT);
|
|
setState(2458);
|
|
match(SUPER);
|
|
setState(2459);
|
|
match(COLONCOLON);
|
|
setState(2461);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2460);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2463);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(2465);
|
|
classType();
|
|
setState(2466);
|
|
match(COLONCOLON);
|
|
setState(2468);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2467);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2470);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(2472);
|
|
arrayType();
|
|
setState(2473);
|
|
match(COLONCOLON);
|
|
setState(2474);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodReference_lf_primaryContext extends ParserRuleContext {
|
|
public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodReference_lf_primary; }
|
|
}
|
|
|
|
public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException {
|
|
MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 400, RULE_methodReference_lf_primary);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2478);
|
|
match(COLONCOLON);
|
|
setState(2480);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2479);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2482);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodReference_lfno_primaryContext extends ParserRuleContext {
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public TerminalNode COLONCOLON() { return getToken(Java8Parser.COLONCOLON, 0); }
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java8Parser.SUPER, 0); }
|
|
public TypeNameContext typeName() {
|
|
return getRuleContext(TypeNameContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java8Parser.DOT, 0); }
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public ArrayTypeContext arrayType() {
|
|
return getRuleContext(ArrayTypeContext.class,0);
|
|
}
|
|
public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodReference_lfno_primary; }
|
|
}
|
|
|
|
public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException {
|
|
MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState());
|
|
enterRule(_localctx, 402, RULE_methodReference_lfno_primary);
|
|
int _la;
|
|
try {
|
|
setState(2524);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2484);
|
|
expressionName();
|
|
setState(2485);
|
|
match(COLONCOLON);
|
|
setState(2487);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2486);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2489);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2491);
|
|
referenceType();
|
|
setState(2492);
|
|
match(COLONCOLON);
|
|
setState(2494);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2493);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2496);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2498);
|
|
match(SUPER);
|
|
setState(2499);
|
|
match(COLONCOLON);
|
|
setState(2501);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2500);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2503);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2504);
|
|
typeName();
|
|
setState(2505);
|
|
match(DOT);
|
|
setState(2506);
|
|
match(SUPER);
|
|
setState(2507);
|
|
match(COLONCOLON);
|
|
setState(2509);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2508);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2511);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2513);
|
|
classType();
|
|
setState(2514);
|
|
match(COLONCOLON);
|
|
setState(2516);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(2515);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(2518);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(2520);
|
|
arrayType();
|
|
setState(2521);
|
|
match(COLONCOLON);
|
|
setState(2522);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayCreationExpressionContext extends ParserRuleContext {
|
|
public TerminalNode NEW() { return getToken(Java8Parser.NEW, 0); }
|
|
public PrimitiveTypeContext primitiveType() {
|
|
return getRuleContext(PrimitiveTypeContext.class,0);
|
|
}
|
|
public DimExprsContext dimExprs() {
|
|
return getRuleContext(DimExprsContext.class,0);
|
|
}
|
|
public DimsContext dims() {
|
|
return getRuleContext(DimsContext.class,0);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public ArrayInitializerContext arrayInitializer() {
|
|
return getRuleContext(ArrayInitializerContext.class,0);
|
|
}
|
|
public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayCreationExpression; }
|
|
}
|
|
|
|
public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException {
|
|
ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 404, RULE_arrayCreationExpression);
|
|
try {
|
|
setState(2548);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,288,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2526);
|
|
match(NEW);
|
|
setState(2527);
|
|
primitiveType();
|
|
setState(2528);
|
|
dimExprs();
|
|
setState(2530);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,286,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2529);
|
|
dims();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2532);
|
|
match(NEW);
|
|
setState(2533);
|
|
classOrInterfaceType();
|
|
setState(2534);
|
|
dimExprs();
|
|
setState(2536);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2535);
|
|
dims();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2538);
|
|
match(NEW);
|
|
setState(2539);
|
|
primitiveType();
|
|
setState(2540);
|
|
dims();
|
|
setState(2541);
|
|
arrayInitializer();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2543);
|
|
match(NEW);
|
|
setState(2544);
|
|
classOrInterfaceType();
|
|
setState(2545);
|
|
dims();
|
|
setState(2546);
|
|
arrayInitializer();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DimExprsContext extends ParserRuleContext {
|
|
public List<DimExprContext> dimExpr() {
|
|
return getRuleContexts(DimExprContext.class);
|
|
}
|
|
public DimExprContext dimExpr(int i) {
|
|
return getRuleContext(DimExprContext.class,i);
|
|
}
|
|
public DimExprsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_dimExprs; }
|
|
}
|
|
|
|
public final DimExprsContext dimExprs() throws RecognitionException {
|
|
DimExprsContext _localctx = new DimExprsContext(_ctx, getState());
|
|
enterRule(_localctx, 406, RULE_dimExprs);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2550);
|
|
dimExpr();
|
|
setState(2554);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,289,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(2551);
|
|
dimExpr();
|
|
}
|
|
}
|
|
}
|
|
setState(2556);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,289,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DimExprContext extends ParserRuleContext {
|
|
public TerminalNode LBRACK() { return getToken(Java8Parser.LBRACK, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RBRACK() { return getToken(Java8Parser.RBRACK, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public DimExprContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_dimExpr; }
|
|
}
|
|
|
|
public final DimExprContext dimExpr() throws RecognitionException {
|
|
DimExprContext _localctx = new DimExprContext(_ctx, getState());
|
|
enterRule(_localctx, 408, RULE_dimExpr);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2560);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==AT) {
|
|
{
|
|
{
|
|
setState(2557);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(2562);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2563);
|
|
match(LBRACK);
|
|
setState(2564);
|
|
expression();
|
|
setState(2565);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
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; }
|
|
}
|
|
|
|
public final ConstantExpressionContext constantExpression() throws RecognitionException {
|
|
ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 410, RULE_constantExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2567);
|
|
expression();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExpressionContext extends ParserRuleContext {
|
|
public LambdaExpressionContext lambdaExpression() {
|
|
return getRuleContext(LambdaExpressionContext.class,0);
|
|
}
|
|
public AssignmentExpressionContext assignmentExpression() {
|
|
return getRuleContext(AssignmentExpressionContext.class,0);
|
|
}
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expression; }
|
|
}
|
|
|
|
public final ExpressionContext expression() throws RecognitionException {
|
|
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 412, RULE_expression);
|
|
try {
|
|
setState(2571);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,291,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2569);
|
|
lambdaExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2570);
|
|
assignmentExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LambdaExpressionContext extends ParserRuleContext {
|
|
public LambdaParametersContext lambdaParameters() {
|
|
return getRuleContext(LambdaParametersContext.class,0);
|
|
}
|
|
public TerminalNode ARROW() { return getToken(Java8Parser.ARROW, 0); }
|
|
public LambdaBodyContext lambdaBody() {
|
|
return getRuleContext(LambdaBodyContext.class,0);
|
|
}
|
|
public LambdaExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaExpression; }
|
|
}
|
|
|
|
public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
|
|
LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 414, RULE_lambdaExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2573);
|
|
lambdaParameters();
|
|
setState(2574);
|
|
match(ARROW);
|
|
setState(2575);
|
|
lambdaBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LambdaParametersContext extends ParserRuleContext {
|
|
public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public FormalParameterListContext formalParameterList() {
|
|
return getRuleContext(FormalParameterListContext.class,0);
|
|
}
|
|
public InferredFormalParameterListContext inferredFormalParameterList() {
|
|
return getRuleContext(InferredFormalParameterListContext.class,0);
|
|
}
|
|
public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaParameters; }
|
|
}
|
|
|
|
public final LambdaParametersContext lambdaParameters() throws RecognitionException {
|
|
LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
|
|
enterRule(_localctx, 416, RULE_lambdaParameters);
|
|
int _la;
|
|
try {
|
|
setState(2587);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2577);
|
|
match(Identifier);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2578);
|
|
match(LPAREN);
|
|
setState(2580);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 138111369512L) != 0) || _la==Identifier || _la==AT) {
|
|
{
|
|
setState(2579);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
setState(2582);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2583);
|
|
match(LPAREN);
|
|
setState(2584);
|
|
inferredFormalParameterList();
|
|
setState(2585);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InferredFormalParameterListContext extends ParserRuleContext {
|
|
public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); }
|
|
public TerminalNode Identifier(int i) {
|
|
return getToken(Java8Parser.Identifier, i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java8Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java8Parser.COMMA, i);
|
|
}
|
|
public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_inferredFormalParameterList; }
|
|
}
|
|
|
|
public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException {
|
|
InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState());
|
|
enterRule(_localctx, 418, RULE_inferredFormalParameterList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2589);
|
|
match(Identifier);
|
|
setState(2594);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(2590);
|
|
match(COMMA);
|
|
setState(2591);
|
|
match(Identifier);
|
|
}
|
|
}
|
|
setState(2596);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LambdaBodyContext extends ParserRuleContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public LambdaBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaBody; }
|
|
}
|
|
|
|
public final LambdaBodyContext lambdaBody() throws RecognitionException {
|
|
LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 420, RULE_lambdaBody);
|
|
try {
|
|
setState(2599);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
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 IntegerLiteral:
|
|
case FloatingPointLiteral:
|
|
case BooleanLiteral:
|
|
case CharacterLiteral:
|
|
case StringLiteral:
|
|
case NullLiteral:
|
|
case LPAREN:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case Identifier:
|
|
case AT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2597);
|
|
expression();
|
|
}
|
|
break;
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2598);
|
|
block();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssignmentExpressionContext extends ParserRuleContext {
|
|
public ConditionalExpressionContext conditionalExpression() {
|
|
return getRuleContext(ConditionalExpressionContext.class,0);
|
|
}
|
|
public AssignmentContext assignment() {
|
|
return getRuleContext(AssignmentContext.class,0);
|
|
}
|
|
public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_assignmentExpression; }
|
|
}
|
|
|
|
public final AssignmentExpressionContext assignmentExpression() throws RecognitionException {
|
|
AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 422, RULE_assignmentExpression);
|
|
try {
|
|
setState(2603);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2601);
|
|
conditionalExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2602);
|
|
assignment();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssignmentContext extends ParserRuleContext {
|
|
public LeftHandSideContext leftHandSide() {
|
|
return getRuleContext(LeftHandSideContext.class,0);
|
|
}
|
|
public AssignmentOperatorContext assignmentOperator() {
|
|
return getRuleContext(AssignmentOperatorContext.class,0);
|
|
}
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public AssignmentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_assignment; }
|
|
}
|
|
|
|
public final AssignmentContext assignment() throws RecognitionException {
|
|
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
|
|
enterRule(_localctx, 424, RULE_assignment);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2605);
|
|
leftHandSide();
|
|
setState(2606);
|
|
assignmentOperator();
|
|
setState(2607);
|
|
expression();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LeftHandSideContext extends ParserRuleContext {
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public FieldAccessContext fieldAccess() {
|
|
return getRuleContext(FieldAccessContext.class,0);
|
|
}
|
|
public ArrayAccessContext arrayAccess() {
|
|
return getRuleContext(ArrayAccessContext.class,0);
|
|
}
|
|
public LeftHandSideContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_leftHandSide; }
|
|
}
|
|
|
|
public final LeftHandSideContext leftHandSide() throws RecognitionException {
|
|
LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState());
|
|
enterRule(_localctx, 426, RULE_leftHandSide);
|
|
try {
|
|
setState(2612);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,297,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2609);
|
|
expressionName();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2610);
|
|
fieldAccess();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2611);
|
|
arrayAccess();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssignmentOperatorContext extends ParserRuleContext {
|
|
public TerminalNode ASSIGN() { return getToken(Java8Parser.ASSIGN, 0); }
|
|
public TerminalNode MUL_ASSIGN() { return getToken(Java8Parser.MUL_ASSIGN, 0); }
|
|
public TerminalNode DIV_ASSIGN() { return getToken(Java8Parser.DIV_ASSIGN, 0); }
|
|
public TerminalNode MOD_ASSIGN() { return getToken(Java8Parser.MOD_ASSIGN, 0); }
|
|
public TerminalNode ADD_ASSIGN() { return getToken(Java8Parser.ADD_ASSIGN, 0); }
|
|
public TerminalNode SUB_ASSIGN() { return getToken(Java8Parser.SUB_ASSIGN, 0); }
|
|
public TerminalNode LSHIFT_ASSIGN() { return getToken(Java8Parser.LSHIFT_ASSIGN, 0); }
|
|
public TerminalNode RSHIFT_ASSIGN() { return getToken(Java8Parser.RSHIFT_ASSIGN, 0); }
|
|
public TerminalNode URSHIFT_ASSIGN() { return getToken(Java8Parser.URSHIFT_ASSIGN, 0); }
|
|
public TerminalNode AND_ASSIGN() { return getToken(Java8Parser.AND_ASSIGN, 0); }
|
|
public TerminalNode XOR_ASSIGN() { return getToken(Java8Parser.XOR_ASSIGN, 0); }
|
|
public TerminalNode OR_ASSIGN() { return getToken(Java8Parser.OR_ASSIGN, 0); }
|
|
public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_assignmentOperator; }
|
|
}
|
|
|
|
public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
|
|
AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
|
|
enterRule(_localctx, 428, RULE_assignmentOperator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2614);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 68685922305L) != 0)) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConditionalExpressionContext extends ParserRuleContext {
|
|
public ConditionalOrExpressionContext conditionalOrExpression() {
|
|
return getRuleContext(ConditionalOrExpressionContext.class,0);
|
|
}
|
|
public TerminalNode QUESTION() { return getToken(Java8Parser.QUESTION, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java8Parser.COLON, 0); }
|
|
public ConditionalExpressionContext conditionalExpression() {
|
|
return getRuleContext(ConditionalExpressionContext.class,0);
|
|
}
|
|
public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_conditionalExpression; }
|
|
}
|
|
|
|
public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
|
|
ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 430, RULE_conditionalExpression);
|
|
try {
|
|
setState(2623);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2616);
|
|
conditionalOrExpression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2617);
|
|
conditionalOrExpression(0);
|
|
setState(2618);
|
|
match(QUESTION);
|
|
setState(2619);
|
|
expression();
|
|
setState(2620);
|
|
match(COLON);
|
|
setState(2621);
|
|
conditionalExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConditionalOrExpressionContext extends ParserRuleContext {
|
|
public ConditionalAndExpressionContext conditionalAndExpression() {
|
|
return getRuleContext(ConditionalAndExpressionContext.class,0);
|
|
}
|
|
public ConditionalOrExpressionContext conditionalOrExpression() {
|
|
return getRuleContext(ConditionalOrExpressionContext.class,0);
|
|
}
|
|
public TerminalNode OR() { return getToken(Java8Parser.OR, 0); }
|
|
public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_conditionalOrExpression; }
|
|
}
|
|
|
|
public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException {
|
|
return conditionalOrExpression(0);
|
|
}
|
|
|
|
private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState);
|
|
ConditionalOrExpressionContext _prevctx = _localctx;
|
|
int _startState = 432;
|
|
enterRecursionRule(_localctx, 432, RULE_conditionalOrExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2626);
|
|
conditionalAndExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2633);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,299,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new ConditionalOrExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression);
|
|
setState(2628);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2629);
|
|
match(OR);
|
|
setState(2630);
|
|
conditionalAndExpression(0);
|
|
}
|
|
}
|
|
}
|
|
setState(2635);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,299,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConditionalAndExpressionContext extends ParserRuleContext {
|
|
public InclusiveOrExpressionContext inclusiveOrExpression() {
|
|
return getRuleContext(InclusiveOrExpressionContext.class,0);
|
|
}
|
|
public ConditionalAndExpressionContext conditionalAndExpression() {
|
|
return getRuleContext(ConditionalAndExpressionContext.class,0);
|
|
}
|
|
public TerminalNode AND() { return getToken(Java8Parser.AND, 0); }
|
|
public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_conditionalAndExpression; }
|
|
}
|
|
|
|
public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException {
|
|
return conditionalAndExpression(0);
|
|
}
|
|
|
|
private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState);
|
|
ConditionalAndExpressionContext _prevctx = _localctx;
|
|
int _startState = 434;
|
|
enterRecursionRule(_localctx, 434, RULE_conditionalAndExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2637);
|
|
inclusiveOrExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2644);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,300,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new ConditionalAndExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression);
|
|
setState(2639);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2640);
|
|
match(AND);
|
|
setState(2641);
|
|
inclusiveOrExpression(0);
|
|
}
|
|
}
|
|
}
|
|
setState(2646);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,300,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InclusiveOrExpressionContext extends ParserRuleContext {
|
|
public ExclusiveOrExpressionContext exclusiveOrExpression() {
|
|
return getRuleContext(ExclusiveOrExpressionContext.class,0);
|
|
}
|
|
public InclusiveOrExpressionContext inclusiveOrExpression() {
|
|
return getRuleContext(InclusiveOrExpressionContext.class,0);
|
|
}
|
|
public TerminalNode BITOR() { return getToken(Java8Parser.BITOR, 0); }
|
|
public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_inclusiveOrExpression; }
|
|
}
|
|
|
|
public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException {
|
|
return inclusiveOrExpression(0);
|
|
}
|
|
|
|
private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState);
|
|
InclusiveOrExpressionContext _prevctx = _localctx;
|
|
int _startState = 436;
|
|
enterRecursionRule(_localctx, 436, RULE_inclusiveOrExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2648);
|
|
exclusiveOrExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2655);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,301,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new InclusiveOrExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression);
|
|
setState(2650);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2651);
|
|
match(BITOR);
|
|
setState(2652);
|
|
exclusiveOrExpression(0);
|
|
}
|
|
}
|
|
}
|
|
setState(2657);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,301,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExclusiveOrExpressionContext extends ParserRuleContext {
|
|
public AndExpressionContext andExpression() {
|
|
return getRuleContext(AndExpressionContext.class,0);
|
|
}
|
|
public ExclusiveOrExpressionContext exclusiveOrExpression() {
|
|
return getRuleContext(ExclusiveOrExpressionContext.class,0);
|
|
}
|
|
public TerminalNode CARET() { return getToken(Java8Parser.CARET, 0); }
|
|
public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_exclusiveOrExpression; }
|
|
}
|
|
|
|
public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
|
|
return exclusiveOrExpression(0);
|
|
}
|
|
|
|
private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState);
|
|
ExclusiveOrExpressionContext _prevctx = _localctx;
|
|
int _startState = 438;
|
|
enterRecursionRule(_localctx, 438, RULE_exclusiveOrExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2659);
|
|
andExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2666);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,302,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression);
|
|
setState(2661);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2662);
|
|
match(CARET);
|
|
setState(2663);
|
|
andExpression(0);
|
|
}
|
|
}
|
|
}
|
|
setState(2668);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,302,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AndExpressionContext extends ParserRuleContext {
|
|
public EqualityExpressionContext equalityExpression() {
|
|
return getRuleContext(EqualityExpressionContext.class,0);
|
|
}
|
|
public AndExpressionContext andExpression() {
|
|
return getRuleContext(AndExpressionContext.class,0);
|
|
}
|
|
public TerminalNode BITAND() { return getToken(Java8Parser.BITAND, 0); }
|
|
public AndExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_andExpression; }
|
|
}
|
|
|
|
public final AndExpressionContext andExpression() throws RecognitionException {
|
|
return andExpression(0);
|
|
}
|
|
|
|
private AndExpressionContext andExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState);
|
|
AndExpressionContext _prevctx = _localctx;
|
|
int _startState = 440;
|
|
enterRecursionRule(_localctx, 440, RULE_andExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2670);
|
|
equalityExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2677);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,303,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new AndExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_andExpression);
|
|
setState(2672);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2673);
|
|
match(BITAND);
|
|
setState(2674);
|
|
equalityExpression(0);
|
|
}
|
|
}
|
|
}
|
|
setState(2679);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,303,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EqualityExpressionContext extends ParserRuleContext {
|
|
public RelationalExpressionContext relationalExpression() {
|
|
return getRuleContext(RelationalExpressionContext.class,0);
|
|
}
|
|
public EqualityExpressionContext equalityExpression() {
|
|
return getRuleContext(EqualityExpressionContext.class,0);
|
|
}
|
|
public TerminalNode EQUAL() { return getToken(Java8Parser.EQUAL, 0); }
|
|
public TerminalNode NOTEQUAL() { return getToken(Java8Parser.NOTEQUAL, 0); }
|
|
public EqualityExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_equalityExpression; }
|
|
}
|
|
|
|
public final EqualityExpressionContext equalityExpression() throws RecognitionException {
|
|
return equalityExpression(0);
|
|
}
|
|
|
|
private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState);
|
|
EqualityExpressionContext _prevctx = _localctx;
|
|
int _startState = 442;
|
|
enterRecursionRule(_localctx, 442, RULE_equalityExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2681);
|
|
relationalExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2691);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,305,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(2689);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,304,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
|
|
setState(2683);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(2684);
|
|
match(EQUAL);
|
|
setState(2685);
|
|
relationalExpression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
|
|
setState(2686);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2687);
|
|
match(NOTEQUAL);
|
|
setState(2688);
|
|
relationalExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(2693);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,305,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RelationalExpressionContext extends ParserRuleContext {
|
|
public ShiftExpressionContext shiftExpression() {
|
|
return getRuleContext(ShiftExpressionContext.class,0);
|
|
}
|
|
public RelationalExpressionContext relationalExpression() {
|
|
return getRuleContext(RelationalExpressionContext.class,0);
|
|
}
|
|
public TerminalNode LT() { return getToken(Java8Parser.LT, 0); }
|
|
public TerminalNode GT() { return getToken(Java8Parser.GT, 0); }
|
|
public TerminalNode LE() { return getToken(Java8Parser.LE, 0); }
|
|
public TerminalNode GE() { return getToken(Java8Parser.GE, 0); }
|
|
public TerminalNode INSTANCEOF() { return getToken(Java8Parser.INSTANCEOF, 0); }
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_relationalExpression; }
|
|
}
|
|
|
|
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
|
|
return relationalExpression(0);
|
|
}
|
|
|
|
private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState);
|
|
RelationalExpressionContext _prevctx = _localctx;
|
|
int _startState = 444;
|
|
enterRecursionRule(_localctx, 444, RULE_relationalExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2695);
|
|
shiftExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2714);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,307,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(2712);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
|
|
setState(2697);
|
|
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(2698);
|
|
match(LT);
|
|
setState(2699);
|
|
shiftExpression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
|
|
setState(2700);
|
|
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
|
|
setState(2701);
|
|
match(GT);
|
|
setState(2702);
|
|
shiftExpression(0);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
|
|
setState(2703);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(2704);
|
|
match(LE);
|
|
setState(2705);
|
|
shiftExpression(0);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
|
|
setState(2706);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(2707);
|
|
match(GE);
|
|
setState(2708);
|
|
shiftExpression(0);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
|
|
setState(2709);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2710);
|
|
match(INSTANCEOF);
|
|
setState(2711);
|
|
referenceType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(2716);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,307,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ShiftExpressionContext extends ParserRuleContext {
|
|
public AdditiveExpressionContext additiveExpression() {
|
|
return getRuleContext(AdditiveExpressionContext.class,0);
|
|
}
|
|
public ShiftExpressionContext shiftExpression() {
|
|
return getRuleContext(ShiftExpressionContext.class,0);
|
|
}
|
|
public List<TerminalNode> LT() { return getTokens(Java8Parser.LT); }
|
|
public TerminalNode LT(int i) {
|
|
return getToken(Java8Parser.LT, i);
|
|
}
|
|
public List<TerminalNode> GT() { return getTokens(Java8Parser.GT); }
|
|
public TerminalNode GT(int i) {
|
|
return getToken(Java8Parser.GT, i);
|
|
}
|
|
public ShiftExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_shiftExpression; }
|
|
}
|
|
|
|
public final ShiftExpressionContext shiftExpression() throws RecognitionException {
|
|
return shiftExpression(0);
|
|
}
|
|
|
|
private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState);
|
|
ShiftExpressionContext _prevctx = _localctx;
|
|
int _startState = 446;
|
|
enterRecursionRule(_localctx, 446, RULE_shiftExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2718);
|
|
additiveExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2735);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,309,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(2733);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
|
|
setState(2720);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(2721);
|
|
match(LT);
|
|
setState(2722);
|
|
match(LT);
|
|
setState(2723);
|
|
additiveExpression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
|
|
setState(2724);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(2725);
|
|
match(GT);
|
|
setState(2726);
|
|
match(GT);
|
|
setState(2727);
|
|
additiveExpression(0);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
|
|
setState(2728);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2729);
|
|
match(GT);
|
|
setState(2730);
|
|
match(GT);
|
|
setState(2731);
|
|
match(GT);
|
|
setState(2732);
|
|
additiveExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(2737);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,309,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AdditiveExpressionContext extends ParserRuleContext {
|
|
public MultiplicativeExpressionContext multiplicativeExpression() {
|
|
return getRuleContext(MultiplicativeExpressionContext.class,0);
|
|
}
|
|
public AdditiveExpressionContext additiveExpression() {
|
|
return getRuleContext(AdditiveExpressionContext.class,0);
|
|
}
|
|
public TerminalNode ADD() { return getToken(Java8Parser.ADD, 0); }
|
|
public TerminalNode SUB() { return getToken(Java8Parser.SUB, 0); }
|
|
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_additiveExpression; }
|
|
}
|
|
|
|
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
|
|
return additiveExpression(0);
|
|
}
|
|
|
|
private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState);
|
|
AdditiveExpressionContext _prevctx = _localctx;
|
|
int _startState = 448;
|
|
enterRecursionRule(_localctx, 448, RULE_additiveExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2739);
|
|
multiplicativeExpression(0);
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2749);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,311,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(2747);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
|
|
setState(2741);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(2742);
|
|
match(ADD);
|
|
setState(2743);
|
|
multiplicativeExpression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
|
|
setState(2744);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2745);
|
|
match(SUB);
|
|
setState(2746);
|
|
multiplicativeExpression(0);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(2751);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,311,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MultiplicativeExpressionContext extends ParserRuleContext {
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public MultiplicativeExpressionContext multiplicativeExpression() {
|
|
return getRuleContext(MultiplicativeExpressionContext.class,0);
|
|
}
|
|
public TerminalNode MUL() { return getToken(Java8Parser.MUL, 0); }
|
|
public TerminalNode DIV() { return getToken(Java8Parser.DIV, 0); }
|
|
public TerminalNode MOD() { return getToken(Java8Parser.MOD, 0); }
|
|
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
|
|
}
|
|
|
|
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
|
|
return multiplicativeExpression(0);
|
|
}
|
|
|
|
private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState);
|
|
MultiplicativeExpressionContext _prevctx = _localctx;
|
|
int _startState = 450;
|
|
enterRecursionRule(_localctx, 450, RULE_multiplicativeExpression, _p);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
{
|
|
setState(2753);
|
|
unaryExpression();
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(2766);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,313,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(2764);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,312,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
|
|
setState(2755);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(2756);
|
|
match(MUL);
|
|
setState(2757);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
|
|
setState(2758);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(2759);
|
|
match(DIV);
|
|
setState(2760);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
|
|
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
|
|
setState(2761);
|
|
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(2762);
|
|
match(MOD);
|
|
setState(2763);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(2768);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,313,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnaryExpressionContext extends ParserRuleContext {
|
|
public PreIncrementExpressionContext preIncrementExpression() {
|
|
return getRuleContext(PreIncrementExpressionContext.class,0);
|
|
}
|
|
public PreDecrementExpressionContext preDecrementExpression() {
|
|
return getRuleContext(PreDecrementExpressionContext.class,0);
|
|
}
|
|
public TerminalNode ADD() { return getToken(Java8Parser.ADD, 0); }
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SUB() { return getToken(Java8Parser.SUB, 0); }
|
|
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
|
|
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
|
|
}
|
|
public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unaryExpression; }
|
|
}
|
|
|
|
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
|
|
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 452, RULE_unaryExpression);
|
|
try {
|
|
setState(2776);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case INC:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2769);
|
|
preIncrementExpression();
|
|
}
|
|
break;
|
|
case DEC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2770);
|
|
preDecrementExpression();
|
|
}
|
|
break;
|
|
case ADD:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2771);
|
|
match(ADD);
|
|
setState(2772);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case SUB:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2773);
|
|
match(SUB);
|
|
setState(2774);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
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 IntegerLiteral:
|
|
case FloatingPointLiteral:
|
|
case BooleanLiteral:
|
|
case CharacterLiteral:
|
|
case StringLiteral:
|
|
case NullLiteral:
|
|
case LPAREN:
|
|
case BANG:
|
|
case TILDE:
|
|
case Identifier:
|
|
case AT:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(2775);
|
|
unaryExpressionNotPlusMinus();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PreIncrementExpressionContext extends ParserRuleContext {
|
|
public TerminalNode INC() { return getToken(Java8Parser.INC, 0); }
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_preIncrementExpression; }
|
|
}
|
|
|
|
public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException {
|
|
PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 454, RULE_preIncrementExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2778);
|
|
match(INC);
|
|
setState(2779);
|
|
unaryExpression();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PreDecrementExpressionContext extends ParserRuleContext {
|
|
public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); }
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_preDecrementExpression; }
|
|
}
|
|
|
|
public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException {
|
|
PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 456, RULE_preDecrementExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2781);
|
|
match(DEC);
|
|
setState(2782);
|
|
unaryExpression();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext {
|
|
public PostfixExpressionContext postfixExpression() {
|
|
return getRuleContext(PostfixExpressionContext.class,0);
|
|
}
|
|
public TerminalNode TILDE() { return getToken(Java8Parser.TILDE, 0); }
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public TerminalNode BANG() { return getToken(Java8Parser.BANG, 0); }
|
|
public CastExpressionContext castExpression() {
|
|
return getRuleContext(CastExpressionContext.class,0);
|
|
}
|
|
public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; }
|
|
}
|
|
|
|
public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException {
|
|
UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState());
|
|
enterRule(_localctx, 458, RULE_unaryExpressionNotPlusMinus);
|
|
try {
|
|
setState(2790);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2784);
|
|
postfixExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2785);
|
|
match(TILDE);
|
|
setState(2786);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2787);
|
|
match(BANG);
|
|
setState(2788);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(2789);
|
|
castExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostfixExpressionContext extends ParserRuleContext {
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public ExpressionNameContext expressionName() {
|
|
return getRuleContext(ExpressionNameContext.class,0);
|
|
}
|
|
public List<PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() {
|
|
return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class);
|
|
}
|
|
public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) {
|
|
return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class,i);
|
|
}
|
|
public List<PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() {
|
|
return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class);
|
|
}
|
|
public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) {
|
|
return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class,i);
|
|
}
|
|
public PostfixExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_postfixExpression; }
|
|
}
|
|
|
|
public final PostfixExpressionContext postfixExpression() throws RecognitionException {
|
|
PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 460, RULE_postfixExpression);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2794);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,316,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(2792);
|
|
primary();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(2793);
|
|
expressionName();
|
|
}
|
|
break;
|
|
}
|
|
setState(2800);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
setState(2798);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case INC:
|
|
{
|
|
setState(2796);
|
|
postIncrementExpression_lf_postfixExpression();
|
|
}
|
|
break;
|
|
case DEC:
|
|
{
|
|
setState(2797);
|
|
postDecrementExpression_lf_postfixExpression();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
}
|
|
setState(2802);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostIncrementExpressionContext extends ParserRuleContext {
|
|
public PostfixExpressionContext postfixExpression() {
|
|
return getRuleContext(PostfixExpressionContext.class,0);
|
|
}
|
|
public TerminalNode INC() { return getToken(Java8Parser.INC, 0); }
|
|
public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_postIncrementExpression; }
|
|
}
|
|
|
|
public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException {
|
|
PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 462, RULE_postIncrementExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2803);
|
|
postfixExpression();
|
|
setState(2804);
|
|
match(INC);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
|
|
public TerminalNode INC() { return getToken(Java8Parser.INC, 0); }
|
|
public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_postIncrementExpression_lf_postfixExpression; }
|
|
}
|
|
|
|
public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException {
|
|
PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 464, RULE_postIncrementExpression_lf_postfixExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2806);
|
|
match(INC);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostDecrementExpressionContext extends ParserRuleContext {
|
|
public PostfixExpressionContext postfixExpression() {
|
|
return getRuleContext(PostfixExpressionContext.class,0);
|
|
}
|
|
public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); }
|
|
public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_postDecrementExpression; }
|
|
}
|
|
|
|
public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException {
|
|
PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 466, RULE_postDecrementExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2808);
|
|
postfixExpression();
|
|
setState(2809);
|
|
match(DEC);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
|
|
public TerminalNode DEC() { return getToken(Java8Parser.DEC, 0); }
|
|
public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_postDecrementExpression_lf_postfixExpression; }
|
|
}
|
|
|
|
public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException {
|
|
PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 468, RULE_postDecrementExpression_lf_postfixExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2811);
|
|
match(DEC);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CastExpressionContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java8Parser.LPAREN, 0); }
|
|
public PrimitiveTypeContext primitiveType() {
|
|
return getRuleContext(PrimitiveTypeContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java8Parser.RPAREN, 0); }
|
|
public UnaryExpressionContext unaryExpression() {
|
|
return getRuleContext(UnaryExpressionContext.class,0);
|
|
}
|
|
public ReferenceTypeContext referenceType() {
|
|
return getRuleContext(ReferenceTypeContext.class,0);
|
|
}
|
|
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
|
|
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
|
|
}
|
|
public List<AdditionalBoundContext> additionalBound() {
|
|
return getRuleContexts(AdditionalBoundContext.class);
|
|
}
|
|
public AdditionalBoundContext additionalBound(int i) {
|
|
return getRuleContext(AdditionalBoundContext.class,i);
|
|
}
|
|
public LambdaExpressionContext lambdaExpression() {
|
|
return getRuleContext(LambdaExpressionContext.class,0);
|
|
}
|
|
public CastExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_castExpression; }
|
|
}
|
|
|
|
public final CastExpressionContext castExpression() throws RecognitionException {
|
|
CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 470, RULE_castExpression);
|
|
int _la;
|
|
try {
|
|
setState(2840);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,321,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(2813);
|
|
match(LPAREN);
|
|
setState(2814);
|
|
primitiveType();
|
|
setState(2815);
|
|
match(RPAREN);
|
|
setState(2816);
|
|
unaryExpression();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(2818);
|
|
match(LPAREN);
|
|
setState(2819);
|
|
referenceType();
|
|
setState(2823);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITAND) {
|
|
{
|
|
{
|
|
setState(2820);
|
|
additionalBound();
|
|
}
|
|
}
|
|
setState(2825);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2826);
|
|
match(RPAREN);
|
|
setState(2827);
|
|
unaryExpressionNotPlusMinus();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(2829);
|
|
match(LPAREN);
|
|
setState(2830);
|
|
referenceType();
|
|
setState(2834);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITAND) {
|
|
{
|
|
{
|
|
setState(2831);
|
|
additionalBound();
|
|
}
|
|
}
|
|
setState(2836);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(2837);
|
|
match(RPAREN);
|
|
setState(2838);
|
|
lambdaExpression();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
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 25:
|
|
return packageName_sempred((PackageNameContext)_localctx, predIndex);
|
|
case 27:
|
|
return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex);
|
|
case 30:
|
|
return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex);
|
|
case 216:
|
|
return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex);
|
|
case 217:
|
|
return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex);
|
|
case 218:
|
|
return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex);
|
|
case 219:
|
|
return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex);
|
|
case 220:
|
|
return andExpression_sempred((AndExpressionContext)_localctx, predIndex);
|
|
case 221:
|
|
return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex);
|
|
case 222:
|
|
return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex);
|
|
case 223:
|
|
return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex);
|
|
case 224:
|
|
return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex);
|
|
case 225:
|
|
return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 0:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 1:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 2:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 3:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 4:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 5:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 6:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 7:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 8:
|
|
return precpred(_ctx, 2);
|
|
case 9:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 10:
|
|
return precpred(_ctx, 5);
|
|
case 11:
|
|
return precpred(_ctx, 4);
|
|
case 12:
|
|
return precpred(_ctx, 3);
|
|
case 13:
|
|
return precpred(_ctx, 2);
|
|
case 14:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 15:
|
|
return precpred(_ctx, 3);
|
|
case 16:
|
|
return precpred(_ctx, 2);
|
|
case 17:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 18:
|
|
return precpred(_ctx, 2);
|
|
case 19:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 20:
|
|
return precpred(_ctx, 3);
|
|
case 21:
|
|
return precpred(_ctx, 2);
|
|
case 22:
|
|
return precpred(_ctx, 1);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static final String _serializedATNSegment0 =
|
|
"\u0004\u0001k\u0b1b\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
|
|
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
|
|
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
|
|
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
|
|
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
|
|
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
|
|
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
|
|
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
|
|
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
|
|
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
|
|
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
|
|
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
|
|
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
|
|
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
|
|
"2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+
|
|
"7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+
|
|
"<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+
|
|
"A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+
|
|
"F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+
|
|
"K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+
|
|
"P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+
|
|
"U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+
|
|
"Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002"+
|
|
"_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002"+
|
|
"d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002"+
|
|
"i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002"+
|
|
"n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002"+
|
|
"s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002"+
|
|
"x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002"+
|
|
"}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007\u0080"+
|
|
"\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007\u0083"+
|
|
"\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007\u0086"+
|
|
"\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007\u0089"+
|
|
"\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007\u008c"+
|
|
"\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007\u008f"+
|
|
"\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007\u0092"+
|
|
"\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007\u0095"+
|
|
"\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007\u0098"+
|
|
"\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007\u009b"+
|
|
"\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007\u009e"+
|
|
"\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007\u00a1"+
|
|
"\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007\u00a4"+
|
|
"\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007\u00a7"+
|
|
"\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007\u00aa"+
|
|
"\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007\u00ad"+
|
|
"\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007\u00b0"+
|
|
"\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007\u00b3"+
|
|
"\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007\u00b6"+
|
|
"\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007\u00b9"+
|
|
"\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007\u00bc"+
|
|
"\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007\u00bf"+
|
|
"\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007\u00c2"+
|
|
"\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007\u00c5"+
|
|
"\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007\u00c8"+
|
|
"\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007\u00cb"+
|
|
"\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007\u00ce"+
|
|
"\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007\u00d1"+
|
|
"\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007\u00d4"+
|
|
"\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007\u00d7"+
|
|
"\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0002\u00da\u0007\u00da"+
|
|
"\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc\u0002\u00dd\u0007\u00dd"+
|
|
"\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df\u0002\u00e0\u0007\u00e0"+
|
|
"\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2\u0002\u00e3\u0007\u00e3"+
|
|
"\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5\u0002\u00e6\u0007\u00e6"+
|
|
"\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8\u0002\u00e9\u0007\u00e9"+
|
|
"\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb\u0001\u0000\u0001\u0000"+
|
|
"\u0001\u0001\u0005\u0001\u01dc\b\u0001\n\u0001\f\u0001\u01df\t\u0001\u0001"+
|
|
"\u0001\u0001\u0001\u0005\u0001\u01e3\b\u0001\n\u0001\f\u0001\u01e6\t\u0001"+
|
|
"\u0001\u0001\u0003\u0001\u01e9\b\u0001\u0001\u0002\u0001\u0002\u0003\u0002"+
|
|
"\u01ed\b\u0002\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001\u0005"+
|
|
"\u0001\u0005\u0001\u0005\u0003\u0005\u01f6\b\u0005\u0001\u0006\u0001\u0006"+
|
|
"\u0003\u0006\u01fa\b\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u01fe\b"+
|
|
"\u0006\n\u0006\f\u0006\u0201\t\u0006\u0001\u0007\u0005\u0007\u0204\b\u0007"+
|
|
"\n\u0007\f\u0007\u0207\t\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u020b"+
|
|
"\b\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u0210\b\u0007"+
|
|
"\n\u0007\f\u0007\u0213\t\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0217"+
|
|
"\b\u0007\u0003\u0007\u0219\b\u0007\u0001\b\u0001\b\u0005\b\u021d\b\b\n"+
|
|
"\b\f\b\u0220\t\b\u0001\b\u0001\b\u0003\b\u0224\b\b\u0001\t\u0005\t\u0227"+
|
|
"\b\t\n\t\f\t\u022a\t\t\u0001\t\u0001\t\u0003\t\u022e\b\t\u0001\n\u0001"+
|
|
"\n\u0001\u000b\u0001\u000b\u0001\f\u0001\f\u0001\r\u0005\r\u0237\b\r\n"+
|
|
"\r\f\r\u023a\t\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
|
|
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0003"+
|
|
"\u000e\u0247\b\u000e\u0001\u000f\u0005\u000f\u024a\b\u000f\n\u000f\f\u000f"+
|
|
"\u024d\t\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u0252\b"+
|
|
"\u000f\n\u000f\f\u000f\u0255\t\u000f\u0001\u000f\u0001\u000f\u0005\u000f"+
|
|
"\u0259\b\u000f\n\u000f\f\u000f\u025c\t\u000f\u0001\u0010\u0005\u0010\u025f"+
|
|
"\b\u0010\n\u0010\f\u0010\u0262\t\u0010\u0001\u0010\u0001\u0010\u0003\u0010"+
|
|
"\u0266\b\u0010\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012"+
|
|
"\u0001\u0012\u0001\u0012\u0005\u0012\u026f\b\u0012\n\u0012\f\u0012\u0272"+
|
|
"\t\u0012\u0003\u0012\u0274\b\u0012\u0001\u0013\u0001\u0013\u0001\u0013"+
|
|
"\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015"+
|
|
"\u0001\u0015\u0005\u0015\u0280\b\u0015\n\u0015\f\u0015\u0283\t\u0015\u0001"+
|
|
"\u0016\u0001\u0016\u0003\u0016\u0287\b\u0016\u0001\u0017\u0005\u0017\u028a"+
|
|
"\b\u0017\n\u0017\f\u0017\u028d\t\u0017\u0001\u0017\u0001\u0017\u0003\u0017"+
|
|
"\u0291\b\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018"+
|
|
"\u0297\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+
|
|
"\u0001\u0019\u0005\u0019\u029f\b\u0019\n\u0019\f\u0019\u02a2\t\u0019\u0001"+
|
|
"\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u02a9"+
|
|
"\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
|
|
"\u001b\u0005\u001b\u02b1\b\u001b\n\u001b\f\u001b\u02b4\t\u001b\u0001\u001c"+
|
|
"\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u02bb\b\u001c"+
|
|
"\u0001\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e"+
|
|
"\u0001\u001e\u0001\u001e\u0005\u001e\u02c5\b\u001e\n\u001e\f\u001e\u02c8"+
|
|
"\t\u001e\u0001\u001f\u0003\u001f\u02cb\b\u001f\u0001\u001f\u0005\u001f"+
|
|
"\u02ce\b\u001f\n\u001f\f\u001f\u02d1\t\u001f\u0001\u001f\u0005\u001f\u02d4"+
|
|
"\b\u001f\n\u001f\f\u001f\u02d7\t\u001f\u0001\u001f\u0001\u001f\u0001 "+
|
|
"\u0005 \u02dc\b \n \f \u02df\t \u0001 \u0001 \u0001 \u0001 \u0001!\u0001"+
|
|
"!\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u02eb\b\"\u0001#\u0001#\u0001"+
|
|
"#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001"+
|
|
"%\u0001%\u0001%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+
|
|
"&\u0001&\u0001\'\u0001\'\u0001\'\u0003\'\u0308\b\'\u0001(\u0001(\u0003"+
|
|
"(\u030c\b(\u0001)\u0005)\u030f\b)\n)\f)\u0312\t)\u0001)\u0001)\u0001)"+
|
|
"\u0003)\u0317\b)\u0001)\u0003)\u031a\b)\u0001)\u0003)\u031d\b)\u0001)"+
|
|
"\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0003"+
|
|
"*\u0329\b*\u0001+\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0005,\u0332"+
|
|
"\b,\n,\f,\u0335\t,\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001/\u0001"+
|
|
"/\u0001/\u0005/\u0340\b/\n/\f/\u0343\t/\u00010\u00010\u00050\u0347\b0"+
|
|
"\n0\f0\u034a\t0\u00010\u00010\u00011\u00011\u00011\u00011\u00031\u0352"+
|
|
"\b1\u00012\u00012\u00012\u00012\u00012\u00032\u0359\b2\u00013\u00053\u035c"+
|
|
"\b3\n3\f3\u035f\t3\u00013\u00013\u00013\u00013\u00014\u00014\u00014\u0001"+
|
|
"4\u00014\u00014\u00014\u00014\u00034\u036d\b4\u00015\u00015\u00015\u0005"+
|
|
"5\u0372\b5\n5\f5\u0375\t5\u00016\u00016\u00016\u00036\u037a\b6\u00017"+
|
|
"\u00017\u00037\u037e\b7\u00018\u00018\u00038\u0382\b8\u00019\u00019\u0003"+
|
|
"9\u0386\b9\u0001:\u0001:\u0003:\u038a\b:\u0001;\u0001;\u0001;\u0003;\u038f"+
|
|
"\b;\u0001<\u0001<\u0003<\u0393\b<\u0001<\u0001<\u0005<\u0397\b<\n<\f<"+
|
|
"\u039a\t<\u0001=\u0001=\u0003=\u039e\b=\u0001=\u0001=\u0001=\u0005=\u03a3"+
|
|
"\b=\n=\f=\u03a6\t=\u0001=\u0001=\u0003=\u03aa\b=\u0003=\u03ac\b=\u0001"+
|
|
">\u0001>\u0005>\u03b0\b>\n>\f>\u03b3\t>\u0001>\u0001>\u0003>\u03b7\b>"+
|
|
"\u0001?\u0001?\u0003?\u03bb\b?\u0001@\u0001@\u0001A\u0001A\u0001B\u0001"+
|
|
"B\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+
|
|
"D\u0001D\u0003D\u03ce\bD\u0001E\u0005E\u03d1\bE\nE\fE\u03d4\tE\u0001E"+
|
|
"\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
|
|
"F\u0001F\u0001F\u0003F\u03e3\bF\u0001G\u0001G\u0001G\u0003G\u03e8\bG\u0001"+
|
|
"G\u0001G\u0005G\u03ec\bG\nG\fG\u03ef\tG\u0001G\u0001G\u0001G\u0003G\u03f4"+
|
|
"\bG\u0003G\u03f6\bG\u0001H\u0001H\u0003H\u03fa\bH\u0001I\u0001I\u0001"+
|
|
"I\u0003I\u03ff\bI\u0001I\u0001I\u0003I\u0403\bI\u0001J\u0001J\u0001J\u0001"+
|
|
"J\u0001J\u0001J\u0003J\u040b\bJ\u0001K\u0001K\u0001K\u0005K\u0410\bK\n"+
|
|
"K\fK\u0413\tK\u0001K\u0001K\u0001K\u0005K\u0418\bK\nK\fK\u041b\tK\u0003"+
|
|
"K\u041d\bK\u0001L\u0005L\u0420\bL\nL\fL\u0423\tL\u0001L\u0001L\u0001L"+
|
|
"\u0001M\u0001M\u0003M\u042a\bM\u0001N\u0005N\u042d\bN\nN\fN\u0430\tN\u0001"+
|
|
"N\u0001N\u0005N\u0434\bN\nN\fN\u0437\tN\u0001N\u0001N\u0001N\u0001N\u0003"+
|
|
"N\u043d\bN\u0001O\u0005O\u0440\bO\nO\fO\u0443\tO\u0001O\u0001O\u0001O"+
|
|
"\u0003O\u0448\bO\u0001O\u0001O\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001"+
|
|
"Q\u0005Q\u0452\bQ\nQ\fQ\u0455\tQ\u0001R\u0001R\u0003R\u0459\bR\u0001S"+
|
|
"\u0001S\u0003S\u045d\bS\u0001T\u0001T\u0001U\u0001U\u0001U\u0001V\u0005"+
|
|
"V\u0465\bV\nV\fV\u0468\tV\u0001V\u0001V\u0003V\u046c\bV\u0001V\u0001V"+
|
|
"\u0001W\u0001W\u0001W\u0001W\u0003W\u0474\bW\u0001X\u0003X\u0477\bX\u0001"+
|
|
"X\u0001X\u0001X\u0003X\u047c\bX\u0001X\u0001X\u0001Y\u0001Y\u0001Z\u0001"+
|
|
"Z\u0003Z\u0484\bZ\u0001Z\u0003Z\u0487\bZ\u0001Z\u0001Z\u0001[\u0003[\u048c"+
|
|
"\b[\u0001[\u0001[\u0001[\u0003[\u0491\b[\u0001[\u0001[\u0001[\u0003[\u0496"+
|
|
"\b[\u0001[\u0001[\u0001[\u0003[\u049b\b[\u0001[\u0001[\u0001[\u0001[\u0001"+
|
|
"[\u0003[\u04a2\b[\u0001[\u0001[\u0001[\u0003[\u04a7\b[\u0001[\u0001[\u0001"+
|
|
"[\u0001[\u0001[\u0001[\u0003[\u04af\b[\u0001[\u0001[\u0001[\u0003[\u04b4"+
|
|
"\b[\u0001[\u0001[\u0001[\u0003[\u04b9\b[\u0001\\\u0005\\\u04bc\b\\\n\\"+
|
|
"\f\\\u04bf\t\\\u0001\\\u0001\\\u0001\\\u0003\\\u04c4\b\\\u0001\\\u0001"+
|
|
"\\\u0001]\u0001]\u0003]\u04ca\b]\u0001]\u0003]\u04cd\b]\u0001]\u0003]"+
|
|
"\u04d0\b]\u0001]\u0001]\u0001^\u0001^\u0001^\u0005^\u04d7\b^\n^\f^\u04da"+
|
|
"\t^\u0001_\u0005_\u04dd\b_\n_\f_\u04e0\t_\u0001_\u0001_\u0001_\u0003_"+
|
|
"\u04e5\b_\u0001_\u0003_\u04e8\b_\u0001_\u0003_\u04eb\b_\u0001`\u0001`"+
|
|
"\u0001a\u0001a\u0005a\u04f1\ba\na\fa\u04f4\ta\u0001b\u0001b\u0003b\u04f8"+
|
|
"\bb\u0001c\u0005c\u04fb\bc\nc\fc\u04fe\tc\u0001c\u0001c\u0001c\u0003c"+
|
|
"\u0503\bc\u0001c\u0003c\u0506\bc\u0001c\u0001c\u0001d\u0001d\u0001d\u0001"+
|
|
"d\u0001d\u0001d\u0001d\u0003d\u0511\bd\u0001e\u0001e\u0001e\u0001f\u0001"+
|
|
"f\u0005f\u0518\bf\nf\ff\u051b\tf\u0001f\u0001f\u0001g\u0001g\u0001g\u0001"+
|
|
"g\u0001g\u0003g\u0524\bg\u0001h\u0005h\u0527\bh\nh\fh\u052a\th\u0001h"+
|
|
"\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0003i\u0534\bi\u0001"+
|
|
"j\u0005j\u0537\bj\nj\fj\u053a\tj\u0001j\u0001j\u0001j\u0001k\u0001k\u0001"+
|
|
"k\u0001k\u0001k\u0001k\u0003k\u0545\bk\u0001l\u0005l\u0548\bl\nl\fl\u054b"+
|
|
"\tl\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0005m\u0554\bm\n"+
|
|
"m\fm\u0557\tm\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0001n\u0003n"+
|
|
"\u0560\bn\u0001o\u0005o\u0563\bo\no\fo\u0566\to\u0001o\u0001o\u0001o\u0001"+
|
|
"o\u0001o\u0003o\u056d\bo\u0001o\u0003o\u0570\bo\u0001o\u0001o\u0001p\u0001"+
|
|
"p\u0001p\u0003p\u0577\bp\u0001q\u0001q\u0001q\u0001r\u0001r\u0001r\u0003"+
|
|
"r\u057f\br\u0001s\u0001s\u0001s\u0001s\u0003s\u0585\bs\u0001s\u0001s\u0001"+
|
|
"t\u0001t\u0001t\u0005t\u058c\bt\nt\ft\u058f\tt\u0001u\u0001u\u0001u\u0001"+
|
|
"u\u0001v\u0001v\u0001v\u0003v\u0598\bv\u0001w\u0001w\u0003w\u059c\bw\u0001"+
|
|
"w\u0003w\u059f\bw\u0001w\u0001w\u0001x\u0001x\u0001x\u0005x\u05a6\bx\n"+
|
|
"x\fx\u05a9\tx\u0001y\u0001y\u0001y\u0001z\u0001z\u0001z\u0001z\u0001z"+
|
|
"\u0001z\u0001{\u0001{\u0003{\u05b6\b{\u0001{\u0003{\u05b9\b{\u0001{\u0001"+
|
|
"{\u0001|\u0001|\u0001|\u0005|\u05c0\b|\n|\f|\u05c3\t|\u0001}\u0001}\u0003"+
|
|
"}\u05c7\b}\u0001}\u0001}\u0001~\u0004~\u05cc\b~\u000b~\f~\u05cd\u0001"+
|
|
"\u007f\u0001\u007f\u0001\u007f\u0003\u007f\u05d3\b\u007f\u0001\u0080\u0001"+
|
|
"\u0080\u0001\u0080\u0001\u0081\u0005\u0081\u05d9\b\u0081\n\u0081\f\u0081"+
|
|
"\u05dc\t\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0082\u0001\u0082"+
|
|
"\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u05e7\b\u0082"+
|
|
"\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003\u0083"+
|
|
"\u05ee\b\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084"+
|
|
"\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084"+
|
|
"\u0001\u0084\u0003\u0084\u05fc\b\u0084\u0001\u0085\u0001\u0085\u0001\u0086"+
|
|
"\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087\u0001\u0087"+
|
|
"\u0001\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0089\u0001\u0089"+
|
|
"\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089"+
|
|
"\u0612\b\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+
|
|
"\u0001\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008b"+
|
|
"\u0001\u008b\u0001\u008b\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c"+
|
|
"\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008d"+
|
|
"\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d\u0001\u008d"+
|
|
"\u0001\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0634\b\u008d\u0001\u008e"+
|
|
"\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001\u008f"+
|
|
"\u0001\u008f\u0005\u008f\u063e\b\u008f\n\u008f\f\u008f\u0641\t\u008f\u0001"+
|
|
"\u008f\u0005\u008f\u0644\b\u008f\n\u008f\f\u008f\u0647\t\u008f\u0001\u008f"+
|
|
"\u0001\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001\u0091\u0001\u0091"+
|
|
"\u0005\u0091\u0650\b\u0091\n\u0091\f\u0091\u0653\t\u0091\u0001\u0092\u0001"+
|
|
"\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+
|
|
"\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u065f\b\u0092\u0001\u0093\u0001"+
|
|
"\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001\u0094\u0001"+
|
|
"\u0094\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+
|
|
"\u0095\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001\u0096\u0001"+
|
|
"\u0096\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0003\u0097\u0679"+
|
|
"\b\u0097\u0001\u0098\u0001\u0098\u0003\u0098\u067d\b\u0098\u0001\u0099"+
|
|
"\u0001\u0099\u0001\u0099\u0003\u0099\u0682\b\u0099\u0001\u0099\u0001\u0099"+
|
|
"\u0003\u0099\u0686\b\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u068a\b"+
|
|
"\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u009a\u0001\u009a\u0001"+
|
|
"\u009a\u0003\u009a\u0692\b\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u0696"+
|
|
"\b\u009a\u0001\u009a\u0001\u009a\u0003\u009a\u069a\b\u009a\u0001\u009a"+
|
|
"\u0001\u009a\u0001\u009a\u0001\u009b\u0001\u009b\u0003\u009b\u06a1\b\u009b"+
|
|
"\u0001\u009c\u0001\u009c\u0001\u009d\u0001\u009d\u0001\u009d\u0005\u009d"+
|
|
"\u06a8\b\u009d\n\u009d\f\u009d\u06ab\t\u009d\u0001\u009e\u0001\u009e\u0001"+
|
|
"\u009e\u0005\u009e\u06b0\b\u009e\n\u009e\f\u009e\u06b3\t\u009e\u0001\u009e"+
|
|
"\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e\u0001\u009e"+
|
|
"\u0001\u009f\u0001\u009f\u0001\u009f\u0005\u009f\u06bf\b\u009f\n\u009f"+
|
|
"\f\u009f\u06c2\t\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f"+
|
|
"\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u00a0\u0001\u00a0\u0003\u00a0"+
|
|
"\u06cd\b\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1\u0001\u00a1\u0003\u00a1"+
|
|
"\u06d3\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a2\u0001\u00a2\u0003\u00a2"+
|
|
"\u06d9\b\u00a2\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3"+
|
|
"\u0001\u00a3\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a4"+
|
|
"\u0001\u00a4\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5\u0001\u00a5"+
|
|
"\u0001\u00a5\u0001\u00a5\u0003\u00a5\u06ee\b\u00a5\u0001\u00a5\u0001\u00a5"+
|
|
"\u0001\u00a5\u0003\u00a5\u06f3\b\u00a5\u0001\u00a6\u0001\u00a6\u0005\u00a6"+
|
|
"\u06f7\b\u00a6\n\u00a6\f\u00a6\u06fa\t\u00a6\u0001\u00a7\u0001\u00a7\u0001"+
|
|
"\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a7\u0001\u00a8\u0005\u00a8\u0703"+
|
|
"\b\u00a8\n\u00a8\f\u00a8\u0706\t\u00a8\u0001\u00a8\u0001\u00a8\u0001\u00a8"+
|
|
"\u0001\u00a9\u0001\u00a9\u0001\u00a9\u0005\u00a9\u070e\b\u00a9\n\u00a9"+
|
|
"\f\u00a9\u0711\t\u00a9\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab"+
|
|
"\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0003\u00ab\u071a\b\u00ab\u0001\u00ab"+
|
|
"\u0003\u00ab\u071d\b\u00ab\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac"+
|
|
"\u0722\b\u00ac\u0001\u00ac\u0001\u00ac\u0001\u00ad\u0001\u00ad\u0001\u00ad"+
|
|
"\u0005\u00ad\u0729\b\u00ad\n\u00ad\f\u00ad\u072c\t\u00ad\u0001\u00ae\u0005"+
|
|
"\u00ae\u072f\b\u00ae\n\u00ae\f\u00ae\u0732\t\u00ae\u0001\u00ae\u0001\u00ae"+
|
|
"\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00af\u0001\u00af\u0003\u00af"+
|
|
"\u073b\b\u00af\u0001\u00af\u0005\u00af\u073e\b\u00af\n\u00af\f\u00af\u0741"+
|
|
"\t\u00af\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0005\u00b0\u0747"+
|
|
"\b\u00b0\n\u00b0\f\u00b0\u074a\t\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0"+
|
|
"\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0"+
|
|
"\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0"+
|
|
"\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0"+
|
|
"\u0760\b\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0001\u00b2\u0001\u00b2"+
|
|
"\u0001\u00b2\u0005\u00b2\u0768\b\u00b2\n\u00b2\f\u00b2\u076b\t\u00b2\u0001"+
|
|
"\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+
|
|
"\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+
|
|
"\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0001"+
|
|
"\u00b2\u0003\u00b2\u0780\b\u00b2\u0001\u00b3\u0001\u00b3\u0001\u00b3\u0001"+
|
|
"\u00b3\u0001\u00b3\u0003\u00b3\u0787\b\u00b3\u0001\u00b4\u0001\u00b4\u0001"+
|
|
"\u00b5\u0001\u00b5\u0001\u00b5\u0001\u00b5\u0003\u00b5\u078f\b\u00b5\u0001"+
|
|
"\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0005\u00b6\u0795\b\u00b6\n"+
|
|
"\u00b6\f\u00b6\u0798\t\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001"+
|
|
"\u00b6\u0001\u00b6\u0001\u00b6\u0005\u00b6\u07a0\b\u00b6\n\u00b6\f\u00b6"+
|
|
"\u07a3\t\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+
|
|
"\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+
|
|
"\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0001\u00b6"+
|
|
"\u0001\u00b6\u0001\u00b6\u0001\u00b6\u0003\u00b6\u07b9\b\u00b6\u0001\u00b7"+
|
|
"\u0001\u00b7\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0005\u00b8"+
|
|
"\u07c1\b\u00b8\n\u00b8\f\u00b8\u07c4\t\u00b8\u0001\u00b8\u0001\u00b8\u0001"+
|
|
"\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0005\u00b8\u07cc\b\u00b8\n"+
|
|
"\u00b8\f\u00b8\u07cf\t\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+
|
|
"\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+
|
|
"\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0001"+
|
|
"\u00b8\u0001\u00b8\u0001\u00b8\u0001\u00b8\u0003\u00b8\u07e4\b\u00b8\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u07e8\b\u00b9\u0001\u00b9\u0005\u00b9\u07eb"+
|
|
"\b\u00b9\n\u00b9\f\u00b9\u07ee\t\u00b9\u0001\u00b9\u0001\u00b9\u0001\u00b9"+
|
|
"\u0005\u00b9\u07f3\b\u00b9\n\u00b9\f\u00b9\u07f6\t\u00b9\u0001\u00b9\u0005"+
|
|
"\u00b9\u07f9\b\u00b9\n\u00b9\f\u00b9\u07fc\t\u00b9\u0001\u00b9\u0003\u00b9"+
|
|
"\u07ff\b\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u0803\b\u00b9\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u0807\b\u00b9\u0001\u00b9\u0001\u00b9\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u080d\b\u00b9\u0001\u00b9\u0005\u00b9\u0810"+
|
|
"\b\u00b9\n\u00b9\f\u00b9\u0813\t\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9"+
|
|
"\u0817\b\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u081b\b\u00b9\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u081f\b\u00b9\u0001\u00b9\u0001\u00b9\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u0825\b\u00b9\u0001\u00b9\u0005\u00b9\u0828"+
|
|
"\b\u00b9\n\u00b9\f\u00b9\u082b\t\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9"+
|
|
"\u082f\b\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u0833\b\u00b9\u0001"+
|
|
"\u00b9\u0001\u00b9\u0003\u00b9\u0837\b\u00b9\u0003\u00b9\u0839\b\u00b9"+
|
|
"\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u083e\b\u00ba\u0001\u00ba"+
|
|
"\u0005\u00ba\u0841\b\u00ba\n\u00ba\f\u00ba\u0844\t\u00ba\u0001\u00ba\u0001"+
|
|
"\u00ba\u0003\u00ba\u0848\b\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u084c"+
|
|
"\b\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u0850\b\u00ba\u0001\u00bb"+
|
|
"\u0001\u00bb\u0003\u00bb\u0854\b\u00bb\u0001\u00bb\u0005\u00bb\u0857\b"+
|
|
"\u00bb\n\u00bb\f\u00bb\u085a\t\u00bb\u0001\u00bb\u0001\u00bb\u0001\u00bb"+
|
|
"\u0005\u00bb\u085f\b\u00bb\n\u00bb\f\u00bb\u0862\t\u00bb\u0001\u00bb\u0005"+
|
|
"\u00bb\u0865\b\u00bb\n\u00bb\f\u00bb\u0868\t\u00bb\u0001\u00bb\u0003\u00bb"+
|
|
"\u086b\b\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb\u086f\b\u00bb\u0001"+
|
|
"\u00bb\u0001\u00bb\u0003\u00bb\u0873\b\u00bb\u0001\u00bb\u0001\u00bb\u0001"+
|
|
"\u00bb\u0001\u00bb\u0003\u00bb\u0879\b\u00bb\u0001\u00bb\u0005\u00bb\u087c"+
|
|
"\b\u00bb\n\u00bb\f\u00bb\u087f\t\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb"+
|
|
"\u0883\b\u00bb\u0001\u00bb\u0001\u00bb\u0003\u00bb\u0887\b\u00bb\u0001"+
|
|
"\u00bb\u0001\u00bb\u0003\u00bb\u088b\b\u00bb\u0003\u00bb\u088d\b\u00bb"+
|
|
"\u0001\u00bc\u0001\u00bc\u0001\u00bc\u0003\u00bc\u0892\b\u00bc\u0001\u00bd"+
|
|
"\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+
|
|
"\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+
|
|
"\u0003\u00bd\u08a1\b\u00bd\u0001\u00be\u0001\u00be\u0001\u00be\u0001\u00bf"+
|
|
"\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00bf"+
|
|
"\u0001\u00bf\u0001\u00bf\u0003\u00bf\u08af\b\u00bf\u0001\u00c0\u0001\u00c0"+
|
|
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0001\u00c0"+
|
|
"\u0001\u00c0\u0001\u00c0\u0003\u00c0\u08bb\b\u00c0\u0001\u00c0\u0001\u00c0"+
|
|
"\u0001\u00c0\u0001\u00c0\u0001\u00c0\u0005\u00c0\u08c2\b\u00c0\n\u00c0"+
|
|
"\f\u00c0\u08c5\t\u00c0\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1"+
|
|
"\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c1\u0005\u00c1"+
|
|
"\u08d0\b\u00c1\n\u00c1\f\u00c1\u08d3\t\u00c1\u0001\u00c2\u0001\u00c2\u0001"+
|
|
"\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
|
|
"\u00c2\u0001\u00c2\u0003\u00c2\u08df\b\u00c2\u0001\u00c2\u0001\u00c2\u0001"+
|
|
"\u00c2\u0001\u00c2\u0001\u00c2\u0005\u00c2\u08e6\b\u00c2\n\u00c2\f\u00c2"+
|
|
"\u08e9\t\u00c2\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u08ee\b"+
|
|
"\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003"+
|
|
"\u00c3\u08f5\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u08fa"+
|
|
"\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003"+
|
|
"\u00c3\u0901\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u0906"+
|
|
"\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003"+
|
|
"\u00c3\u090d\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u0912"+
|
|
"\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003"+
|
|
"\u00c3\u0919\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u091e"+
|
|
"\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001"+
|
|
"\u00c3\u0003\u00c3\u0926\b\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0003"+
|
|
"\u00c3\u092b\b\u00c3\u0001\u00c3\u0001\u00c3\u0003\u00c3\u092f\b\u00c3"+
|
|
"\u0001\u00c4\u0001\u00c4\u0003\u00c4\u0933\b\u00c4\u0001\u00c4\u0001\u00c4"+
|
|
"\u0001\u00c4\u0003\u00c4\u0938\b\u00c4\u0001\u00c4\u0001\u00c4\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0003\u00c5\u093f\b\u00c5\u0001\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0946\b\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0003\u00c5\u094b\b\u00c5\u0001\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0952\b\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0957\b\u00c5\u0001\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u095e\b\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0963\b\u00c5\u0001\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u096b\b\u00c5"+
|
|
"\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0003\u00c5\u0970\b\u00c5\u0001\u00c5"+
|
|
"\u0001\u00c5\u0003\u00c5\u0974\b\u00c5\u0001\u00c6\u0001\u00c6\u0001\u00c6"+
|
|
"\u0005\u00c6\u0979\b\u00c6\n\u00c6\f\u00c6\u097c\t\u00c6\u0001\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0003\u00c7\u0981\b\u00c7\u0001\u00c7\u0001\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0001\u00c7\u0003\u00c7\u0988\b\u00c7\u0001\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0003\u00c7\u098f\b\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0003\u00c7\u0996"+
|
|
"\b\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001"+
|
|
"\u00c7\u0003\u00c7\u099e\b\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0003\u00c7\u09a5\b\u00c7\u0001\u00c7\u0001\u00c7\u0001"+
|
|
"\u00c7\u0001\u00c7\u0001\u00c7\u0001\u00c7\u0003\u00c7\u09ad\b\u00c7\u0001"+
|
|
"\u00c8\u0001\u00c8\u0003\u00c8\u09b1\b\u00c8\u0001\u00c8\u0001\u00c8\u0001"+
|
|
"\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u09b8\b\u00c9\u0001\u00c9\u0001"+
|
|
"\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u09bf\b\u00c9\u0001"+
|
|
"\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u09c6"+
|
|
"\b\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001"+
|
|
"\u00c9\u0003\u00c9\u09ce\b\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0001"+
|
|
"\u00c9\u0001\u00c9\u0003\u00c9\u09d5\b\u00c9\u0001\u00c9\u0001\u00c9\u0001"+
|
|
"\u00c9\u0001\u00c9\u0001\u00c9\u0001\u00c9\u0003\u00c9\u09dd\b\u00c9\u0001"+
|
|
"\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0003\u00ca\u09e3\b\u00ca\u0001"+
|
|
"\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0003\u00ca\u09e9\b\u00ca\u0001"+
|
|
"\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0001"+
|
|
"\u00ca\u0001\u00ca\u0001\u00ca\u0001\u00ca\u0003\u00ca\u09f5\b\u00ca\u0001"+
|
|
"\u00cb\u0001\u00cb\u0005\u00cb\u09f9\b\u00cb\n\u00cb\f\u00cb\u09fc\t\u00cb"+
|
|
"\u0001\u00cc\u0005\u00cc\u09ff\b\u00cc\n\u00cc\f\u00cc\u0a02\t\u00cc\u0001"+
|
|
"\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cd\u0001\u00cd\u0001"+
|
|
"\u00ce\u0001\u00ce\u0003\u00ce\u0a0c\b\u00ce\u0001\u00cf\u0001\u00cf\u0001"+
|
|
"\u00cf\u0001\u00cf\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0003\u00d0\u0a15"+
|
|
"\b\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0003"+
|
|
"\u00d0\u0a1c\b\u00d0\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0005\u00d1\u0a21"+
|
|
"\b\u00d1\n\u00d1\f\u00d1\u0a24\t\u00d1\u0001\u00d2\u0001\u00d2\u0003\u00d2"+
|
|
"\u0a28\b\u00d2\u0001\u00d3\u0001\u00d3\u0003\u00d3\u0a2c\b\u00d3\u0001"+
|
|
"\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d5\u0001\u00d5\u0001"+
|
|
"\u00d5\u0003\u00d5\u0a35\b\u00d5\u0001\u00d6\u0001\u00d6\u0001\u00d7\u0001"+
|
|
"\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0001\u00d7\u0003"+
|
|
"\u00d7\u0a40\b\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+
|
|
"\u00d8\u0001\u00d8\u0005\u00d8\u0a48\b\u00d8\n\u00d8\f\u00d8\u0a4b\t\u00d8"+
|
|
"\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9"+
|
|
"\u0005\u00d9\u0a53\b\u00d9\n\u00d9\f\u00d9\u0a56\t\u00d9\u0001\u00da\u0001"+
|
|
"\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0005\u00da\u0a5e"+
|
|
"\b\u00da\n\u00da\f\u00da\u0a61\t\u00da\u0001\u00db\u0001\u00db\u0001\u00db"+
|
|
"\u0001\u00db\u0001\u00db\u0001\u00db\u0005\u00db\u0a69\b\u00db\n\u00db"+
|
|
"\f\u00db\u0a6c\t\u00db\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc"+
|
|
"\u0001\u00dc\u0001\u00dc\u0005\u00dc\u0a74\b\u00dc\n\u00dc\f\u00dc\u0a77"+
|
|
"\t\u00dc\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0001"+
|
|
"\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0005\u00dd\u0a82\b\u00dd\n"+
|
|
"\u00dd\f\u00dd\u0a85\t\u00dd\u0001\u00de\u0001\u00de\u0001\u00de\u0001"+
|
|
"\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001"+
|
|
"\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001\u00de\u0001"+
|
|
"\u00de\u0001\u00de\u0001\u00de\u0005\u00de\u0a99\b\u00de\n\u00de\f\u00de"+
|
|
"\u0a9c\t\u00de\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df"+
|
|
"\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df"+
|
|
"\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0001\u00df\u0005\u00df"+
|
|
"\u0aae\b\u00df\n\u00df\f\u00df\u0ab1\t\u00df\u0001\u00e0\u0001\u00e0\u0001"+
|
|
"\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001"+
|
|
"\u00e0\u0005\u00e0\u0abc\b\u00e0\n\u00e0\f\u00e0\u0abf\t\u00e0\u0001\u00e1"+
|
|
"\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1"+
|
|
"\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0005\u00e1"+
|
|
"\u0acd\b\u00e1\n\u00e1\f\u00e1\u0ad0\t\u00e1\u0001\u00e2\u0001\u00e2\u0001"+
|
|
"\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u0ad9"+
|
|
"\b\u00e2\u0001\u00e3\u0001\u00e3\u0001\u00e3\u0001\u00e4\u0001\u00e4\u0001"+
|
|
"\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+
|
|
"\u00e5\u0003\u00e5\u0ae7\b\u00e5\u0001\u00e6\u0001\u00e6\u0003\u00e6\u0aeb"+
|
|
"\b\u00e6\u0001\u00e6\u0001\u00e6\u0005\u00e6\u0aef\b\u00e6\n\u00e6\f\u00e6"+
|
|
"\u0af2\t\u00e6\u0001\u00e7\u0001\u00e7\u0001\u00e7\u0001\u00e8\u0001\u00e8"+
|
|
"\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00eb"+
|
|
"\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb"+
|
|
"\u0001\u00eb\u0005\u00eb\u0b06\b\u00eb\n\u00eb\f\u00eb\u0b09\t\u00eb\u0001"+
|
|
"\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0001\u00eb\u0005"+
|
|
"\u00eb\u0b11\b\u00eb\n\u00eb\f\u00eb\u0b14\t\u00eb\u0001\u00eb\u0001\u00eb"+
|
|
"\u0001\u00eb\u0003\u00eb\u0b19\b\u00eb\u0001\u00eb\u0000\r26<\u01b0\u01b2"+
|
|
"\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u00ec\u0000\u0002\u0004"+
|
|
"\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \""+
|
|
"$&(*,.02468:<>@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\u010c\u010e\u0110\u0112\u0114\u0116"+
|
|
"\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e"+
|
|
"\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146"+
|
|
"\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e"+
|
|
"\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176"+
|
|
"\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e"+
|
|
"\u0190\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6"+
|
|
"\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be"+
|
|
"\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6"+
|
|
"\u0000\u0004\u0001\u000038\u0005\u0000\u0005\u0005\b\b\u001b\u001b\u001d"+
|
|
"\u001d%%\u0002\u0000\u000e\u000e\u0014\u0014\u0002\u0000BB[e\u0c0c\u0000"+
|
|
"\u01d8\u0001\u0000\u0000\u0000\u0002\u01e8\u0001\u0000\u0000\u0000\u0004"+
|
|
"\u01ec\u0001\u0000\u0000\u0000\u0006\u01ee\u0001\u0000\u0000\u0000\b\u01f0"+
|
|
"\u0001\u0000\u0000\u0000\n\u01f5\u0001\u0000\u0000\u0000\f\u01f9\u0001"+
|
|
"\u0000\u0000\u0000\u000e\u0218\u0001\u0000\u0000\u0000\u0010\u021a\u0001"+
|
|
"\u0000\u0000\u0000\u0012\u0228\u0001\u0000\u0000\u0000\u0014\u022f\u0001"+
|
|
"\u0000\u0000\u0000\u0016\u0231\u0001\u0000\u0000\u0000\u0018\u0233\u0001"+
|
|
"\u0000\u0000\u0000\u001a\u0238\u0001\u0000\u0000\u0000\u001c\u0246\u0001"+
|
|
"\u0000\u0000\u0000\u001e\u024b\u0001\u0000\u0000\u0000 \u0260\u0001\u0000"+
|
|
"\u0000\u0000\"\u0267\u0001\u0000\u0000\u0000$\u0273\u0001\u0000\u0000"+
|
|
"\u0000&\u0275\u0001\u0000\u0000\u0000(\u0278\u0001\u0000\u0000\u0000*"+
|
|
"\u027c\u0001\u0000\u0000\u0000,\u0286\u0001\u0000\u0000\u0000.\u028b\u0001"+
|
|
"\u0000\u0000\u00000\u0296\u0001\u0000\u0000\u00002\u0298\u0001\u0000\u0000"+
|
|
"\u00004\u02a8\u0001\u0000\u0000\u00006\u02aa\u0001\u0000\u0000\u00008"+
|
|
"\u02ba\u0001\u0000\u0000\u0000:\u02bc\u0001\u0000\u0000\u0000<\u02be\u0001"+
|
|
"\u0000\u0000\u0000>\u02ca\u0001\u0000\u0000\u0000@\u02dd\u0001\u0000\u0000"+
|
|
"\u0000B\u02e4\u0001\u0000\u0000\u0000D\u02ea\u0001\u0000\u0000\u0000F"+
|
|
"\u02ec\u0001\u0000\u0000\u0000H\u02f0\u0001\u0000\u0000\u0000J\u02f6\u0001"+
|
|
"\u0000\u0000\u0000L\u02fd\u0001\u0000\u0000\u0000N\u0307\u0001\u0000\u0000"+
|
|
"\u0000P\u030b\u0001\u0000\u0000\u0000R\u0310\u0001\u0000\u0000\u0000T"+
|
|
"\u0328\u0001\u0000\u0000\u0000V\u032a\u0001\u0000\u0000\u0000X\u032e\u0001"+
|
|
"\u0000\u0000\u0000Z\u0336\u0001\u0000\u0000\u0000\\\u0339\u0001\u0000"+
|
|
"\u0000\u0000^\u033c\u0001\u0000\u0000\u0000`\u0344\u0001\u0000\u0000\u0000"+
|
|
"b\u0351\u0001\u0000\u0000\u0000d\u0358\u0001\u0000\u0000\u0000f\u035d"+
|
|
"\u0001\u0000\u0000\u0000h\u036c\u0001\u0000\u0000\u0000j\u036e\u0001\u0000"+
|
|
"\u0000\u0000l\u0376\u0001\u0000\u0000\u0000n\u037b\u0001\u0000\u0000\u0000"+
|
|
"p\u0381\u0001\u0000\u0000\u0000r\u0385\u0001\u0000\u0000\u0000t\u0389"+
|
|
"\u0001\u0000\u0000\u0000v\u038e\u0001\u0000\u0000\u0000x\u0392\u0001\u0000"+
|
|
"\u0000\u0000z\u03ab\u0001\u0000\u0000\u0000|\u03ad\u0001\u0000\u0000\u0000"+
|
|
"~\u03b8\u0001\u0000\u0000\u0000\u0080\u03bc\u0001\u0000\u0000\u0000\u0082"+
|
|
"\u03be\u0001\u0000\u0000\u0000\u0084\u03c0\u0001\u0000\u0000\u0000\u0086"+
|
|
"\u03c2\u0001\u0000\u0000\u0000\u0088\u03cd\u0001\u0000\u0000\u0000\u008a"+
|
|
"\u03d2\u0001\u0000\u0000\u0000\u008c\u03e2\u0001\u0000\u0000\u0000\u008e"+
|
|
"\u03f5\u0001\u0000\u0000\u0000\u0090\u03f9\u0001\u0000\u0000\u0000\u0092"+
|
|
"\u03fb\u0001\u0000\u0000\u0000\u0094\u040a\u0001\u0000\u0000\u0000\u0096"+
|
|
"\u041c\u0001\u0000\u0000\u0000\u0098\u0421\u0001\u0000\u0000\u0000\u009a"+
|
|
"\u0429\u0001\u0000\u0000\u0000\u009c\u043c\u0001\u0000\u0000\u0000\u009e"+
|
|
"\u0441\u0001\u0000\u0000\u0000\u00a0\u044b\u0001\u0000\u0000\u0000\u00a2"+
|
|
"\u044e\u0001\u0000\u0000\u0000\u00a4\u0458\u0001\u0000\u0000\u0000\u00a6"+
|
|
"\u045c\u0001\u0000\u0000\u0000\u00a8\u045e\u0001\u0000\u0000\u0000\u00aa"+
|
|
"\u0460\u0001\u0000\u0000\u0000\u00ac\u0466\u0001\u0000\u0000\u0000\u00ae"+
|
|
"\u0473\u0001\u0000\u0000\u0000\u00b0\u0476\u0001\u0000\u0000\u0000\u00b2"+
|
|
"\u047f\u0001\u0000\u0000\u0000\u00b4\u0481\u0001\u0000\u0000\u0000\u00b6"+
|
|
"\u04b8\u0001\u0000\u0000\u0000\u00b8\u04bd\u0001\u0000\u0000\u0000\u00ba"+
|
|
"\u04c7\u0001\u0000\u0000\u0000\u00bc\u04d3\u0001\u0000\u0000\u0000\u00be"+
|
|
"\u04de\u0001\u0000\u0000\u0000\u00c0\u04ec\u0001\u0000\u0000\u0000\u00c2"+
|
|
"\u04ee\u0001\u0000\u0000\u0000\u00c4\u04f7\u0001\u0000\u0000\u0000\u00c6"+
|
|
"\u04fc\u0001\u0000\u0000\u0000\u00c8\u0510\u0001\u0000\u0000\u0000\u00ca"+
|
|
"\u0512\u0001\u0000\u0000\u0000\u00cc\u0515\u0001\u0000\u0000\u0000\u00ce"+
|
|
"\u0523\u0001\u0000\u0000\u0000\u00d0\u0528\u0001\u0000\u0000\u0000\u00d2"+
|
|
"\u0533\u0001\u0000\u0000\u0000\u00d4\u0538\u0001\u0000\u0000\u0000\u00d6"+
|
|
"\u0544\u0001\u0000\u0000\u0000\u00d8\u0549\u0001\u0000\u0000\u0000\u00da"+
|
|
"\u0551\u0001\u0000\u0000\u0000\u00dc\u055f\u0001\u0000\u0000\u0000\u00de"+
|
|
"\u0564\u0001\u0000\u0000\u0000\u00e0\u0576\u0001\u0000\u0000\u0000\u00e2"+
|
|
"\u0578\u0001\u0000\u0000\u0000\u00e4\u057e\u0001\u0000\u0000\u0000\u00e6"+
|
|
"\u0580\u0001\u0000\u0000\u0000\u00e8\u0588\u0001\u0000\u0000\u0000\u00ea"+
|
|
"\u0590\u0001\u0000\u0000\u0000\u00ec\u0597\u0001\u0000\u0000\u0000\u00ee"+
|
|
"\u0599\u0001\u0000\u0000\u0000\u00f0\u05a2\u0001\u0000\u0000\u0000\u00f2"+
|
|
"\u05aa\u0001\u0000\u0000\u0000\u00f4\u05ad\u0001\u0000\u0000\u0000\u00f6"+
|
|
"\u05b3\u0001\u0000\u0000\u0000\u00f8\u05bc\u0001\u0000\u0000\u0000\u00fa"+
|
|
"\u05c4\u0001\u0000\u0000\u0000\u00fc\u05cb\u0001\u0000\u0000\u0000\u00fe"+
|
|
"\u05d2\u0001\u0000\u0000\u0000\u0100\u05d4\u0001\u0000\u0000\u0000\u0102"+
|
|
"\u05da\u0001\u0000\u0000\u0000\u0104\u05e6\u0001\u0000\u0000\u0000\u0106"+
|
|
"\u05ed\u0001\u0000\u0000\u0000\u0108\u05fb\u0001\u0000\u0000\u0000\u010a"+
|
|
"\u05fd\u0001\u0000\u0000\u0000\u010c\u05ff\u0001\u0000\u0000\u0000\u010e"+
|
|
"\u0603\u0001\u0000\u0000\u0000\u0110\u0607\u0001\u0000\u0000\u0000\u0112"+
|
|
"\u0611\u0001\u0000\u0000\u0000\u0114\u0613\u0001\u0000\u0000\u0000\u0116"+
|
|
"\u0619\u0001\u0000\u0000\u0000\u0118\u0621\u0001\u0000\u0000\u0000\u011a"+
|
|
"\u0633\u0001\u0000\u0000\u0000\u011c\u0635\u0001\u0000\u0000\u0000\u011e"+
|
|
"\u063b\u0001\u0000\u0000\u0000\u0120\u064a\u0001\u0000\u0000\u0000\u0122"+
|
|
"\u064d\u0001\u0000\u0000\u0000\u0124\u065e\u0001\u0000\u0000\u0000\u0126"+
|
|
"\u0660\u0001\u0000\u0000\u0000\u0128\u0662\u0001\u0000\u0000\u0000\u012a"+
|
|
"\u0668\u0001\u0000\u0000\u0000\u012c\u066e\u0001\u0000\u0000\u0000\u012e"+
|
|
"\u0678\u0001\u0000\u0000\u0000\u0130\u067c\u0001\u0000\u0000\u0000\u0132"+
|
|
"\u067e\u0001\u0000\u0000\u0000\u0134\u068e\u0001\u0000\u0000\u0000\u0136"+
|
|
"\u06a0\u0001\u0000\u0000\u0000\u0138\u06a2\u0001\u0000\u0000\u0000\u013a"+
|
|
"\u06a4\u0001\u0000\u0000\u0000\u013c\u06ac\u0001\u0000\u0000\u0000\u013e"+
|
|
"\u06bb\u0001\u0000\u0000\u0000\u0140\u06ca\u0001\u0000\u0000\u0000\u0142"+
|
|
"\u06d0\u0001\u0000\u0000\u0000\u0144\u06d6\u0001\u0000\u0000\u0000\u0146"+
|
|
"\u06dc\u0001\u0000\u0000\u0000\u0148\u06e0\u0001\u0000\u0000\u0000\u014a"+
|
|
"\u06f2\u0001\u0000\u0000\u0000\u014c\u06f4\u0001\u0000\u0000\u0000\u014e"+
|
|
"\u06fb\u0001\u0000\u0000\u0000\u0150\u0704\u0001\u0000\u0000\u0000\u0152"+
|
|
"\u070a\u0001\u0000\u0000\u0000\u0154\u0712\u0001\u0000\u0000\u0000\u0156"+
|
|
"\u0715\u0001\u0000\u0000\u0000\u0158\u071e\u0001\u0000\u0000\u0000\u015a"+
|
|
"\u0725\u0001\u0000\u0000\u0000\u015c\u0730\u0001\u0000\u0000\u0000\u015e"+
|
|
"\u073a\u0001\u0000\u0000\u0000\u0160\u075f\u0001\u0000\u0000\u0000\u0162"+
|
|
"\u0761\u0001\u0000\u0000\u0000\u0164\u077f\u0001\u0000\u0000\u0000\u0166"+
|
|
"\u0786\u0001\u0000\u0000\u0000\u0168\u0788\u0001\u0000\u0000\u0000\u016a"+
|
|
"\u078e\u0001\u0000\u0000\u0000\u016c\u07b8\u0001\u0000\u0000\u0000\u016e"+
|
|
"\u07ba\u0001\u0000\u0000\u0000\u0170\u07e3\u0001\u0000\u0000\u0000\u0172"+
|
|
"\u0838\u0001\u0000\u0000\u0000\u0174\u083a\u0001\u0000\u0000\u0000\u0176"+
|
|
"\u088c\u0001\u0000\u0000\u0000\u0178\u0891\u0001\u0000\u0000\u0000\u017a"+
|
|
"\u08a0\u0001\u0000\u0000\u0000\u017c\u08a2\u0001\u0000\u0000\u0000\u017e"+
|
|
"\u08ae\u0001\u0000\u0000\u0000\u0180\u08ba\u0001\u0000\u0000\u0000\u0182"+
|
|
"\u08c6\u0001\u0000\u0000\u0000\u0184\u08de\u0001\u0000\u0000\u0000\u0186"+
|
|
"\u092e\u0001\u0000\u0000\u0000\u0188\u0930\u0001\u0000\u0000\u0000\u018a"+
|
|
"\u0973\u0001\u0000\u0000\u0000\u018c\u0975\u0001\u0000\u0000\u0000\u018e"+
|
|
"\u09ac\u0001\u0000\u0000\u0000\u0190\u09ae\u0001\u0000\u0000\u0000\u0192"+
|
|
"\u09dc\u0001\u0000\u0000\u0000\u0194\u09f4\u0001\u0000\u0000\u0000\u0196"+
|
|
"\u09f6\u0001\u0000\u0000\u0000\u0198\u0a00\u0001\u0000\u0000\u0000\u019a"+
|
|
"\u0a07\u0001\u0000\u0000\u0000\u019c\u0a0b\u0001\u0000\u0000\u0000\u019e"+
|
|
"\u0a0d\u0001\u0000\u0000\u0000\u01a0\u0a1b\u0001\u0000\u0000\u0000\u01a2"+
|
|
"\u0a1d\u0001\u0000\u0000\u0000\u01a4\u0a27\u0001\u0000\u0000\u0000\u01a6"+
|
|
"\u0a2b\u0001\u0000\u0000\u0000\u01a8\u0a2d\u0001\u0000\u0000\u0000\u01aa"+
|
|
"\u0a34\u0001\u0000\u0000\u0000\u01ac\u0a36\u0001\u0000\u0000\u0000\u01ae"+
|
|
"\u0a3f\u0001\u0000\u0000\u0000\u01b0\u0a41\u0001\u0000\u0000\u0000\u01b2"+
|
|
"\u0a4c\u0001\u0000\u0000\u0000\u01b4\u0a57\u0001\u0000\u0000\u0000\u01b6"+
|
|
"\u0a62\u0001\u0000\u0000\u0000\u01b8\u0a6d\u0001\u0000\u0000\u0000\u01ba"+
|
|
"\u0a78\u0001\u0000\u0000\u0000\u01bc\u0a86\u0001\u0000\u0000\u0000\u01be"+
|
|
"\u0a9d\u0001\u0000\u0000\u0000\u01c0\u0ab2\u0001\u0000\u0000\u0000\u01c2"+
|
|
"\u0ac0\u0001\u0000\u0000\u0000\u01c4\u0ad8\u0001\u0000\u0000\u0000\u01c6"+
|
|
"\u0ada\u0001\u0000\u0000\u0000\u01c8\u0add\u0001\u0000\u0000\u0000\u01ca"+
|
|
"\u0ae6\u0001\u0000\u0000\u0000\u01cc\u0aea\u0001\u0000\u0000\u0000\u01ce"+
|
|
"\u0af3\u0001\u0000\u0000\u0000\u01d0\u0af6\u0001\u0000\u0000\u0000\u01d2"+
|
|
"\u0af8\u0001\u0000\u0000\u0000\u01d4\u0afb\u0001\u0000\u0000\u0000\u01d6"+
|
|
"\u0b18\u0001\u0000\u0000\u0000\u01d8\u01d9\u0007\u0000\u0000\u0000\u01d9"+
|
|
"\u0001\u0001\u0000\u0000\u0000\u01da\u01dc\u0003\u00e4r\u0000\u01db\u01da"+
|
|
"\u0001\u0000\u0000\u0000\u01dc\u01df\u0001\u0000\u0000\u0000\u01dd\u01db"+
|
|
"\u0001\u0000\u0000\u0000\u01dd\u01de\u0001\u0000\u0000\u0000\u01de\u01e0"+
|
|
"\u0001\u0000\u0000\u0000\u01df\u01dd\u0001\u0000\u0000\u0000\u01e0\u01e9"+
|
|
"\u0003\u0004\u0002\u0000\u01e1\u01e3\u0003\u00e4r\u0000\u01e2\u01e1\u0001"+
|
|
"\u0000\u0000\u0000\u01e3\u01e6\u0001\u0000\u0000\u0000\u01e4\u01e2\u0001"+
|
|
"\u0000\u0000\u0000\u01e4\u01e5\u0001\u0000\u0000\u0000\u01e5\u01e7\u0001"+
|
|
"\u0000\u0000\u0000\u01e6\u01e4\u0001\u0000\u0000\u0000\u01e7\u01e9\u0005"+
|
|
"\u0003\u0000\u0000\u01e8\u01dd\u0001\u0000\u0000\u0000\u01e8\u01e4\u0001"+
|
|
"\u0000\u0000\u0000\u01e9\u0003\u0001\u0000\u0000\u0000\u01ea\u01ed\u0003"+
|
|
"\u0006\u0003\u0000\u01eb\u01ed\u0003\b\u0004\u0000\u01ec\u01ea\u0001\u0000"+
|
|
"\u0000\u0000\u01ec\u01eb\u0001\u0000\u0000\u0000\u01ed\u0005\u0001\u0000"+
|
|
"\u0000\u0000\u01ee\u01ef\u0007\u0001\u0000\u0000\u01ef\u0007\u0001\u0000"+
|
|
"\u0000\u0000\u01f0\u01f1\u0007\u0002\u0000\u0000\u01f1\t\u0001\u0000\u0000"+
|
|
"\u0000\u01f2\u01f6\u0003\f\u0006\u0000\u01f3\u01f6\u0003\u001a\r\u0000"+
|
|
"\u01f4\u01f6\u0003\u001c\u000e\u0000\u01f5\u01f2\u0001\u0000\u0000\u0000"+
|
|
"\u01f5\u01f3\u0001\u0000\u0000\u0000\u01f5\u01f4\u0001\u0000\u0000\u0000"+
|
|
"\u01f6\u000b\u0001\u0000\u0000\u0000\u01f7\u01fa\u0003\u0012\t\u0000\u01f8"+
|
|
"\u01fa\u0003\u0018\f\u0000\u01f9\u01f7\u0001\u0000\u0000\u0000\u01f9\u01f8"+
|
|
"\u0001\u0000\u0000\u0000\u01fa\u01ff\u0001\u0000\u0000\u0000\u01fb\u01fe"+
|
|
"\u0003\u0010\b\u0000\u01fc\u01fe\u0003\u0016\u000b\u0000\u01fd\u01fb\u0001"+
|
|
"\u0000\u0000\u0000\u01fd\u01fc\u0001\u0000\u0000\u0000\u01fe\u0201\u0001"+
|
|
"\u0000\u0000\u0000\u01ff\u01fd\u0001\u0000\u0000\u0000\u01ff\u0200\u0001"+
|
|
"\u0000\u0000\u0000\u0200\r\u0001\u0000\u0000\u0000\u0201\u01ff\u0001\u0000"+
|
|
"\u0000\u0000\u0202\u0204\u0003\u00e4r\u0000\u0203\u0202\u0001\u0000\u0000"+
|
|
"\u0000\u0204\u0207\u0001\u0000\u0000\u0000\u0205\u0203\u0001\u0000\u0000"+
|
|
"\u0000\u0205\u0206\u0001\u0000\u0000\u0000\u0206\u0208\u0001\u0000\u0000"+
|
|
"\u0000\u0207\u0205\u0001\u0000\u0000\u0000\u0208\u020a\u0005f\u0000\u0000"+
|
|
"\u0209\u020b\u0003(\u0014\u0000\u020a\u0209\u0001\u0000\u0000\u0000\u020a"+
|
|
"\u020b\u0001\u0000\u0000\u0000\u020b\u0219\u0001\u0000\u0000\u0000\u020c"+
|
|
"\u020d\u0003\f\u0006\u0000\u020d\u0211\u0005A\u0000\u0000\u020e\u0210"+
|
|
"\u0003\u00e4r\u0000\u020f\u020e\u0001\u0000\u0000\u0000\u0210\u0213\u0001"+
|
|
"\u0000\u0000\u0000\u0211\u020f\u0001\u0000\u0000\u0000\u0211\u0212\u0001"+
|
|
"\u0000\u0000\u0000\u0212\u0214\u0001\u0000\u0000\u0000\u0213\u0211\u0001"+
|
|
"\u0000\u0000\u0000\u0214\u0216\u0005f\u0000\u0000\u0215\u0217\u0003(\u0014"+
|
|
"\u0000\u0216\u0215\u0001\u0000\u0000\u0000\u0216\u0217\u0001\u0000\u0000"+
|
|
"\u0000\u0217\u0219\u0001\u0000\u0000\u0000\u0218\u0205\u0001\u0000\u0000"+
|
|
"\u0000\u0218\u020c\u0001\u0000\u0000\u0000\u0219\u000f\u0001\u0000\u0000"+
|
|
"\u0000\u021a\u021e\u0005A\u0000\u0000\u021b\u021d\u0003\u00e4r\u0000\u021c"+
|
|
"\u021b\u0001\u0000\u0000\u0000\u021d\u0220\u0001\u0000\u0000\u0000\u021e"+
|
|
"\u021c\u0001\u0000\u0000\u0000\u021e\u021f\u0001\u0000\u0000\u0000\u021f"+
|
|
"\u0221\u0001\u0000\u0000\u0000\u0220\u021e\u0001\u0000\u0000\u0000\u0221"+
|
|
"\u0223\u0005f\u0000\u0000\u0222\u0224\u0003(\u0014\u0000\u0223\u0222\u0001"+
|
|
"\u0000\u0000\u0000\u0223\u0224\u0001\u0000\u0000\u0000\u0224\u0011\u0001"+
|
|
"\u0000\u0000\u0000\u0225\u0227\u0003\u00e4r\u0000\u0226\u0225\u0001\u0000"+
|
|
"\u0000\u0000\u0227\u022a\u0001\u0000\u0000\u0000\u0228\u0226\u0001\u0000"+
|
|
"\u0000\u0000\u0228\u0229\u0001\u0000\u0000\u0000\u0229\u022b\u0001\u0000"+
|
|
"\u0000\u0000\u022a\u0228\u0001\u0000\u0000\u0000\u022b\u022d\u0005f\u0000"+
|
|
"\u0000\u022c\u022e\u0003(\u0014\u0000\u022d\u022c\u0001\u0000\u0000\u0000"+
|
|
"\u022d\u022e\u0001\u0000\u0000\u0000\u022e\u0013\u0001\u0000\u0000\u0000"+
|
|
"\u022f\u0230\u0003\u000e\u0007\u0000\u0230\u0015\u0001\u0000\u0000\u0000"+
|
|
"\u0231\u0232\u0003\u0010\b\u0000\u0232\u0017\u0001\u0000\u0000\u0000\u0233"+
|
|
"\u0234\u0003\u0012\t\u0000\u0234\u0019\u0001\u0000\u0000\u0000\u0235\u0237"+
|
|
"\u0003\u00e4r\u0000\u0236\u0235\u0001\u0000\u0000\u0000\u0237\u023a\u0001"+
|
|
"\u0000\u0000\u0000\u0238\u0236\u0001\u0000\u0000\u0000\u0238\u0239\u0001"+
|
|
"\u0000\u0000\u0000\u0239\u023b\u0001\u0000\u0000\u0000\u023a\u0238\u0001"+
|
|
"\u0000\u0000\u0000\u023b\u023c\u0005f\u0000\u0000\u023c\u001b\u0001\u0000"+
|
|
"\u0000\u0000\u023d\u023e\u0003\u0002\u0001\u0000\u023e\u023f\u0003\u001e"+
|
|
"\u000f\u0000\u023f\u0247\u0001\u0000\u0000\u0000\u0240\u0241\u0003\f\u0006"+
|
|
"\u0000\u0241\u0242\u0003\u001e\u000f\u0000\u0242\u0247\u0001\u0000\u0000"+
|
|
"\u0000\u0243\u0244\u0003\u001a\r\u0000\u0244\u0245\u0003\u001e\u000f\u0000"+
|
|
"\u0245\u0247\u0001\u0000\u0000\u0000\u0246\u023d\u0001\u0000\u0000\u0000"+
|
|
"\u0246\u0240\u0001\u0000\u0000\u0000\u0246\u0243\u0001\u0000\u0000\u0000"+
|
|
"\u0247\u001d\u0001\u0000\u0000\u0000\u0248\u024a\u0003\u00e4r\u0000\u0249"+
|
|
"\u0248\u0001\u0000\u0000\u0000\u024a\u024d\u0001\u0000\u0000\u0000\u024b"+
|
|
"\u0249\u0001\u0000\u0000\u0000\u024b\u024c\u0001\u0000\u0000\u0000\u024c"+
|
|
"\u024e\u0001\u0000\u0000\u0000\u024d\u024b\u0001\u0000\u0000\u0000\u024e"+
|
|
"\u024f\u0005=\u0000\u0000\u024f\u025a\u0005>\u0000\u0000\u0250\u0252\u0003"+
|
|
"\u00e4r\u0000\u0251\u0250\u0001\u0000\u0000\u0000\u0252\u0255\u0001\u0000"+
|
|
"\u0000\u0000\u0253\u0251\u0001\u0000\u0000\u0000\u0253\u0254\u0001\u0000"+
|
|
"\u0000\u0000\u0254\u0256\u0001\u0000\u0000\u0000\u0255\u0253\u0001\u0000"+
|
|
"\u0000\u0000\u0256\u0257\u0005=\u0000\u0000\u0257\u0259\u0005>\u0000\u0000"+
|
|
"\u0258\u0253\u0001\u0000\u0000\u0000\u0259\u025c\u0001\u0000\u0000\u0000"+
|
|
"\u025a\u0258\u0001\u0000\u0000\u0000\u025a\u025b\u0001\u0000\u0000\u0000"+
|
|
"\u025b\u001f\u0001\u0000\u0000\u0000\u025c\u025a\u0001\u0000\u0000\u0000"+
|
|
"\u025d\u025f\u0003\"\u0011\u0000\u025e\u025d\u0001\u0000\u0000\u0000\u025f"+
|
|
"\u0262\u0001\u0000\u0000\u0000\u0260\u025e\u0001\u0000\u0000\u0000\u0260"+
|
|
"\u0261\u0001\u0000\u0000\u0000\u0261\u0263\u0001\u0000\u0000\u0000\u0262"+
|
|
"\u0260\u0001\u0000\u0000\u0000\u0263\u0265\u0005f\u0000\u0000\u0264\u0266"+
|
|
"\u0003$\u0012\u0000\u0265\u0264\u0001\u0000\u0000\u0000\u0265\u0266\u0001"+
|
|
"\u0000\u0000\u0000\u0266!\u0001\u0000\u0000\u0000\u0267\u0268\u0003\u00e4"+
|
|
"r\u0000\u0268#\u0001\u0000\u0000\u0000\u0269\u026a\u0005\u0011\u0000\u0000"+
|
|
"\u026a\u0274\u0003\u001a\r\u0000\u026b\u026c\u0005\u0011\u0000\u0000\u026c"+
|
|
"\u0270\u0003\f\u0006\u0000\u026d\u026f\u0003&\u0013\u0000\u026e\u026d"+
|
|
"\u0001\u0000\u0000\u0000\u026f\u0272\u0001\u0000\u0000\u0000\u0270\u026e"+
|
|
"\u0001\u0000\u0000\u0000\u0270\u0271\u0001\u0000\u0000\u0000\u0271\u0274"+
|
|
"\u0001\u0000\u0000\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0273\u0269"+
|
|
"\u0001\u0000\u0000\u0000\u0273\u026b\u0001\u0000\u0000\u0000\u0274%\u0001"+
|
|
"\u0000\u0000\u0000\u0275\u0276\u0005U\u0000\u0000\u0276\u0277\u0003\u0014"+
|
|
"\n\u0000\u0277\'\u0001\u0000\u0000\u0000\u0278\u0279\u0005D\u0000\u0000"+
|
|
"\u0279\u027a\u0003*\u0015\u0000\u027a\u027b\u0005C\u0000\u0000\u027b)"+
|
|
"\u0001\u0000\u0000\u0000\u027c\u0281\u0003,\u0016\u0000\u027d\u027e\u0005"+
|
|
"@\u0000\u0000\u027e\u0280\u0003,\u0016\u0000\u027f\u027d\u0001\u0000\u0000"+
|
|
"\u0000\u0280\u0283\u0001\u0000\u0000\u0000\u0281\u027f\u0001\u0000\u0000"+
|
|
"\u0000\u0281\u0282\u0001\u0000\u0000\u0000\u0282+\u0001\u0000\u0000\u0000"+
|
|
"\u0283\u0281\u0001\u0000\u0000\u0000\u0284\u0287\u0003\n\u0005\u0000\u0285"+
|
|
"\u0287\u0003.\u0017\u0000\u0286\u0284\u0001\u0000\u0000\u0000\u0286\u0285"+
|
|
"\u0001\u0000\u0000\u0000\u0287-\u0001\u0000\u0000\u0000\u0288\u028a\u0003"+
|
|
"\u00e4r\u0000\u0289\u0288\u0001\u0000\u0000\u0000\u028a\u028d\u0001\u0000"+
|
|
"\u0000\u0000\u028b\u0289\u0001\u0000\u0000\u0000\u028b\u028c\u0001\u0000"+
|
|
"\u0000\u0000\u028c\u028e\u0001\u0000\u0000\u0000\u028d\u028b\u0001\u0000"+
|
|
"\u0000\u0000\u028e\u0290\u0005G\u0000\u0000\u028f\u0291\u00030\u0018\u0000"+
|
|
"\u0290\u028f\u0001\u0000\u0000\u0000\u0290\u0291\u0001\u0000\u0000\u0000"+
|
|
"\u0291/\u0001\u0000\u0000\u0000\u0292\u0293\u0005\u0011\u0000\u0000\u0293"+
|
|
"\u0297\u0003\n\u0005\u0000\u0294\u0295\u0005(\u0000\u0000\u0295\u0297"+
|
|
"\u0003\n\u0005\u0000\u0296\u0292\u0001\u0000\u0000\u0000\u0296\u0294\u0001"+
|
|
"\u0000\u0000\u0000\u02971\u0001\u0000\u0000\u0000\u0298\u0299\u0006\u0019"+
|
|
"\uffff\uffff\u0000\u0299\u029a\u0005f\u0000\u0000\u029a\u02a0\u0001\u0000"+
|
|
"\u0000\u0000\u029b\u029c\n\u0001\u0000\u0000\u029c\u029d\u0005A\u0000"+
|
|
"\u0000\u029d\u029f\u0005f\u0000\u0000\u029e\u029b\u0001\u0000\u0000\u0000"+
|
|
"\u029f\u02a2\u0001\u0000\u0000\u0000\u02a0\u029e\u0001\u0000\u0000\u0000"+
|
|
"\u02a0\u02a1\u0001\u0000\u0000\u0000\u02a13\u0001\u0000\u0000\u0000\u02a2"+
|
|
"\u02a0\u0001\u0000\u0000\u0000\u02a3\u02a9\u0005f\u0000\u0000\u02a4\u02a5"+
|
|
"\u00036\u001b\u0000\u02a5\u02a6\u0005A\u0000\u0000\u02a6\u02a7\u0005f"+
|
|
"\u0000\u0000\u02a7\u02a9\u0001\u0000\u0000\u0000\u02a8\u02a3\u0001\u0000"+
|
|
"\u0000\u0000\u02a8\u02a4\u0001\u0000\u0000\u0000\u02a95\u0001\u0000\u0000"+
|
|
"\u0000\u02aa\u02ab\u0006\u001b\uffff\uffff\u0000\u02ab\u02ac\u0005f\u0000"+
|
|
"\u0000\u02ac\u02b2\u0001\u0000\u0000\u0000\u02ad\u02ae\n\u0001\u0000\u0000"+
|
|
"\u02ae\u02af\u0005A\u0000\u0000\u02af\u02b1\u0005f\u0000\u0000\u02b0\u02ad"+
|
|
"\u0001\u0000\u0000\u0000\u02b1\u02b4\u0001\u0000\u0000\u0000\u02b2\u02b0"+
|
|
"\u0001\u0000\u0000\u0000\u02b2\u02b3\u0001\u0000\u0000\u0000\u02b37\u0001"+
|
|
"\u0000\u0000\u0000\u02b4\u02b2\u0001\u0000\u0000\u0000\u02b5\u02bb\u0005"+
|
|
"f\u0000\u0000\u02b6\u02b7\u0003<\u001e\u0000\u02b7\u02b8\u0005A\u0000"+
|
|
"\u0000\u02b8\u02b9\u0005f\u0000\u0000\u02b9\u02bb\u0001\u0000\u0000\u0000"+
|
|
"\u02ba\u02b5\u0001\u0000\u0000\u0000\u02ba\u02b6\u0001\u0000\u0000\u0000"+
|
|
"\u02bb9\u0001\u0000\u0000\u0000\u02bc\u02bd\u0005f\u0000\u0000\u02bd;"+
|
|
"\u0001\u0000\u0000\u0000\u02be\u02bf\u0006\u001e\uffff\uffff\u0000\u02bf"+
|
|
"\u02c0\u0005f\u0000\u0000\u02c0\u02c6\u0001\u0000\u0000\u0000\u02c1\u02c2"+
|
|
"\n\u0001\u0000\u0000\u02c2\u02c3\u0005A\u0000\u0000\u02c3\u02c5\u0005"+
|
|
"f\u0000\u0000\u02c4\u02c1\u0001\u0000\u0000\u0000\u02c5\u02c8\u0001\u0000"+
|
|
"\u0000\u0000\u02c6\u02c4\u0001\u0000\u0000\u0000\u02c6\u02c7\u0001\u0000"+
|
|
"\u0000\u0000\u02c7=\u0001\u0000\u0000\u0000\u02c8\u02c6\u0001\u0000\u0000"+
|
|
"\u0000\u02c9\u02cb\u0003@ \u0000\u02ca\u02c9\u0001\u0000\u0000\u0000\u02ca"+
|
|
"\u02cb\u0001\u0000\u0000\u0000\u02cb\u02cf\u0001\u0000\u0000\u0000\u02cc"+
|
|
"\u02ce\u0003D\"\u0000\u02cd\u02cc\u0001\u0000\u0000\u0000\u02ce\u02d1"+
|
|
"\u0001\u0000\u0000\u0000\u02cf\u02cd\u0001\u0000\u0000\u0000\u02cf\u02d0"+
|
|
"\u0001\u0000\u0000\u0000\u02d0\u02d5\u0001\u0000\u0000\u0000\u02d1\u02cf"+
|
|
"\u0001\u0000\u0000\u0000\u02d2\u02d4\u0003N\'\u0000\u02d3\u02d2\u0001"+
|
|
"\u0000\u0000\u0000\u02d4\u02d7\u0001\u0000\u0000\u0000\u02d5\u02d3\u0001"+
|
|
"\u0000\u0000\u0000\u02d5\u02d6\u0001\u0000\u0000\u0000\u02d6\u02d8\u0001"+
|
|
"\u0000\u0000\u0000\u02d7\u02d5\u0001\u0000\u0000\u0000\u02d8\u02d9\u0005"+
|
|
"\u0000\u0000\u0001\u02d9?\u0001\u0000\u0000\u0000\u02da\u02dc\u0003B!"+
|
|
"\u0000\u02db\u02da\u0001\u0000\u0000\u0000\u02dc\u02df\u0001\u0000\u0000"+
|
|
"\u0000\u02dd\u02db\u0001\u0000\u0000\u0000\u02dd\u02de\u0001\u0000\u0000"+
|
|
"\u0000\u02de\u02e0\u0001\u0000\u0000\u0000\u02df\u02dd\u0001\u0000\u0000"+
|
|
"\u0000\u02e0\u02e1\u0005 \u0000\u0000\u02e1\u02e2\u00032\u0019\u0000\u02e2"+
|
|
"\u02e3\u0005?\u0000\u0000\u02e3A\u0001\u0000\u0000\u0000\u02e4\u02e5\u0003"+
|
|
"\u00e4r\u0000\u02e5C\u0001\u0000\u0000\u0000\u02e6\u02eb\u0003F#\u0000"+
|
|
"\u02e7\u02eb\u0003H$\u0000\u02e8\u02eb\u0003J%\u0000\u02e9\u02eb\u0003"+
|
|
"L&\u0000\u02ea\u02e6\u0001\u0000\u0000\u0000\u02ea\u02e7\u0001\u0000\u0000"+
|
|
"\u0000\u02ea\u02e8\u0001\u0000\u0000\u0000\u02ea\u02e9\u0001\u0000\u0000"+
|
|
"\u0000\u02ebE\u0001\u0000\u0000\u0000\u02ec\u02ed\u0005\u0019\u0000\u0000"+
|
|
"\u02ed\u02ee\u00034\u001a\u0000\u02ee\u02ef\u0005?\u0000\u0000\u02efG"+
|
|
"\u0001\u0000\u0000\u0000\u02f0\u02f1\u0005\u0019\u0000\u0000\u02f1\u02f2"+
|
|
"\u00036\u001b\u0000\u02f2\u02f3\u0005A\u0000\u0000\u02f3\u02f4\u0005S"+
|
|
"\u0000\u0000\u02f4\u02f5\u0005?\u0000\u0000\u02f5I\u0001\u0000\u0000\u0000"+
|
|
"\u02f6\u02f7\u0005\u0019\u0000\u0000\u02f7\u02f8\u0005&\u0000\u0000\u02f8"+
|
|
"\u02f9\u00034\u001a\u0000\u02f9\u02fa\u0005A\u0000\u0000\u02fa\u02fb\u0005"+
|
|
"f\u0000\u0000\u02fb\u02fc\u0005?\u0000\u0000\u02fcK\u0001\u0000\u0000"+
|
|
"\u0000\u02fd\u02fe\u0005\u0019\u0000\u0000\u02fe\u02ff\u0005&\u0000\u0000"+
|
|
"\u02ff\u0300\u00034\u001a\u0000\u0300\u0301\u0005A\u0000\u0000\u0301\u0302"+
|
|
"\u0005S\u0000\u0000\u0302\u0303\u0005?\u0000\u0000\u0303M\u0001\u0000"+
|
|
"\u0000\u0000\u0304\u0308\u0003P(\u0000\u0305\u0308\u0003\u00c4b\u0000"+
|
|
"\u0306\u0308\u0005?\u0000\u0000\u0307\u0304\u0001\u0000\u0000\u0000\u0307"+
|
|
"\u0305\u0001\u0000\u0000\u0000\u0307\u0306\u0001\u0000\u0000\u0000\u0308"+
|
|
"O\u0001\u0000\u0000\u0000\u0309\u030c\u0003R)\u0000\u030a\u030c\u0003"+
|
|
"\u00b8\\\u0000\u030b\u0309\u0001\u0000\u0000\u0000\u030b\u030a\u0001\u0000"+
|
|
"\u0000\u0000\u030cQ\u0001\u0000\u0000\u0000\u030d\u030f\u0003T*\u0000"+
|
|
"\u030e\u030d\u0001\u0000\u0000\u0000\u030f\u0312\u0001\u0000\u0000\u0000"+
|
|
"\u0310\u030e\u0001\u0000\u0000\u0000\u0310\u0311\u0001\u0000\u0000\u0000"+
|
|
"\u0311\u0313\u0001\u0000\u0000\u0000\u0312\u0310\u0001\u0000\u0000\u0000"+
|
|
"\u0313\u0314\u0005\t\u0000\u0000\u0314\u0316\u0005f\u0000\u0000\u0315"+
|
|
"\u0317\u0003V+\u0000\u0316\u0315\u0001\u0000\u0000\u0000\u0316\u0317\u0001"+
|
|
"\u0000\u0000\u0000\u0317\u0319\u0001\u0000\u0000\u0000\u0318\u031a\u0003"+
|
|
"Z-\u0000\u0319\u0318\u0001\u0000\u0000\u0000\u0319\u031a\u0001\u0000\u0000"+
|
|
"\u0000\u031a\u031c\u0001\u0000\u0000\u0000\u031b\u031d\u0003\\.\u0000"+
|
|
"\u031c\u031b\u0001\u0000\u0000\u0000\u031c\u031d\u0001\u0000\u0000\u0000"+
|
|
"\u031d\u031e\u0001\u0000\u0000\u0000\u031e\u031f\u0003`0\u0000\u031fS"+
|
|
"\u0001\u0000\u0000\u0000\u0320\u0329\u0003\u00e4r\u0000\u0321\u0329\u0005"+
|
|
"#\u0000\u0000\u0322\u0329\u0005\"\u0000\u0000\u0323\u0329\u0005!\u0000"+
|
|
"\u0000\u0324\u0329\u0005\u0001\u0000\u0000\u0325\u0329\u0005&\u0000\u0000"+
|
|
"\u0326\u0329\u0005\u0012\u0000\u0000\u0327\u0329\u0005\'\u0000\u0000\u0328"+
|
|
"\u0320\u0001\u0000\u0000\u0000\u0328\u0321\u0001\u0000\u0000\u0000\u0328"+
|
|
"\u0322\u0001\u0000\u0000\u0000\u0328\u0323\u0001\u0000\u0000\u0000\u0328"+
|
|
"\u0324\u0001\u0000\u0000\u0000\u0328\u0325\u0001\u0000\u0000\u0000\u0328"+
|
|
"\u0326\u0001\u0000\u0000\u0000\u0328\u0327\u0001\u0000\u0000\u0000\u0329"+
|
|
"U\u0001\u0000\u0000\u0000\u032a\u032b\u0005D\u0000\u0000\u032b\u032c\u0003"+
|
|
"X,\u0000\u032c\u032d\u0005C\u0000\u0000\u032dW\u0001\u0000\u0000\u0000"+
|
|
"\u032e\u0333\u0003 \u0010\u0000\u032f\u0330\u0005@\u0000\u0000\u0330\u0332"+
|
|
"\u0003 \u0010\u0000\u0331\u032f\u0001\u0000\u0000\u0000\u0332\u0335\u0001"+
|
|
"\u0000\u0000\u0000\u0333\u0331\u0001\u0000\u0000\u0000\u0333\u0334\u0001"+
|
|
"\u0000\u0000\u0000\u0334Y\u0001\u0000\u0000\u0000\u0335\u0333\u0001\u0000"+
|
|
"\u0000\u0000\u0336\u0337\u0005\u0011\u0000\u0000\u0337\u0338\u0003\u000e"+
|
|
"\u0007\u0000\u0338[\u0001\u0000\u0000\u0000\u0339\u033a\u0005\u0018\u0000"+
|
|
"\u0000\u033a\u033b\u0003^/\u0000\u033b]\u0001\u0000\u0000\u0000\u033c"+
|
|
"\u0341\u0003\u0014\n\u0000\u033d\u033e\u0005@\u0000\u0000\u033e\u0340"+
|
|
"\u0003\u0014\n\u0000\u033f\u033d\u0001\u0000\u0000\u0000\u0340\u0343\u0001"+
|
|
"\u0000\u0000\u0000\u0341\u033f\u0001\u0000\u0000\u0000\u0341\u0342\u0001"+
|
|
"\u0000\u0000\u0000\u0342_\u0001\u0000\u0000\u0000\u0343\u0341\u0001\u0000"+
|
|
"\u0000\u0000\u0344\u0348\u0005;\u0000\u0000\u0345\u0347\u0003b1\u0000"+
|
|
"\u0346\u0345\u0001\u0000\u0000\u0000\u0347\u034a\u0001\u0000\u0000\u0000"+
|
|
"\u0348\u0346\u0001\u0000\u0000\u0000\u0348\u0349\u0001\u0000\u0000\u0000"+
|
|
"\u0349\u034b\u0001\u0000\u0000\u0000\u034a\u0348\u0001\u0000\u0000\u0000"+
|
|
"\u034b\u034c\u0005<\u0000\u0000\u034ca\u0001\u0000\u0000\u0000\u034d\u0352"+
|
|
"\u0003d2\u0000\u034e\u0352\u0003\u00a8T\u0000\u034f\u0352\u0003\u00aa"+
|
|
"U\u0000\u0350\u0352\u0003\u00acV\u0000\u0351\u034d\u0001\u0000\u0000\u0000"+
|
|
"\u0351\u034e\u0001\u0000\u0000\u0000\u0351\u034f\u0001\u0000\u0000\u0000"+
|
|
"\u0351\u0350\u0001\u0000\u0000\u0000\u0352c\u0001\u0000\u0000\u0000\u0353"+
|
|
"\u0359\u0003f3\u0000\u0354\u0359\u0003\u008aE\u0000\u0355\u0359\u0003"+
|
|
"P(\u0000\u0356\u0359\u0003\u00c4b\u0000\u0357\u0359\u0005?\u0000\u0000"+
|
|
"\u0358\u0353\u0001\u0000\u0000\u0000\u0358\u0354\u0001\u0000\u0000\u0000"+
|
|
"\u0358\u0355\u0001\u0000\u0000\u0000\u0358\u0356\u0001\u0000\u0000\u0000"+
|
|
"\u0358\u0357\u0001\u0000\u0000\u0000\u0359e\u0001\u0000\u0000\u0000\u035a"+
|
|
"\u035c\u0003h4\u0000\u035b\u035a\u0001\u0000\u0000\u0000\u035c\u035f\u0001"+
|
|
"\u0000\u0000\u0000\u035d\u035b\u0001\u0000\u0000\u0000\u035d\u035e\u0001"+
|
|
"\u0000\u0000\u0000\u035e\u0360\u0001\u0000\u0000\u0000\u035f\u035d\u0001"+
|
|
"\u0000\u0000\u0000\u0360\u0361\u0003r9\u0000\u0361\u0362\u0003j5\u0000"+
|
|
"\u0362\u0363\u0005?\u0000\u0000\u0363g\u0001\u0000\u0000\u0000\u0364\u036d"+
|
|
"\u0003\u00e4r\u0000\u0365\u036d\u0005#\u0000\u0000\u0366\u036d\u0005\""+
|
|
"\u0000\u0000\u0367\u036d\u0005!\u0000\u0000\u0368\u036d\u0005&\u0000\u0000"+
|
|
"\u0369\u036d\u0005\u0012\u0000\u0000\u036a\u036d\u0005.\u0000\u0000\u036b"+
|
|
"\u036d\u00051\u0000\u0000\u036c\u0364\u0001\u0000\u0000\u0000\u036c\u0365"+
|
|
"\u0001\u0000\u0000\u0000\u036c\u0366\u0001\u0000\u0000\u0000\u036c\u0367"+
|
|
"\u0001\u0000\u0000\u0000\u036c\u0368\u0001\u0000\u0000\u0000\u036c\u0369"+
|
|
"\u0001\u0000\u0000\u0000\u036c\u036a\u0001\u0000\u0000\u0000\u036c\u036b"+
|
|
"\u0001\u0000\u0000\u0000\u036di\u0001\u0000\u0000\u0000\u036e\u0373\u0003"+
|
|
"l6\u0000\u036f\u0370\u0005@\u0000\u0000\u0370\u0372\u0003l6\u0000\u0371"+
|
|
"\u036f\u0001\u0000\u0000\u0000\u0372\u0375\u0001\u0000\u0000\u0000\u0373"+
|
|
"\u0371\u0001\u0000\u0000\u0000\u0373\u0374\u0001\u0000\u0000\u0000\u0374"+
|
|
"k\u0001\u0000\u0000\u0000\u0375\u0373\u0001\u0000\u0000\u0000\u0376\u0379"+
|
|
"\u0003n7\u0000\u0377\u0378\u0005B\u0000\u0000\u0378\u037a\u0003p8\u0000"+
|
|
"\u0379\u0377\u0001\u0000\u0000\u0000\u0379\u037a\u0001\u0000\u0000\u0000"+
|
|
"\u037am\u0001\u0000\u0000\u0000\u037b\u037d\u0005f\u0000\u0000\u037c\u037e"+
|
|
"\u0003\u001e\u000f\u0000\u037d\u037c\u0001\u0000\u0000\u0000\u037d\u037e"+
|
|
"\u0001\u0000\u0000\u0000\u037eo\u0001\u0000\u0000\u0000\u037f\u0382\u0003"+
|
|
"\u019c\u00ce\u0000\u0380\u0382\u0003\u00f6{\u0000\u0381\u037f\u0001\u0000"+
|
|
"\u0000\u0000\u0381\u0380\u0001\u0000\u0000\u0000\u0382q\u0001\u0000\u0000"+
|
|
"\u0000\u0383\u0386\u0003t:\u0000\u0384\u0386\u0003v;\u0000\u0385\u0383"+
|
|
"\u0001\u0000\u0000\u0000\u0385\u0384\u0001\u0000\u0000\u0000\u0386s\u0001"+
|
|
"\u0000\u0000\u0000\u0387\u038a\u0003\u0004\u0002\u0000\u0388\u038a\u0005"+
|
|
"\u0003\u0000\u0000\u0389\u0387\u0001\u0000\u0000\u0000\u0389\u0388\u0001"+
|
|
"\u0000\u0000\u0000\u038au\u0001\u0000\u0000\u0000\u038b\u038f\u0003x<"+
|
|
"\u0000\u038c\u038f\u0003\u0086C\u0000\u038d\u038f\u0003\u0088D\u0000\u038e"+
|
|
"\u038b\u0001\u0000\u0000\u0000\u038e\u038c\u0001\u0000\u0000\u0000\u038e"+
|
|
"\u038d\u0001\u0000\u0000\u0000\u038fw\u0001\u0000\u0000\u0000\u0390\u0393"+
|
|
"\u0003~?\u0000\u0391\u0393\u0003\u0084B\u0000\u0392\u0390\u0001\u0000"+
|
|
"\u0000\u0000\u0392\u0391\u0001\u0000\u0000\u0000\u0393\u0398\u0001\u0000"+
|
|
"\u0000\u0000\u0394\u0397\u0003|>\u0000\u0395\u0397\u0003\u0082A\u0000"+
|
|
"\u0396\u0394\u0001\u0000\u0000\u0000\u0396\u0395\u0001\u0000\u0000\u0000"+
|
|
"\u0397\u039a\u0001\u0000\u0000\u0000\u0398\u0396\u0001\u0000\u0000\u0000"+
|
|
"\u0398\u0399\u0001\u0000\u0000\u0000\u0399y\u0001\u0000\u0000\u0000\u039a"+
|
|
"\u0398\u0001\u0000\u0000\u0000\u039b\u039d\u0005f\u0000\u0000\u039c\u039e"+
|
|
"\u0003(\u0014\u0000\u039d\u039c\u0001\u0000\u0000\u0000\u039d\u039e\u0001"+
|
|
"\u0000\u0000\u0000\u039e\u03ac\u0001\u0000\u0000\u0000\u039f\u03a0\u0003"+
|
|
"x<\u0000\u03a0\u03a4\u0005A\u0000\u0000\u03a1\u03a3\u0003\u00e4r\u0000"+
|
|
"\u03a2\u03a1\u0001\u0000\u0000\u0000\u03a3\u03a6\u0001\u0000\u0000\u0000"+
|
|
"\u03a4\u03a2\u0001\u0000\u0000\u0000\u03a4\u03a5\u0001\u0000\u0000\u0000"+
|
|
"\u03a5\u03a7\u0001\u0000\u0000\u0000\u03a6\u03a4\u0001\u0000\u0000\u0000"+
|
|
"\u03a7\u03a9\u0005f\u0000\u0000\u03a8\u03aa\u0003(\u0014\u0000\u03a9\u03a8"+
|
|
"\u0001\u0000\u0000\u0000\u03a9\u03aa\u0001\u0000\u0000\u0000\u03aa\u03ac"+
|
|
"\u0001\u0000\u0000\u0000\u03ab\u039b\u0001\u0000\u0000\u0000\u03ab\u039f"+
|
|
"\u0001\u0000\u0000\u0000\u03ac{\u0001\u0000\u0000\u0000\u03ad\u03b1\u0005"+
|
|
"A\u0000\u0000\u03ae\u03b0\u0003\u00e4r\u0000\u03af\u03ae\u0001\u0000\u0000"+
|
|
"\u0000\u03b0\u03b3\u0001\u0000\u0000\u0000\u03b1\u03af\u0001\u0000\u0000"+
|
|
"\u0000\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2\u03b4\u0001\u0000\u0000"+
|
|
"\u0000\u03b3\u03b1\u0001\u0000\u0000\u0000\u03b4\u03b6\u0005f\u0000\u0000"+
|
|
"\u03b5\u03b7\u0003(\u0014\u0000\u03b6\u03b5\u0001\u0000\u0000\u0000\u03b6"+
|
|
"\u03b7\u0001\u0000\u0000\u0000\u03b7}\u0001\u0000\u0000\u0000\u03b8\u03ba"+
|
|
"\u0005f\u0000\u0000\u03b9\u03bb\u0003(\u0014\u0000\u03ba\u03b9\u0001\u0000"+
|
|
"\u0000\u0000\u03ba\u03bb\u0001\u0000\u0000\u0000\u03bb\u007f\u0001\u0000"+
|
|
"\u0000\u0000\u03bc\u03bd\u0003z=\u0000\u03bd\u0081\u0001\u0000\u0000\u0000"+
|
|
"\u03be\u03bf\u0003|>\u0000\u03bf\u0083\u0001\u0000\u0000\u0000\u03c0\u03c1"+
|
|
"\u0003~?\u0000\u03c1\u0085\u0001\u0000\u0000\u0000\u03c2\u03c3\u0005f"+
|
|
"\u0000\u0000\u03c3\u0087\u0001\u0000\u0000\u0000\u03c4\u03c5\u0003t:\u0000"+
|
|
"\u03c5\u03c6\u0003\u001e\u000f\u0000\u03c6\u03ce\u0001\u0000\u0000\u0000"+
|
|
"\u03c7\u03c8\u0003x<\u0000\u03c8\u03c9\u0003\u001e\u000f\u0000\u03c9\u03ce"+
|
|
"\u0001\u0000\u0000\u0000\u03ca\u03cb\u0003\u0086C\u0000\u03cb\u03cc\u0003"+
|
|
"\u001e\u000f\u0000\u03cc\u03ce\u0001\u0000\u0000\u0000\u03cd\u03c4\u0001"+
|
|
"\u0000\u0000\u0000\u03cd\u03c7\u0001\u0000\u0000\u0000\u03cd\u03ca\u0001"+
|
|
"\u0000\u0000\u0000\u03ce\u0089\u0001\u0000\u0000\u0000\u03cf\u03d1\u0003"+
|
|
"\u008cF\u0000\u03d0\u03cf\u0001\u0000\u0000\u0000\u03d1\u03d4\u0001\u0000"+
|
|
"\u0000\u0000\u03d2\u03d0\u0001\u0000\u0000\u0000\u03d2\u03d3\u0001\u0000"+
|
|
"\u0000\u0000\u03d3\u03d5\u0001\u0000\u0000\u0000\u03d4\u03d2\u0001\u0000"+
|
|
"\u0000\u0000\u03d5\u03d6\u0003\u008eG\u0000\u03d6\u03d7\u0003\u00a6S\u0000"+
|
|
"\u03d7\u008b\u0001\u0000\u0000\u0000\u03d8\u03e3\u0003\u00e4r\u0000\u03d9"+
|
|
"\u03e3\u0005#\u0000\u0000\u03da\u03e3\u0005\"\u0000\u0000\u03db\u03e3"+
|
|
"\u0005!\u0000\u0000\u03dc\u03e3\u0005\u0001\u0000\u0000\u03dd\u03e3\u0005"+
|
|
"&\u0000\u0000\u03de\u03e3\u0005\u0012\u0000\u0000\u03df\u03e3\u0005*\u0000"+
|
|
"\u0000\u03e0\u03e3\u0005\u001e\u0000\u0000\u03e1\u03e3\u0005\'\u0000\u0000"+
|
|
"\u03e2\u03d8\u0001\u0000\u0000\u0000\u03e2\u03d9\u0001\u0000\u0000\u0000"+
|
|
"\u03e2\u03da\u0001\u0000\u0000\u0000\u03e2\u03db\u0001\u0000\u0000\u0000"+
|
|
"\u03e2\u03dc\u0001\u0000\u0000\u0000\u03e2\u03dd\u0001\u0000\u0000\u0000"+
|
|
"\u03e2\u03de\u0001\u0000\u0000\u0000\u03e2\u03df\u0001\u0000\u0000\u0000"+
|
|
"\u03e2\u03e0\u0001\u0000\u0000\u0000\u03e2\u03e1\u0001\u0000\u0000\u0000"+
|
|
"\u03e3\u008d\u0001\u0000\u0000\u0000\u03e4\u03e5\u0003\u0090H\u0000\u03e5"+
|
|
"\u03e7\u0003\u0092I\u0000\u03e6\u03e8\u0003\u00a0P\u0000\u03e7\u03e6\u0001"+
|
|
"\u0000\u0000\u0000\u03e7\u03e8\u0001\u0000\u0000\u0000\u03e8\u03f6\u0001"+
|
|
"\u0000\u0000\u0000\u03e9\u03ed\u0003V+\u0000\u03ea\u03ec\u0003\u00e4r"+
|
|
"\u0000\u03eb\u03ea\u0001\u0000\u0000\u0000\u03ec\u03ef\u0001\u0000\u0000"+
|
|
"\u0000\u03ed\u03eb\u0001\u0000\u0000\u0000\u03ed\u03ee\u0001\u0000\u0000"+
|
|
"\u0000\u03ee\u03f0\u0001\u0000\u0000\u0000\u03ef\u03ed\u0001\u0000\u0000"+
|
|
"\u0000\u03f0\u03f1\u0003\u0090H\u0000\u03f1\u03f3\u0003\u0092I\u0000\u03f2"+
|
|
"\u03f4\u0003\u00a0P\u0000\u03f3\u03f2\u0001\u0000\u0000\u0000\u03f3\u03f4"+
|
|
"\u0001\u0000\u0000\u0000\u03f4\u03f6\u0001\u0000\u0000\u0000\u03f5\u03e4"+
|
|
"\u0001\u0000\u0000\u0000\u03f5\u03e9\u0001\u0000\u0000\u0000\u03f6\u008f"+
|
|
"\u0001\u0000\u0000\u0000\u03f7\u03fa\u0003r9\u0000\u03f8\u03fa\u00050"+
|
|
"\u0000\u0000\u03f9\u03f7\u0001\u0000\u0000\u0000\u03f9\u03f8\u0001\u0000"+
|
|
"\u0000\u0000\u03fa\u0091\u0001\u0000\u0000\u0000\u03fb\u03fc\u0005f\u0000"+
|
|
"\u0000\u03fc\u03fe\u00059\u0000\u0000\u03fd\u03ff\u0003\u0094J\u0000\u03fe"+
|
|
"\u03fd\u0001\u0000\u0000\u0000\u03fe\u03ff\u0001\u0000\u0000\u0000\u03ff"+
|
|
"\u0400\u0001\u0000\u0000\u0000\u0400\u0402\u0005:\u0000\u0000\u0401\u0403"+
|
|
"\u0003\u001e\u000f\u0000\u0402\u0401\u0001\u0000\u0000\u0000\u0402\u0403"+
|
|
"\u0001\u0000\u0000\u0000\u0403\u0093\u0001\u0000\u0000\u0000\u0404\u040b"+
|
|
"\u0003\u009eO\u0000\u0405\u0406\u0003\u0096K\u0000\u0406\u0407\u0005@"+
|
|
"\u0000\u0000\u0407\u0408\u0003\u009cN\u0000\u0408\u040b\u0001\u0000\u0000"+
|
|
"\u0000\u0409\u040b\u0003\u009cN\u0000\u040a\u0404\u0001\u0000\u0000\u0000"+
|
|
"\u040a\u0405\u0001\u0000\u0000\u0000\u040a\u0409\u0001\u0000\u0000\u0000"+
|
|
"\u040b\u0095\u0001\u0000\u0000\u0000\u040c\u0411\u0003\u0098L\u0000\u040d"+
|
|
"\u040e\u0005@\u0000\u0000\u040e\u0410\u0003\u0098L\u0000\u040f\u040d\u0001"+
|
|
"\u0000\u0000\u0000\u0410\u0413\u0001\u0000\u0000\u0000\u0411\u040f\u0001"+
|
|
"\u0000\u0000\u0000\u0411\u0412\u0001\u0000\u0000\u0000\u0412\u041d\u0001"+
|
|
"\u0000\u0000\u0000\u0413\u0411\u0001\u0000\u0000\u0000\u0414\u0419\u0003"+
|
|
"\u009eO\u0000\u0415\u0416\u0005@\u0000\u0000\u0416\u0418\u0003\u0098L"+
|
|
"\u0000\u0417\u0415\u0001\u0000\u0000\u0000\u0418\u041b\u0001\u0000\u0000"+
|
|
"\u0000\u0419\u0417\u0001\u0000\u0000\u0000\u0419\u041a\u0001\u0000\u0000"+
|
|
"\u0000\u041a\u041d\u0001\u0000\u0000\u0000\u041b\u0419\u0001\u0000\u0000"+
|
|
"\u0000\u041c\u040c\u0001\u0000\u0000\u0000\u041c\u0414\u0001\u0000\u0000"+
|
|
"\u0000\u041d\u0097\u0001\u0000\u0000\u0000\u041e\u0420\u0003\u009aM\u0000"+
|
|
"\u041f\u041e\u0001\u0000\u0000\u0000\u0420\u0423\u0001\u0000\u0000\u0000"+
|
|
"\u0421\u041f\u0001\u0000\u0000\u0000\u0421\u0422\u0001\u0000\u0000\u0000"+
|
|
"\u0422\u0424\u0001\u0000\u0000\u0000\u0423\u0421\u0001\u0000\u0000\u0000"+
|
|
"\u0424\u0425\u0003r9\u0000\u0425\u0426\u0003n7\u0000\u0426\u0099\u0001"+
|
|
"\u0000\u0000\u0000\u0427\u042a\u0003\u00e4r\u0000\u0428\u042a\u0005\u0012"+
|
|
"\u0000\u0000\u0429\u0427\u0001\u0000\u0000\u0000\u0429\u0428\u0001\u0000"+
|
|
"\u0000\u0000\u042a\u009b\u0001\u0000\u0000\u0000\u042b\u042d\u0003\u009a"+
|
|
"M\u0000\u042c\u042b\u0001\u0000\u0000\u0000\u042d\u0430\u0001\u0000\u0000"+
|
|
"\u0000\u042e\u042c\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000"+
|
|
"\u0000\u042f\u0431\u0001\u0000\u0000\u0000\u0430\u042e\u0001\u0000\u0000"+
|
|
"\u0000\u0431\u0435\u0003r9\u0000\u0432\u0434\u0003\u00e4r\u0000\u0433"+
|
|
"\u0432\u0001\u0000\u0000\u0000\u0434\u0437\u0001\u0000\u0000\u0000\u0435"+
|
|
"\u0433\u0001\u0000\u0000\u0000\u0435\u0436\u0001\u0000\u0000\u0000\u0436"+
|
|
"\u0438\u0001\u0000\u0000\u0000\u0437\u0435\u0001\u0000\u0000\u0000\u0438"+
|
|
"\u0439\u0005h\u0000\u0000\u0439\u043a\u0003n7\u0000\u043a\u043d\u0001"+
|
|
"\u0000\u0000\u0000\u043b\u043d\u0003\u0098L\u0000\u043c\u042e\u0001\u0000"+
|
|
"\u0000\u0000\u043c\u043b\u0001\u0000\u0000\u0000\u043d\u009d\u0001\u0000"+
|
|
"\u0000\u0000\u043e\u0440\u0003\u00e4r\u0000\u043f\u043e\u0001\u0000\u0000"+
|
|
"\u0000\u0440\u0443\u0001\u0000\u0000\u0000\u0441\u043f\u0001\u0000\u0000"+
|
|
"\u0000\u0441\u0442\u0001\u0000\u0000\u0000\u0442\u0444\u0001\u0000\u0000"+
|
|
"\u0000\u0443\u0441\u0001\u0000\u0000\u0000\u0444\u0447\u0003r9\u0000\u0445"+
|
|
"\u0446\u0005f\u0000\u0000\u0446\u0448\u0005A\u0000\u0000\u0447\u0445\u0001"+
|
|
"\u0000\u0000\u0000\u0447\u0448\u0001\u0000\u0000\u0000\u0448\u0449\u0001"+
|
|
"\u0000\u0000\u0000\u0449\u044a\u0005+\u0000\u0000\u044a\u009f\u0001\u0000"+
|
|
"\u0000\u0000\u044b\u044c\u0005-\u0000\u0000\u044c\u044d\u0003\u00a2Q\u0000"+
|
|
"\u044d\u00a1\u0001\u0000\u0000\u0000\u044e\u0453\u0003\u00a4R\u0000\u044f"+
|
|
"\u0450\u0005@\u0000\u0000\u0450\u0452\u0003\u00a4R\u0000\u0451\u044f\u0001"+
|
|
"\u0000\u0000\u0000\u0452\u0455\u0001\u0000\u0000\u0000\u0453\u0451\u0001"+
|
|
"\u0000\u0000\u0000\u0453\u0454\u0001\u0000\u0000\u0000\u0454\u00a3\u0001"+
|
|
"\u0000\u0000\u0000\u0455\u0453\u0001\u0000\u0000\u0000\u0456\u0459\u0003"+
|
|
"\u000e\u0007\u0000\u0457\u0459\u0003\u001a\r\u0000\u0458\u0456\u0001\u0000"+
|
|
"\u0000\u0000\u0458\u0457\u0001\u0000\u0000\u0000\u0459\u00a5\u0001\u0000"+
|
|
"\u0000\u0000\u045a\u045d\u0003\u00fa}\u0000\u045b\u045d\u0005?\u0000\u0000"+
|
|
"\u045c\u045a\u0001\u0000\u0000\u0000\u045c\u045b\u0001\u0000\u0000\u0000"+
|
|
"\u045d\u00a7\u0001\u0000\u0000\u0000\u045e\u045f\u0003\u00fa}\u0000\u045f"+
|
|
"\u00a9\u0001\u0000\u0000\u0000\u0460\u0461\u0005&\u0000\u0000\u0461\u0462"+
|
|
"\u0003\u00fa}\u0000\u0462\u00ab\u0001\u0000\u0000\u0000\u0463\u0465\u0003"+
|
|
"\u00aeW\u0000\u0464\u0463\u0001\u0000\u0000\u0000\u0465\u0468\u0001\u0000"+
|
|
"\u0000\u0000\u0466\u0464\u0001\u0000\u0000\u0000\u0466\u0467\u0001\u0000"+
|
|
"\u0000\u0000\u0467\u0469\u0001\u0000\u0000\u0000\u0468\u0466\u0001\u0000"+
|
|
"\u0000\u0000\u0469\u046b\u0003\u00b0X\u0000\u046a\u046c\u0003\u00a0P\u0000"+
|
|
"\u046b\u046a\u0001\u0000\u0000\u0000\u046b\u046c\u0001\u0000\u0000\u0000"+
|
|
"\u046c\u046d\u0001\u0000\u0000\u0000\u046d\u046e\u0003\u00b4Z\u0000\u046e"+
|
|
"\u00ad\u0001\u0000\u0000\u0000\u046f\u0474\u0003\u00e4r\u0000\u0470\u0474"+
|
|
"\u0005#\u0000\u0000\u0471\u0474\u0005\"\u0000\u0000\u0472\u0474\u0005"+
|
|
"!\u0000\u0000\u0473\u046f\u0001\u0000\u0000\u0000\u0473\u0470\u0001\u0000"+
|
|
"\u0000\u0000\u0473\u0471\u0001\u0000\u0000\u0000\u0473\u0472\u0001\u0000"+
|
|
"\u0000\u0000\u0474\u00af\u0001\u0000\u0000\u0000\u0475\u0477\u0003V+\u0000"+
|
|
"\u0476\u0475\u0001\u0000\u0000\u0000\u0476\u0477\u0001\u0000\u0000\u0000"+
|
|
"\u0477\u0478\u0001\u0000\u0000\u0000\u0478\u0479\u0003\u00b2Y\u0000\u0479"+
|
|
"\u047b\u00059\u0000\u0000\u047a\u047c\u0003\u0094J\u0000\u047b\u047a\u0001"+
|
|
"\u0000\u0000\u0000\u047b\u047c\u0001\u0000\u0000\u0000\u047c\u047d\u0001"+
|
|
"\u0000\u0000\u0000\u047d\u047e\u0005:\u0000\u0000\u047e\u00b1\u0001\u0000"+
|
|
"\u0000\u0000\u047f\u0480\u0005f\u0000\u0000\u0480\u00b3\u0001\u0000\u0000"+
|
|
"\u0000\u0481\u0483\u0005;\u0000\u0000\u0482\u0484\u0003\u00b6[\u0000\u0483"+
|
|
"\u0482\u0001\u0000\u0000\u0000\u0483\u0484\u0001\u0000\u0000\u0000\u0484"+
|
|
"\u0486\u0001\u0000\u0000\u0000\u0485\u0487\u0003\u00fc~\u0000\u0486\u0485"+
|
|
"\u0001\u0000\u0000\u0000\u0486\u0487\u0001\u0000\u0000\u0000\u0487\u0488"+
|
|
"\u0001\u0000\u0000\u0000\u0488\u0489\u0005<\u0000\u0000\u0489\u00b5\u0001"+
|
|
"\u0000\u0000\u0000\u048a\u048c\u0003(\u0014\u0000\u048b\u048a\u0001\u0000"+
|
|
"\u0000\u0000\u048b\u048c\u0001\u0000\u0000\u0000\u048c\u048d\u0001\u0000"+
|
|
"\u0000\u0000\u048d\u048e\u0005+\u0000\u0000\u048e\u0490\u00059\u0000\u0000"+
|
|
"\u048f\u0491\u0003\u018c\u00c6\u0000\u0490\u048f\u0001\u0000\u0000\u0000"+
|
|
"\u0490\u0491\u0001\u0000\u0000\u0000\u0491\u0492\u0001\u0000\u0000\u0000"+
|
|
"\u0492\u0493\u0005:\u0000\u0000\u0493\u04b9\u0005?\u0000\u0000\u0494\u0496"+
|
|
"\u0003(\u0014\u0000\u0495\u0494\u0001\u0000\u0000\u0000\u0495\u0496\u0001"+
|
|
"\u0000\u0000\u0000\u0496\u0497\u0001\u0000\u0000\u0000\u0497\u0498\u0005"+
|
|
"(\u0000\u0000\u0498\u049a\u00059\u0000\u0000\u0499\u049b\u0003\u018c\u00c6"+
|
|
"\u0000\u049a\u0499\u0001\u0000\u0000\u0000\u049a\u049b\u0001\u0000\u0000"+
|
|
"\u0000\u049b\u049c\u0001\u0000\u0000\u0000\u049c\u049d\u0005:\u0000\u0000"+
|
|
"\u049d\u04b9\u0005?\u0000\u0000\u049e\u049f\u00038\u001c\u0000\u049f\u04a1"+
|
|
"\u0005A\u0000\u0000\u04a0\u04a2\u0003(\u0014\u0000\u04a1\u04a0\u0001\u0000"+
|
|
"\u0000\u0000\u04a1\u04a2\u0001\u0000\u0000\u0000\u04a2\u04a3\u0001\u0000"+
|
|
"\u0000\u0000\u04a3\u04a4\u0005(\u0000\u0000\u04a4\u04a6\u00059\u0000\u0000"+
|
|
"\u04a5\u04a7\u0003\u018c\u00c6\u0000\u04a6\u04a5\u0001\u0000\u0000\u0000"+
|
|
"\u04a6\u04a7\u0001\u0000\u0000\u0000\u04a7\u04a8\u0001\u0000\u0000\u0000"+
|
|
"\u04a8\u04a9\u0005:\u0000\u0000\u04a9\u04aa\u0005?\u0000\u0000\u04aa\u04b9"+
|
|
"\u0001\u0000\u0000\u0000\u04ab\u04ac\u0003\u015e\u00af\u0000\u04ac\u04ae"+
|
|
"\u0005A\u0000\u0000\u04ad\u04af\u0003(\u0014\u0000\u04ae\u04ad\u0001\u0000"+
|
|
"\u0000\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af\u04b0\u0001\u0000"+
|
|
"\u0000\u0000\u04b0\u04b1\u0005(\u0000\u0000\u04b1\u04b3\u00059\u0000\u0000"+
|
|
"\u04b2\u04b4\u0003\u018c\u00c6\u0000\u04b3\u04b2\u0001\u0000\u0000\u0000"+
|
|
"\u04b3\u04b4\u0001\u0000\u0000\u0000\u04b4\u04b5\u0001\u0000\u0000\u0000"+
|
|
"\u04b5\u04b6\u0005:\u0000\u0000\u04b6\u04b7\u0005?\u0000\u0000\u04b7\u04b9"+
|
|
"\u0001\u0000\u0000\u0000\u04b8\u048b\u0001\u0000\u0000\u0000\u04b8\u0495"+
|
|
"\u0001\u0000\u0000\u0000\u04b8\u049e\u0001\u0000\u0000\u0000\u04b8\u04ab"+
|
|
"\u0001\u0000\u0000\u0000\u04b9\u00b7\u0001\u0000\u0000\u0000\u04ba\u04bc"+
|
|
"\u0003T*\u0000\u04bb\u04ba\u0001\u0000\u0000\u0000\u04bc\u04bf\u0001\u0000"+
|
|
"\u0000\u0000\u04bd\u04bb\u0001\u0000\u0000\u0000\u04bd\u04be\u0001\u0000"+
|
|
"\u0000\u0000\u04be\u04c0\u0001\u0000\u0000\u0000\u04bf\u04bd\u0001\u0000"+
|
|
"\u0000\u0000\u04c0\u04c1\u0005\u0010\u0000\u0000\u04c1\u04c3\u0005f\u0000"+
|
|
"\u0000\u04c2\u04c4\u0003\\.\u0000\u04c3\u04c2\u0001\u0000\u0000\u0000"+
|
|
"\u04c3\u04c4\u0001\u0000\u0000\u0000\u04c4\u04c5\u0001\u0000\u0000\u0000"+
|
|
"\u04c5\u04c6\u0003\u00ba]\u0000\u04c6\u00b9\u0001\u0000\u0000\u0000\u04c7"+
|
|
"\u04c9\u0005;\u0000\u0000\u04c8\u04ca\u0003\u00bc^\u0000\u04c9\u04c8\u0001"+
|
|
"\u0000\u0000\u0000\u04c9\u04ca\u0001\u0000\u0000\u0000\u04ca\u04cc\u0001"+
|
|
"\u0000\u0000\u0000\u04cb\u04cd\u0005@\u0000\u0000\u04cc\u04cb\u0001\u0000"+
|
|
"\u0000\u0000\u04cc\u04cd\u0001\u0000\u0000\u0000\u04cd\u04cf\u0001\u0000"+
|
|
"\u0000\u0000\u04ce\u04d0\u0003\u00c2a\u0000\u04cf\u04ce\u0001\u0000\u0000"+
|
|
"\u0000\u04cf\u04d0\u0001\u0000\u0000\u0000\u04d0\u04d1\u0001\u0000\u0000"+
|
|
"\u0000\u04d1\u04d2\u0005<\u0000\u0000\u04d2\u00bb\u0001\u0000\u0000\u0000"+
|
|
"\u04d3\u04d8\u0003\u00be_\u0000\u04d4\u04d5\u0005@\u0000\u0000\u04d5\u04d7"+
|
|
"\u0003\u00be_\u0000\u04d6\u04d4\u0001\u0000\u0000\u0000\u04d7\u04da\u0001"+
|
|
"\u0000\u0000\u0000\u04d8\u04d6\u0001\u0000\u0000\u0000\u04d8\u04d9\u0001"+
|
|
"\u0000\u0000\u0000\u04d9\u00bd\u0001\u0000\u0000\u0000\u04da\u04d8\u0001"+
|
|
"\u0000\u0000\u0000\u04db\u04dd\u0003\u00c0`\u0000\u04dc\u04db\u0001\u0000"+
|
|
"\u0000\u0000\u04dd\u04e0\u0001\u0000\u0000\u0000\u04de\u04dc\u0001\u0000"+
|
|
"\u0000\u0000\u04de\u04df\u0001\u0000\u0000\u0000\u04df\u04e1\u0001\u0000"+
|
|
"\u0000\u0000\u04e0\u04de\u0001\u0000\u0000\u0000\u04e1\u04e7\u0005f\u0000"+
|
|
"\u0000\u04e2\u04e4\u00059\u0000\u0000\u04e3\u04e5\u0003\u018c\u00c6\u0000"+
|
|
"\u04e4\u04e3\u0001\u0000\u0000\u0000\u04e4\u04e5\u0001\u0000\u0000\u0000"+
|
|
"\u04e5\u04e6\u0001\u0000\u0000\u0000\u04e6\u04e8\u0005:\u0000\u0000\u04e7"+
|
|
"\u04e2\u0001\u0000\u0000\u0000\u04e7\u04e8\u0001\u0000\u0000\u0000\u04e8"+
|
|
"\u04ea\u0001\u0000\u0000\u0000\u04e9\u04eb\u0003`0\u0000\u04ea\u04e9\u0001"+
|
|
"\u0000\u0000\u0000\u04ea\u04eb\u0001\u0000\u0000\u0000\u04eb\u00bf\u0001"+
|
|
"\u0000\u0000\u0000\u04ec\u04ed\u0003\u00e4r\u0000\u04ed\u00c1\u0001\u0000"+
|
|
"\u0000\u0000\u04ee\u04f2\u0005?\u0000\u0000\u04ef\u04f1\u0003b1\u0000"+
|
|
"\u04f0\u04ef\u0001\u0000\u0000\u0000\u04f1\u04f4\u0001\u0000\u0000\u0000"+
|
|
"\u04f2\u04f0\u0001\u0000\u0000\u0000\u04f2\u04f3\u0001\u0000\u0000\u0000"+
|
|
"\u04f3\u00c3\u0001\u0000\u0000\u0000\u04f4\u04f2\u0001\u0000\u0000\u0000"+
|
|
"\u04f5\u04f8\u0003\u00c6c\u0000\u04f6\u04f8\u0003\u00d8l\u0000\u04f7\u04f5"+
|
|
"\u0001\u0000\u0000\u0000\u04f7\u04f6\u0001\u0000\u0000\u0000\u04f8\u00c5"+
|
|
"\u0001\u0000\u0000\u0000\u04f9\u04fb\u0003\u00c8d\u0000\u04fa\u04f9\u0001"+
|
|
"\u0000\u0000\u0000\u04fb\u04fe\u0001\u0000\u0000\u0000\u04fc\u04fa\u0001"+
|
|
"\u0000\u0000\u0000\u04fc\u04fd\u0001\u0000\u0000\u0000\u04fd\u04ff\u0001"+
|
|
"\u0000\u0000\u0000\u04fe\u04fc\u0001\u0000\u0000\u0000\u04ff\u0500\u0005"+
|
|
"\u001c\u0000\u0000\u0500\u0502\u0005f\u0000\u0000\u0501\u0503\u0003V+"+
|
|
"\u0000\u0502\u0501\u0001\u0000\u0000\u0000\u0502\u0503\u0001\u0000\u0000"+
|
|
"\u0000\u0503\u0505\u0001\u0000\u0000\u0000\u0504\u0506\u0003\u00cae\u0000"+
|
|
"\u0505\u0504\u0001\u0000\u0000\u0000\u0505\u0506\u0001\u0000\u0000\u0000"+
|
|
"\u0506\u0507\u0001\u0000\u0000\u0000\u0507\u0508\u0003\u00ccf\u0000\u0508"+
|
|
"\u00c7\u0001\u0000\u0000\u0000\u0509\u0511\u0003\u00e4r\u0000\u050a\u0511"+
|
|
"\u0005#\u0000\u0000\u050b\u0511\u0005\"\u0000\u0000\u050c\u0511\u0005"+
|
|
"!\u0000\u0000\u050d\u0511\u0005\u0001\u0000\u0000\u050e\u0511\u0005&\u0000"+
|
|
"\u0000\u050f\u0511\u0005\'\u0000\u0000\u0510\u0509\u0001\u0000\u0000\u0000"+
|
|
"\u0510\u050a\u0001\u0000\u0000\u0000\u0510\u050b\u0001\u0000\u0000\u0000"+
|
|
"\u0510\u050c\u0001\u0000\u0000\u0000\u0510\u050d\u0001\u0000\u0000\u0000"+
|
|
"\u0510\u050e\u0001\u0000\u0000\u0000\u0510\u050f\u0001\u0000\u0000\u0000"+
|
|
"\u0511\u00c9\u0001\u0000\u0000\u0000\u0512\u0513\u0005\u0011\u0000\u0000"+
|
|
"\u0513\u0514\u0003^/\u0000\u0514\u00cb\u0001\u0000\u0000\u0000\u0515\u0519"+
|
|
"\u0005;\u0000\u0000\u0516\u0518\u0003\u00ceg\u0000\u0517\u0516\u0001\u0000"+
|
|
"\u0000\u0000\u0518\u051b\u0001\u0000\u0000\u0000\u0519\u0517\u0001\u0000"+
|
|
"\u0000\u0000\u0519\u051a\u0001\u0000\u0000\u0000\u051a\u051c\u0001\u0000"+
|
|
"\u0000\u0000\u051b\u0519\u0001\u0000\u0000\u0000\u051c\u051d\u0005<\u0000"+
|
|
"\u0000\u051d\u00cd\u0001\u0000\u0000\u0000\u051e\u0524\u0003\u00d0h\u0000"+
|
|
"\u051f\u0524\u0003\u00d4j\u0000\u0520\u0524\u0003P(\u0000\u0521\u0524"+
|
|
"\u0003\u00c4b\u0000\u0522\u0524\u0005?\u0000\u0000\u0523\u051e\u0001\u0000"+
|
|
"\u0000\u0000\u0523\u051f\u0001\u0000\u0000\u0000\u0523\u0520\u0001\u0000"+
|
|
"\u0000\u0000\u0523\u0521\u0001\u0000\u0000\u0000\u0523\u0522\u0001\u0000"+
|
|
"\u0000\u0000\u0524\u00cf\u0001\u0000\u0000\u0000\u0525\u0527\u0003\u00d2"+
|
|
"i\u0000\u0526\u0525\u0001\u0000\u0000\u0000\u0527\u052a\u0001\u0000\u0000"+
|
|
"\u0000\u0528\u0526\u0001\u0000\u0000\u0000\u0528\u0529\u0001\u0000\u0000"+
|
|
"\u0000\u0529\u052b\u0001\u0000\u0000\u0000\u052a\u0528\u0001\u0000\u0000"+
|
|
"\u0000\u052b\u052c\u0003r9\u0000\u052c\u052d\u0003j5\u0000\u052d\u052e"+
|
|
"\u0005?\u0000\u0000\u052e\u00d1\u0001\u0000\u0000\u0000\u052f\u0534\u0003"+
|
|
"\u00e4r\u0000\u0530\u0534\u0005#\u0000\u0000\u0531\u0534\u0005&\u0000"+
|
|
"\u0000\u0532\u0534\u0005\u0012\u0000\u0000\u0533\u052f\u0001\u0000\u0000"+
|
|
"\u0000\u0533\u0530\u0001\u0000\u0000\u0000\u0533\u0531\u0001\u0000\u0000"+
|
|
"\u0000\u0533\u0532\u0001\u0000\u0000\u0000\u0534\u00d3\u0001\u0000\u0000"+
|
|
"\u0000\u0535\u0537\u0003\u00d6k\u0000\u0536\u0535\u0001\u0000\u0000\u0000"+
|
|
"\u0537\u053a\u0001\u0000\u0000\u0000\u0538\u0536\u0001\u0000\u0000\u0000"+
|
|
"\u0538\u0539\u0001\u0000\u0000\u0000\u0539\u053b\u0001\u0000\u0000\u0000"+
|
|
"\u053a\u0538\u0001\u0000\u0000\u0000\u053b\u053c\u0003\u008eG\u0000\u053c"+
|
|
"\u053d\u0003\u00a6S\u0000\u053d\u00d5\u0001\u0000\u0000\u0000\u053e\u0545"+
|
|
"\u0003\u00e4r\u0000\u053f\u0545\u0005#\u0000\u0000\u0540\u0545\u0005\u0001"+
|
|
"\u0000\u0000\u0541\u0545\u0005\f\u0000\u0000\u0542\u0545\u0005&\u0000"+
|
|
"\u0000\u0543\u0545\u0005\'\u0000\u0000\u0544\u053e\u0001\u0000\u0000\u0000"+
|
|
"\u0544\u053f\u0001\u0000\u0000\u0000\u0544\u0540\u0001\u0000\u0000\u0000"+
|
|
"\u0544\u0541\u0001\u0000\u0000\u0000\u0544\u0542\u0001\u0000\u0000\u0000"+
|
|
"\u0544\u0543\u0001\u0000\u0000\u0000\u0545\u00d7\u0001\u0000\u0000\u0000"+
|
|
"\u0546\u0548\u0003\u00c8d\u0000\u0547\u0546\u0001\u0000\u0000\u0000\u0548"+
|
|
"\u054b\u0001\u0000\u0000\u0000\u0549\u0547\u0001\u0000\u0000\u0000\u0549"+
|
|
"\u054a\u0001\u0000\u0000\u0000\u054a\u054c\u0001\u0000\u0000\u0000\u054b"+
|
|
"\u0549\u0001\u0000\u0000\u0000\u054c\u054d\u0005g\u0000\u0000\u054d\u054e"+
|
|
"\u0005\u001c\u0000\u0000\u054e\u054f\u0005f\u0000\u0000\u054f\u0550\u0003"+
|
|
"\u00dam\u0000\u0550\u00d9\u0001\u0000\u0000\u0000\u0551\u0555\u0005;\u0000"+
|
|
"\u0000\u0552\u0554\u0003\u00dcn\u0000\u0553\u0552\u0001\u0000\u0000\u0000"+
|
|
"\u0554\u0557\u0001\u0000\u0000\u0000\u0555\u0553\u0001\u0000\u0000\u0000"+
|
|
"\u0555\u0556\u0001\u0000\u0000\u0000\u0556\u0558\u0001\u0000\u0000\u0000"+
|
|
"\u0557\u0555\u0001\u0000\u0000\u0000\u0558\u0559\u0005<\u0000\u0000\u0559"+
|
|
"\u00db\u0001\u0000\u0000\u0000\u055a\u0560\u0003\u00deo\u0000\u055b\u0560"+
|
|
"\u0003\u00d0h\u0000\u055c\u0560\u0003P(\u0000\u055d\u0560\u0003\u00c4"+
|
|
"b\u0000\u055e\u0560\u0005?\u0000\u0000\u055f\u055a\u0001\u0000\u0000\u0000"+
|
|
"\u055f\u055b\u0001\u0000\u0000\u0000\u055f\u055c\u0001\u0000\u0000\u0000"+
|
|
"\u055f\u055d\u0001\u0000\u0000\u0000\u055f\u055e\u0001\u0000\u0000\u0000"+
|
|
"\u0560\u00dd\u0001\u0000\u0000\u0000\u0561\u0563\u0003\u00e0p\u0000\u0562"+
|
|
"\u0561\u0001\u0000\u0000\u0000\u0563\u0566\u0001\u0000\u0000\u0000\u0564"+
|
|
"\u0562\u0001\u0000\u0000\u0000\u0564\u0565\u0001\u0000\u0000\u0000\u0565"+
|
|
"\u0567\u0001\u0000\u0000\u0000\u0566\u0564\u0001\u0000\u0000\u0000\u0567"+
|
|
"\u0568\u0003r9\u0000\u0568\u0569\u0005f\u0000\u0000\u0569\u056a\u0005"+
|
|
"9\u0000\u0000\u056a\u056c\u0005:\u0000\u0000\u056b\u056d\u0003\u001e\u000f"+
|
|
"\u0000\u056c\u056b\u0001\u0000\u0000\u0000\u056c\u056d\u0001\u0000\u0000"+
|
|
"\u0000\u056d\u056f\u0001\u0000\u0000\u0000\u056e\u0570\u0003\u00e2q\u0000"+
|
|
"\u056f\u056e\u0001\u0000\u0000\u0000\u056f\u0570\u0001\u0000\u0000\u0000"+
|
|
"\u0570\u0571\u0001\u0000\u0000\u0000\u0571\u0572\u0005?\u0000\u0000\u0572"+
|
|
"\u00df\u0001\u0000\u0000\u0000\u0573\u0577\u0003\u00e4r\u0000\u0574\u0577"+
|
|
"\u0005#\u0000\u0000\u0575\u0577\u0005\u0001\u0000\u0000\u0576\u0573\u0001"+
|
|
"\u0000\u0000\u0000\u0576\u0574\u0001\u0000\u0000\u0000\u0576\u0575\u0001"+
|
|
"\u0000\u0000\u0000\u0577\u00e1\u0001\u0000\u0000\u0000\u0578\u0579\u0005"+
|
|
"\f\u0000\u0000\u0579\u057a\u0003\u00ecv\u0000\u057a\u00e3\u0001\u0000"+
|
|
"\u0000\u0000\u057b\u057f\u0003\u00e6s\u0000\u057c\u057f\u0003\u00f2y\u0000"+
|
|
"\u057d\u057f\u0003\u00f4z\u0000\u057e\u057b\u0001\u0000\u0000\u0000\u057e"+
|
|
"\u057c\u0001\u0000\u0000\u0000\u057e\u057d\u0001\u0000\u0000\u0000\u057f"+
|
|
"\u00e5\u0001\u0000\u0000\u0000\u0580\u0581\u0005g\u0000\u0000\u0581\u0582"+
|
|
"\u00034\u001a\u0000\u0582\u0584\u00059\u0000\u0000\u0583\u0585\u0003\u00e8"+
|
|
"t\u0000\u0584\u0583\u0001\u0000\u0000\u0000\u0584\u0585\u0001\u0000\u0000"+
|
|
"\u0000\u0585\u0586\u0001\u0000\u0000\u0000\u0586\u0587\u0005:\u0000\u0000"+
|
|
"\u0587\u00e7\u0001\u0000\u0000\u0000\u0588\u058d\u0003\u00eau\u0000\u0589"+
|
|
"\u058a\u0005@\u0000\u0000\u058a\u058c\u0003\u00eau\u0000\u058b\u0589\u0001"+
|
|
"\u0000\u0000\u0000\u058c\u058f\u0001\u0000\u0000\u0000\u058d\u058b\u0001"+
|
|
"\u0000\u0000\u0000\u058d\u058e\u0001\u0000\u0000\u0000\u058e\u00e9\u0001"+
|
|
"\u0000\u0000\u0000\u058f\u058d\u0001\u0000\u0000\u0000\u0590\u0591\u0005"+
|
|
"f\u0000\u0000\u0591\u0592\u0005B\u0000\u0000\u0592\u0593\u0003\u00ecv"+
|
|
"\u0000\u0593\u00eb\u0001\u0000\u0000\u0000\u0594\u0598\u0003\u01ae\u00d7"+
|
|
"\u0000\u0595\u0598\u0003\u00eew\u0000\u0596\u0598\u0003\u00e4r\u0000\u0597"+
|
|
"\u0594\u0001\u0000\u0000\u0000\u0597\u0595\u0001\u0000\u0000\u0000\u0597"+
|
|
"\u0596\u0001\u0000\u0000\u0000\u0598\u00ed\u0001\u0000\u0000\u0000\u0599"+
|
|
"\u059b\u0005;\u0000\u0000\u059a\u059c\u0003\u00f0x\u0000\u059b\u059a\u0001"+
|
|
"\u0000\u0000\u0000\u059b\u059c\u0001\u0000\u0000\u0000\u059c\u059e\u0001"+
|
|
"\u0000\u0000\u0000\u059d\u059f\u0005@\u0000\u0000\u059e\u059d\u0001\u0000"+
|
|
"\u0000\u0000\u059e\u059f\u0001\u0000\u0000\u0000\u059f\u05a0\u0001\u0000"+
|
|
"\u0000\u0000\u05a0\u05a1\u0005<\u0000\u0000\u05a1\u00ef\u0001\u0000\u0000"+
|
|
"\u0000\u05a2\u05a7\u0003\u00ecv\u0000\u05a3\u05a4\u0005@\u0000\u0000\u05a4"+
|
|
"\u05a6\u0003\u00ecv\u0000\u05a5\u05a3\u0001\u0000\u0000\u0000\u05a6\u05a9"+
|
|
"\u0001\u0000\u0000\u0000\u05a7\u05a5\u0001\u0000\u0000\u0000\u05a7\u05a8"+
|
|
"\u0001\u0000\u0000\u0000\u05a8\u00f1\u0001\u0000\u0000\u0000\u05a9\u05a7"+
|
|
"\u0001\u0000\u0000\u0000\u05aa\u05ab\u0005g\u0000\u0000\u05ab\u05ac\u0003"+
|
|
"4\u001a\u0000\u05ac\u00f3\u0001\u0000\u0000\u0000\u05ad\u05ae\u0005g\u0000"+
|
|
"\u0000\u05ae\u05af\u00034\u001a\u0000\u05af\u05b0\u00059\u0000\u0000\u05b0"+
|
|
"\u05b1\u0003\u00ecv\u0000\u05b1\u05b2\u0005:\u0000\u0000\u05b2\u00f5\u0001"+
|
|
"\u0000\u0000\u0000\u05b3\u05b5\u0005;\u0000\u0000\u05b4\u05b6\u0003\u00f8"+
|
|
"|\u0000\u05b5\u05b4\u0001\u0000\u0000\u0000\u05b5\u05b6\u0001\u0000\u0000"+
|
|
"\u0000\u05b6\u05b8\u0001\u0000\u0000\u0000\u05b7\u05b9\u0005@\u0000\u0000"+
|
|
"\u05b8\u05b7\u0001\u0000\u0000\u0000\u05b8\u05b9\u0001\u0000\u0000\u0000"+
|
|
"\u05b9\u05ba\u0001\u0000\u0000\u0000\u05ba\u05bb\u0005<\u0000\u0000\u05bb"+
|
|
"\u00f7\u0001\u0000\u0000\u0000\u05bc\u05c1\u0003p8\u0000\u05bd\u05be\u0005"+
|
|
"@\u0000\u0000\u05be\u05c0\u0003p8\u0000\u05bf\u05bd\u0001\u0000\u0000"+
|
|
"\u0000\u05c0\u05c3\u0001\u0000\u0000\u0000\u05c1\u05bf\u0001\u0000\u0000"+
|
|
"\u0000\u05c1\u05c2\u0001\u0000\u0000\u0000\u05c2\u00f9\u0001\u0000\u0000"+
|
|
"\u0000\u05c3\u05c1\u0001\u0000\u0000\u0000\u05c4\u05c6\u0005;\u0000\u0000"+
|
|
"\u05c5\u05c7\u0003\u00fc~\u0000\u05c6\u05c5\u0001\u0000\u0000\u0000\u05c6"+
|
|
"\u05c7\u0001\u0000\u0000\u0000\u05c7\u05c8\u0001\u0000\u0000\u0000\u05c8"+
|
|
"\u05c9\u0005<\u0000\u0000\u05c9\u00fb\u0001\u0000\u0000\u0000\u05ca\u05cc"+
|
|
"\u0003\u00fe\u007f\u0000\u05cb\u05ca\u0001\u0000\u0000\u0000\u05cc\u05cd"+
|
|
"\u0001\u0000\u0000\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000\u05cd\u05ce"+
|
|
"\u0001\u0000\u0000\u0000\u05ce\u00fd\u0001\u0000\u0000\u0000\u05cf\u05d3"+
|
|
"\u0003\u0100\u0080\u0000\u05d0\u05d3\u0003P(\u0000\u05d1\u05d3\u0003\u0104"+
|
|
"\u0082\u0000\u05d2\u05cf\u0001\u0000\u0000\u0000\u05d2\u05d0\u0001\u0000"+
|
|
"\u0000\u0000\u05d2\u05d1\u0001\u0000\u0000\u0000\u05d3\u00ff\u0001\u0000"+
|
|
"\u0000\u0000\u05d4\u05d5\u0003\u0102\u0081\u0000\u05d5\u05d6\u0005?\u0000"+
|
|
"\u0000\u05d6\u0101\u0001\u0000\u0000\u0000\u05d7\u05d9\u0003\u009aM\u0000"+
|
|
"\u05d8\u05d7\u0001\u0000\u0000\u0000\u05d9\u05dc\u0001\u0000\u0000\u0000"+
|
|
"\u05da\u05d8\u0001\u0000\u0000\u0000\u05da\u05db\u0001\u0000\u0000\u0000"+
|
|
"\u05db\u05dd\u0001\u0000\u0000\u0000\u05dc\u05da\u0001\u0000\u0000\u0000"+
|
|
"\u05dd\u05de\u0003r9\u0000\u05de\u05df\u0003j5\u0000\u05df\u0103\u0001"+
|
|
"\u0000\u0000\u0000\u05e0\u05e7\u0003\u0108\u0084\u0000\u05e1\u05e7\u0003"+
|
|
"\u010c\u0086\u0000\u05e2\u05e7\u0003\u0114\u008a\u0000\u05e3\u05e7\u0003"+
|
|
"\u0116\u008b\u0000\u05e4\u05e7\u0003\u0128\u0094\u0000\u05e5\u05e7\u0003"+
|
|
"\u012e\u0097\u0000\u05e6\u05e0\u0001\u0000\u0000\u0000\u05e6\u05e1\u0001"+
|
|
"\u0000\u0000\u0000\u05e6\u05e2\u0001\u0000\u0000\u0000\u05e6\u05e3\u0001"+
|
|
"\u0000\u0000\u0000\u05e6\u05e4\u0001\u0000\u0000\u0000\u05e6\u05e5\u0001"+
|
|
"\u0000\u0000\u0000\u05e7\u0105\u0001\u0000\u0000\u0000\u05e8\u05ee\u0003"+
|
|
"\u0108\u0084\u0000\u05e9\u05ee\u0003\u010e\u0087\u0000\u05ea\u05ee\u0003"+
|
|
"\u0118\u008c\u0000\u05eb\u05ee\u0003\u012a\u0095\u0000\u05ec\u05ee\u0003"+
|
|
"\u0130\u0098\u0000\u05ed\u05e8\u0001\u0000\u0000\u0000\u05ed\u05e9\u0001"+
|
|
"\u0000\u0000\u0000\u05ed\u05ea\u0001\u0000\u0000\u0000\u05ed\u05eb\u0001"+
|
|
"\u0000\u0000\u0000\u05ed\u05ec\u0001\u0000\u0000\u0000\u05ee\u0107\u0001"+
|
|
"\u0000\u0000\u0000\u05ef\u05fc\u0003\u00fa}\u0000\u05f0\u05fc\u0003\u010a"+
|
|
"\u0085\u0000\u05f1\u05fc\u0003\u0110\u0088\u0000\u05f2\u05fc\u0003\u011a"+
|
|
"\u008d\u0000\u05f3\u05fc\u0003\u011c\u008e\u0000\u05f4\u05fc\u0003\u012c"+
|
|
"\u0096\u0000\u05f5\u05fc\u0003\u0140\u00a0\u0000\u05f6\u05fc\u0003\u0142"+
|
|
"\u00a1\u0000\u05f7\u05fc\u0003\u0144\u00a2\u0000\u05f8\u05fc\u0003\u0148"+
|
|
"\u00a4\u0000\u05f9\u05fc\u0003\u0146\u00a3\u0000\u05fa\u05fc\u0003\u014a"+
|
|
"\u00a5\u0000\u05fb\u05ef\u0001\u0000\u0000\u0000\u05fb\u05f0\u0001\u0000"+
|
|
"\u0000\u0000\u05fb\u05f1\u0001\u0000\u0000\u0000\u05fb\u05f2\u0001\u0000"+
|
|
"\u0000\u0000\u05fb\u05f3\u0001\u0000\u0000\u0000\u05fb\u05f4\u0001\u0000"+
|
|
"\u0000\u0000\u05fb\u05f5\u0001\u0000\u0000\u0000\u05fb\u05f6\u0001\u0000"+
|
|
"\u0000\u0000\u05fb\u05f7\u0001\u0000\u0000\u0000\u05fb\u05f8\u0001\u0000"+
|
|
"\u0000\u0000\u05fb\u05f9\u0001\u0000\u0000\u0000\u05fb\u05fa\u0001\u0000"+
|
|
"\u0000\u0000\u05fc\u0109\u0001\u0000\u0000\u0000\u05fd\u05fe\u0005?\u0000"+
|
|
"\u0000\u05fe\u010b\u0001\u0000\u0000\u0000\u05ff\u0600\u0005f\u0000\u0000"+
|
|
"\u0600\u0601\u0005H\u0000\u0000\u0601\u0602\u0003\u0104\u0082\u0000\u0602"+
|
|
"\u010d\u0001\u0000\u0000\u0000\u0603\u0604\u0005f\u0000\u0000\u0604\u0605"+
|
|
"\u0005H\u0000\u0000\u0605\u0606\u0003\u0106\u0083\u0000\u0606\u010f\u0001"+
|
|
"\u0000\u0000\u0000\u0607\u0608\u0003\u0112\u0089\u0000\u0608\u0609\u0005"+
|
|
"?\u0000\u0000\u0609\u0111\u0001\u0000\u0000\u0000\u060a\u0612\u0003\u01a8"+
|
|
"\u00d4\u0000\u060b\u0612\u0003\u01c6\u00e3\u0000\u060c\u0612\u0003\u01c8"+
|
|
"\u00e4\u0000\u060d\u0612\u0003\u01ce\u00e7\u0000\u060e\u0612\u0003\u01d2"+
|
|
"\u00e9\u0000\u060f\u0612\u0003\u0186\u00c3\u0000\u0610\u0612\u0003\u0172"+
|
|
"\u00b9\u0000\u0611\u060a\u0001\u0000\u0000\u0000\u0611\u060b\u0001\u0000"+
|
|
"\u0000\u0000\u0611\u060c\u0001\u0000\u0000\u0000\u0611\u060d\u0001\u0000"+
|
|
"\u0000\u0000\u0611\u060e\u0001\u0000\u0000\u0000\u0611\u060f\u0001\u0000"+
|
|
"\u0000\u0000\u0611\u0610\u0001\u0000\u0000\u0000\u0612\u0113\u0001\u0000"+
|
|
"\u0000\u0000\u0613\u0614\u0005\u0016\u0000\u0000\u0614\u0615\u00059\u0000"+
|
|
"\u0000\u0615\u0616\u0003\u019c\u00ce\u0000\u0616\u0617\u0005:\u0000\u0000"+
|
|
"\u0617\u0618\u0003\u0104\u0082\u0000\u0618\u0115\u0001\u0000\u0000\u0000"+
|
|
"\u0619\u061a\u0005\u0016\u0000\u0000\u061a\u061b\u00059\u0000\u0000\u061b"+
|
|
"\u061c\u0003\u019c\u00ce\u0000\u061c\u061d\u0005:\u0000\u0000\u061d\u061e"+
|
|
"\u0003\u0106\u0083\u0000\u061e\u061f\u0005\u000f\u0000\u0000\u061f\u0620"+
|
|
"\u0003\u0104\u0082\u0000\u0620\u0117\u0001\u0000\u0000\u0000\u0621\u0622"+
|
|
"\u0005\u0016\u0000\u0000\u0622\u0623\u00059\u0000\u0000\u0623\u0624\u0003"+
|
|
"\u019c\u00ce\u0000\u0624\u0625\u0005:\u0000\u0000\u0625\u0626\u0003\u0106"+
|
|
"\u0083\u0000\u0626\u0627\u0005\u000f\u0000\u0000\u0627\u0628\u0003\u0106"+
|
|
"\u0083\u0000\u0628\u0119\u0001\u0000\u0000\u0000\u0629\u062a\u0005\u0002"+
|
|
"\u0000\u0000\u062a\u062b\u0003\u019c\u00ce\u0000\u062b\u062c\u0005?\u0000"+
|
|
"\u0000\u062c\u0634\u0001\u0000\u0000\u0000\u062d\u062e\u0005\u0002\u0000"+
|
|
"\u0000\u062e\u062f\u0003\u019c\u00ce\u0000\u062f\u0630\u0005H\u0000\u0000"+
|
|
"\u0630\u0631\u0003\u019c\u00ce\u0000\u0631\u0632\u0005?\u0000\u0000\u0632"+
|
|
"\u0634\u0001\u0000\u0000\u0000\u0633\u0629\u0001\u0000\u0000\u0000\u0633"+
|
|
"\u062d\u0001\u0000\u0000\u0000\u0634\u011b\u0001\u0000\u0000\u0000\u0635"+
|
|
"\u0636\u0005)\u0000\u0000\u0636\u0637\u00059\u0000\u0000\u0637\u0638\u0003"+
|
|
"\u019c\u00ce\u0000\u0638\u0639\u0005:\u0000\u0000\u0639\u063a\u0003\u011e"+
|
|
"\u008f\u0000\u063a\u011d\u0001\u0000\u0000\u0000\u063b\u063f\u0005;\u0000"+
|
|
"\u0000\u063c\u063e\u0003\u0120\u0090\u0000\u063d\u063c\u0001\u0000\u0000"+
|
|
"\u0000\u063e\u0641\u0001\u0000\u0000\u0000\u063f\u063d\u0001\u0000\u0000"+
|
|
"\u0000\u063f\u0640\u0001\u0000\u0000\u0000\u0640\u0645\u0001\u0000\u0000"+
|
|
"\u0000\u0641\u063f\u0001\u0000\u0000\u0000\u0642\u0644\u0003\u0124\u0092"+
|
|
"\u0000\u0643\u0642\u0001\u0000\u0000\u0000\u0644\u0647\u0001\u0000\u0000"+
|
|
"\u0000\u0645\u0643\u0001\u0000\u0000\u0000\u0645\u0646\u0001\u0000\u0000"+
|
|
"\u0000\u0646\u0648\u0001\u0000\u0000\u0000\u0647\u0645\u0001\u0000\u0000"+
|
|
"\u0000\u0648\u0649\u0005<\u0000\u0000\u0649\u011f\u0001\u0000\u0000\u0000"+
|
|
"\u064a\u064b\u0003\u0122\u0091\u0000\u064b\u064c\u0003\u00fc~\u0000\u064c"+
|
|
"\u0121\u0001\u0000\u0000\u0000\u064d\u0651\u0003\u0124\u0092\u0000\u064e"+
|
|
"\u0650\u0003\u0124\u0092\u0000\u064f\u064e\u0001\u0000\u0000\u0000\u0650"+
|
|
"\u0653\u0001\u0000\u0000\u0000\u0651\u064f\u0001\u0000\u0000\u0000\u0651"+
|
|
"\u0652\u0001\u0000\u0000\u0000\u0652\u0123\u0001\u0000\u0000\u0000\u0653"+
|
|
"\u0651\u0001\u0000\u0000\u0000\u0654\u0655\u0005\u0006\u0000\u0000\u0655"+
|
|
"\u0656\u0003\u019a\u00cd\u0000\u0656\u0657\u0005H\u0000\u0000\u0657\u065f"+
|
|
"\u0001\u0000\u0000\u0000\u0658\u0659\u0005\u0006\u0000\u0000\u0659\u065a"+
|
|
"\u0003\u0126\u0093\u0000\u065a\u065b\u0005H\u0000\u0000\u065b\u065f\u0001"+
|
|
"\u0000\u0000\u0000\u065c\u065d\u0005\f\u0000\u0000\u065d\u065f\u0005H"+
|
|
"\u0000\u0000\u065e\u0654\u0001\u0000\u0000\u0000\u065e\u0658\u0001\u0000"+
|
|
"\u0000\u0000\u065e\u065c\u0001\u0000\u0000\u0000\u065f\u0125\u0001\u0000"+
|
|
"\u0000\u0000\u0660\u0661\u0005f\u0000\u0000\u0661\u0127\u0001\u0000\u0000"+
|
|
"\u0000\u0662\u0663\u00052\u0000\u0000\u0663\u0664\u00059\u0000\u0000\u0664"+
|
|
"\u0665\u0003\u019c\u00ce\u0000\u0665\u0666\u0005:\u0000\u0000\u0666\u0667"+
|
|
"\u0003\u0104\u0082\u0000\u0667\u0129\u0001\u0000\u0000\u0000\u0668\u0669"+
|
|
"\u00052\u0000\u0000\u0669\u066a\u00059\u0000\u0000\u066a\u066b\u0003\u019c"+
|
|
"\u00ce\u0000\u066b\u066c\u0005:\u0000\u0000\u066c\u066d\u0003\u0106\u0083"+
|
|
"\u0000\u066d\u012b\u0001\u0000\u0000\u0000\u066e\u066f\u0005\r\u0000\u0000"+
|
|
"\u066f\u0670\u0003\u0104\u0082\u0000\u0670\u0671\u00052\u0000\u0000\u0671"+
|
|
"\u0672\u00059\u0000\u0000\u0672\u0673\u0003\u019c\u00ce\u0000\u0673\u0674"+
|
|
"\u0005:\u0000\u0000\u0674\u0675\u0005?\u0000\u0000\u0675\u012d\u0001\u0000"+
|
|
"\u0000\u0000\u0676\u0679\u0003\u0132\u0099\u0000\u0677\u0679\u0003\u013c"+
|
|
"\u009e\u0000\u0678\u0676\u0001\u0000\u0000\u0000\u0678\u0677\u0001\u0000"+
|
|
"\u0000\u0000\u0679\u012f\u0001\u0000\u0000\u0000\u067a\u067d\u0003\u0134"+
|
|
"\u009a\u0000\u067b\u067d\u0003\u013e\u009f\u0000\u067c\u067a\u0001\u0000"+
|
|
"\u0000\u0000\u067c\u067b\u0001\u0000\u0000\u0000\u067d\u0131\u0001\u0000"+
|
|
"\u0000\u0000\u067e\u067f\u0005\u0015\u0000\u0000\u067f\u0681\u00059\u0000"+
|
|
"\u0000\u0680\u0682\u0003\u0136\u009b\u0000\u0681\u0680\u0001\u0000\u0000"+
|
|
"\u0000\u0681\u0682\u0001\u0000\u0000\u0000\u0682\u0683\u0001\u0000\u0000"+
|
|
"\u0000\u0683\u0685\u0005?\u0000\u0000\u0684\u0686\u0003\u019c\u00ce\u0000"+
|
|
"\u0685\u0684\u0001\u0000\u0000\u0000\u0685\u0686\u0001\u0000\u0000\u0000"+
|
|
"\u0686\u0687\u0001\u0000\u0000\u0000\u0687\u0689\u0005?\u0000\u0000\u0688"+
|
|
"\u068a\u0003\u0138\u009c\u0000\u0689\u0688\u0001\u0000\u0000\u0000\u0689"+
|
|
"\u068a\u0001\u0000\u0000\u0000\u068a\u068b\u0001\u0000\u0000\u0000\u068b"+
|
|
"\u068c\u0005:\u0000\u0000\u068c\u068d\u0003\u0104\u0082\u0000\u068d\u0133"+
|
|
"\u0001\u0000\u0000\u0000\u068e\u068f\u0005\u0015\u0000\u0000\u068f\u0691"+
|
|
"\u00059\u0000\u0000\u0690\u0692\u0003\u0136\u009b\u0000\u0691\u0690\u0001"+
|
|
"\u0000\u0000\u0000\u0691\u0692\u0001\u0000\u0000\u0000\u0692\u0693\u0001"+
|
|
"\u0000\u0000\u0000\u0693\u0695\u0005?\u0000\u0000\u0694\u0696\u0003\u019c"+
|
|
"\u00ce\u0000\u0695\u0694\u0001\u0000\u0000\u0000\u0695\u0696\u0001\u0000"+
|
|
"\u0000\u0000\u0696\u0697\u0001\u0000\u0000\u0000\u0697\u0699\u0005?\u0000"+
|
|
"\u0000\u0698\u069a\u0003\u0138\u009c\u0000\u0699\u0698\u0001\u0000\u0000"+
|
|
"\u0000\u0699\u069a\u0001\u0000\u0000\u0000\u069a\u069b\u0001\u0000\u0000"+
|
|
"\u0000\u069b\u069c\u0005:\u0000\u0000\u069c\u069d\u0003\u0106\u0083\u0000"+
|
|
"\u069d\u0135\u0001\u0000\u0000\u0000\u069e\u06a1\u0003\u013a\u009d\u0000"+
|
|
"\u069f\u06a1\u0003\u0102\u0081\u0000\u06a0\u069e\u0001\u0000\u0000\u0000"+
|
|
"\u06a0\u069f\u0001\u0000\u0000\u0000\u06a1\u0137\u0001\u0000\u0000\u0000"+
|
|
"\u06a2\u06a3\u0003\u013a\u009d\u0000\u06a3\u0139\u0001\u0000\u0000\u0000"+
|
|
"\u06a4\u06a9\u0003\u0112\u0089\u0000\u06a5\u06a6\u0005@\u0000\u0000\u06a6"+
|
|
"\u06a8\u0003\u0112\u0089\u0000\u06a7\u06a5\u0001\u0000\u0000\u0000\u06a8"+
|
|
"\u06ab\u0001\u0000\u0000\u0000\u06a9\u06a7\u0001\u0000\u0000\u0000\u06a9"+
|
|
"\u06aa\u0001\u0000\u0000\u0000\u06aa\u013b\u0001\u0000\u0000\u0000\u06ab"+
|
|
"\u06a9\u0001\u0000\u0000\u0000\u06ac\u06ad\u0005\u0015\u0000\u0000\u06ad"+
|
|
"\u06b1\u00059\u0000\u0000\u06ae\u06b0\u0003\u009aM\u0000\u06af\u06ae\u0001"+
|
|
"\u0000\u0000\u0000\u06b0\u06b3\u0001\u0000\u0000\u0000\u06b1\u06af\u0001"+
|
|
"\u0000\u0000\u0000\u06b1\u06b2\u0001\u0000\u0000\u0000\u06b2\u06b4\u0001"+
|
|
"\u0000\u0000\u0000\u06b3\u06b1\u0001\u0000\u0000\u0000\u06b4\u06b5\u0003"+
|
|
"r9\u0000\u06b5\u06b6\u0003n7\u0000\u06b6\u06b7\u0005H\u0000\u0000\u06b7"+
|
|
"\u06b8\u0003\u019c\u00ce\u0000\u06b8\u06b9\u0005:\u0000\u0000\u06b9\u06ba"+
|
|
"\u0003\u0104\u0082\u0000\u06ba\u013d\u0001\u0000\u0000\u0000\u06bb\u06bc"+
|
|
"\u0005\u0015\u0000\u0000\u06bc\u06c0\u00059\u0000\u0000\u06bd\u06bf\u0003"+
|
|
"\u009aM\u0000\u06be\u06bd\u0001\u0000\u0000\u0000\u06bf\u06c2\u0001\u0000"+
|
|
"\u0000\u0000\u06c0\u06be\u0001\u0000\u0000\u0000\u06c0\u06c1\u0001\u0000"+
|
|
"\u0000\u0000\u06c1\u06c3\u0001\u0000\u0000\u0000\u06c2\u06c0\u0001\u0000"+
|
|
"\u0000\u0000\u06c3\u06c4\u0003r9\u0000\u06c4\u06c5\u0003n7\u0000\u06c5"+
|
|
"\u06c6\u0005H\u0000\u0000\u06c6\u06c7\u0003\u019c\u00ce\u0000\u06c7\u06c8"+
|
|
"\u0005:\u0000\u0000\u06c8\u06c9\u0003\u0106\u0083\u0000\u06c9\u013f\u0001"+
|
|
"\u0000\u0000\u0000\u06ca\u06cc\u0005\u0004\u0000\u0000\u06cb\u06cd\u0005"+
|
|
"f\u0000\u0000\u06cc\u06cb\u0001\u0000\u0000\u0000\u06cc\u06cd\u0001\u0000"+
|
|
"\u0000\u0000\u06cd\u06ce\u0001\u0000\u0000\u0000\u06ce\u06cf\u0005?\u0000"+
|
|
"\u0000\u06cf\u0141\u0001\u0000\u0000\u0000\u06d0\u06d2\u0005\u000b\u0000"+
|
|
"\u0000\u06d1\u06d3\u0005f\u0000\u0000\u06d2\u06d1\u0001\u0000\u0000\u0000"+
|
|
"\u06d2\u06d3\u0001\u0000\u0000\u0000\u06d3\u06d4\u0001\u0000\u0000\u0000"+
|
|
"\u06d4\u06d5\u0005?\u0000\u0000\u06d5\u0143\u0001\u0000\u0000\u0000\u06d6"+
|
|
"\u06d8\u0005$\u0000\u0000\u06d7\u06d9\u0003\u019c\u00ce\u0000\u06d8\u06d7"+
|
|
"\u0001\u0000\u0000\u0000\u06d8\u06d9\u0001\u0000\u0000\u0000\u06d9\u06da"+
|
|
"\u0001\u0000\u0000\u0000\u06da\u06db\u0005?\u0000\u0000\u06db\u0145\u0001"+
|
|
"\u0000\u0000\u0000\u06dc\u06dd\u0005,\u0000\u0000\u06dd\u06de\u0003\u019c"+
|
|
"\u00ce\u0000\u06de\u06df\u0005?\u0000\u0000\u06df\u0147\u0001\u0000\u0000"+
|
|
"\u0000\u06e0\u06e1\u0005*\u0000\u0000\u06e1\u06e2\u00059\u0000\u0000\u06e2"+
|
|
"\u06e3\u0003\u019c\u00ce\u0000\u06e3\u06e4\u0005:\u0000\u0000\u06e4\u06e5"+
|
|
"\u0003\u00fa}\u0000\u06e5\u0149\u0001\u0000\u0000\u0000\u06e6\u06e7\u0005"+
|
|
"/\u0000\u0000\u06e7\u06e8\u0003\u00fa}\u0000\u06e8\u06e9\u0003\u014c\u00a6"+
|
|
"\u0000\u06e9\u06f3\u0001\u0000\u0000\u0000\u06ea\u06eb\u0005/\u0000\u0000"+
|
|
"\u06eb\u06ed\u0003\u00fa}\u0000\u06ec\u06ee\u0003\u014c\u00a6\u0000\u06ed"+
|
|
"\u06ec\u0001\u0000\u0000\u0000\u06ed\u06ee\u0001\u0000\u0000\u0000\u06ee"+
|
|
"\u06ef\u0001\u0000\u0000\u0000\u06ef\u06f0\u0003\u0154\u00aa\u0000\u06f0"+
|
|
"\u06f3\u0001\u0000\u0000\u0000\u06f1\u06f3\u0003\u0156\u00ab\u0000\u06f2"+
|
|
"\u06e6\u0001\u0000\u0000\u0000\u06f2\u06ea\u0001\u0000\u0000\u0000\u06f2"+
|
|
"\u06f1\u0001\u0000\u0000\u0000\u06f3\u014b\u0001\u0000\u0000\u0000\u06f4"+
|
|
"\u06f8\u0003\u014e\u00a7\u0000\u06f5\u06f7\u0003\u014e\u00a7\u0000\u06f6"+
|
|
"\u06f5\u0001\u0000\u0000\u0000\u06f7\u06fa\u0001\u0000\u0000\u0000\u06f8"+
|
|
"\u06f6\u0001\u0000\u0000\u0000\u06f8\u06f9\u0001\u0000\u0000\u0000\u06f9"+
|
|
"\u014d\u0001\u0000\u0000\u0000\u06fa\u06f8\u0001\u0000\u0000\u0000\u06fb"+
|
|
"\u06fc\u0005\u0007\u0000\u0000\u06fc\u06fd\u00059\u0000\u0000\u06fd\u06fe"+
|
|
"\u0003\u0150\u00a8\u0000\u06fe\u06ff\u0005:\u0000\u0000\u06ff\u0700\u0003"+
|
|
"\u00fa}\u0000\u0700\u014f\u0001\u0000\u0000\u0000\u0701\u0703\u0003\u009a"+
|
|
"M\u0000\u0702\u0701\u0001\u0000\u0000\u0000\u0703\u0706\u0001\u0000\u0000"+
|
|
"\u0000\u0704\u0702\u0001\u0000\u0000\u0000\u0704\u0705\u0001\u0000\u0000"+
|
|
"\u0000\u0705\u0707\u0001\u0000\u0000\u0000\u0706\u0704\u0001\u0000\u0000"+
|
|
"\u0000\u0707\u0708\u0003\u0152\u00a9\u0000\u0708\u0709\u0003n7\u0000\u0709"+
|
|
"\u0151\u0001\u0000\u0000\u0000\u070a\u070f\u0003z=\u0000\u070b\u070c\u0005"+
|
|
"V\u0000\u0000\u070c\u070e\u0003\u000e\u0007\u0000\u070d\u070b\u0001\u0000"+
|
|
"\u0000\u0000\u070e\u0711\u0001\u0000\u0000\u0000\u070f\u070d\u0001\u0000"+
|
|
"\u0000\u0000\u070f\u0710\u0001\u0000\u0000\u0000\u0710\u0153\u0001\u0000"+
|
|
"\u0000\u0000\u0711\u070f\u0001\u0000\u0000\u0000\u0712\u0713\u0005\u0013"+
|
|
"\u0000\u0000\u0713\u0714\u0003\u00fa}\u0000\u0714\u0155\u0001\u0000\u0000"+
|
|
"\u0000\u0715\u0716\u0005/\u0000\u0000\u0716\u0717\u0003\u0158\u00ac\u0000"+
|
|
"\u0717\u0719\u0003\u00fa}\u0000\u0718\u071a\u0003\u014c\u00a6\u0000\u0719"+
|
|
"\u0718\u0001\u0000\u0000\u0000\u0719\u071a\u0001\u0000\u0000\u0000\u071a"+
|
|
"\u071c\u0001\u0000\u0000\u0000\u071b\u071d\u0003\u0154\u00aa\u0000\u071c"+
|
|
"\u071b\u0001\u0000\u0000\u0000\u071c\u071d\u0001\u0000\u0000\u0000\u071d"+
|
|
"\u0157\u0001\u0000\u0000\u0000\u071e\u071f\u00059\u0000\u0000\u071f\u0721"+
|
|
"\u0003\u015a\u00ad\u0000\u0720\u0722\u0005?\u0000\u0000\u0721\u0720\u0001"+
|
|
"\u0000\u0000\u0000\u0721\u0722\u0001\u0000\u0000\u0000\u0722\u0723\u0001"+
|
|
"\u0000\u0000\u0000\u0723\u0724\u0005:\u0000\u0000\u0724\u0159\u0001\u0000"+
|
|
"\u0000\u0000\u0725\u072a\u0003\u015c\u00ae\u0000\u0726\u0727\u0005?\u0000"+
|
|
"\u0000\u0727\u0729\u0003\u015c\u00ae\u0000\u0728\u0726\u0001\u0000\u0000"+
|
|
"\u0000\u0729\u072c\u0001\u0000\u0000\u0000\u072a\u0728\u0001\u0000\u0000"+
|
|
"\u0000\u072a\u072b\u0001\u0000\u0000\u0000\u072b\u015b\u0001\u0000\u0000"+
|
|
"\u0000\u072c\u072a\u0001\u0000\u0000\u0000\u072d\u072f\u0003\u009aM\u0000"+
|
|
"\u072e\u072d\u0001\u0000\u0000\u0000\u072f\u0732\u0001\u0000\u0000\u0000"+
|
|
"\u0730\u072e\u0001\u0000\u0000\u0000\u0730\u0731\u0001\u0000\u0000\u0000"+
|
|
"\u0731\u0733\u0001\u0000\u0000\u0000\u0732\u0730\u0001\u0000\u0000\u0000"+
|
|
"\u0733\u0734\u0003r9\u0000\u0734\u0735\u0003n7\u0000\u0735\u0736\u0005"+
|
|
"B\u0000\u0000\u0736\u0737\u0003\u019c\u00ce\u0000\u0737\u015d\u0001\u0000"+
|
|
"\u0000\u0000\u0738\u073b\u0003\u016c\u00b6\u0000\u0739\u073b\u0003\u0194"+
|
|
"\u00ca\u0000\u073a\u0738\u0001\u0000\u0000\u0000\u073a\u0739\u0001\u0000"+
|
|
"\u0000\u0000\u073b\u073f\u0001\u0000\u0000\u0000\u073c\u073e\u0003\u0166"+
|
|
"\u00b3\u0000\u073d\u073c\u0001\u0000\u0000\u0000\u073e\u0741\u0001\u0000"+
|
|
"\u0000\u0000\u073f\u073d\u0001\u0000\u0000\u0000\u073f\u0740\u0001\u0000"+
|
|
"\u0000\u0000\u0740\u015f\u0001\u0000\u0000\u0000\u0741\u073f\u0001\u0000"+
|
|
"\u0000\u0000\u0742\u0760\u0003\u0000\u0000\u0000\u0743\u0748\u00034\u001a"+
|
|
"\u0000\u0744\u0745\u0005=\u0000\u0000\u0745\u0747\u0005>\u0000\u0000\u0746"+
|
|
"\u0744\u0001\u0000\u0000\u0000\u0747\u074a\u0001\u0000\u0000\u0000\u0748"+
|
|
"\u0746\u0001\u0000\u0000\u0000\u0748\u0749\u0001\u0000\u0000\u0000\u0749"+
|
|
"\u074b\u0001\u0000\u0000\u0000\u074a\u0748\u0001\u0000\u0000\u0000\u074b"+
|
|
"\u074c\u0005A\u0000\u0000\u074c\u074d\u0005\t\u0000\u0000\u074d\u0760"+
|
|
"\u0001\u0000\u0000\u0000\u074e\u074f\u00050\u0000\u0000\u074f\u0750\u0005"+
|
|
"A\u0000\u0000\u0750\u0760\u0005\t\u0000\u0000\u0751\u0760\u0005+\u0000"+
|
|
"\u0000\u0752\u0753\u00034\u001a\u0000\u0753\u0754\u0005A\u0000\u0000\u0754"+
|
|
"\u0755\u0005+\u0000\u0000\u0755\u0760\u0001\u0000\u0000\u0000\u0756\u0757"+
|
|
"\u00059\u0000\u0000\u0757\u0758\u0003\u019c\u00ce\u0000\u0758\u0759\u0005"+
|
|
":\u0000\u0000\u0759\u0760\u0001\u0000\u0000\u0000\u075a\u0760\u0003\u0172"+
|
|
"\u00b9\u0000\u075b\u0760\u0003\u017a\u00bd\u0000\u075c\u0760\u0003\u0180"+
|
|
"\u00c0\u0000\u075d\u0760\u0003\u0186\u00c3\u0000\u075e\u0760\u0003\u018e"+
|
|
"\u00c7\u0000\u075f\u0742\u0001\u0000\u0000\u0000\u075f\u0743\u0001\u0000"+
|
|
"\u0000\u0000\u075f\u074e\u0001\u0000\u0000\u0000\u075f\u0751\u0001\u0000"+
|
|
"\u0000\u0000\u075f\u0752\u0001\u0000\u0000\u0000\u075f\u0756\u0001\u0000"+
|
|
"\u0000\u0000\u075f\u075a\u0001\u0000\u0000\u0000\u075f\u075b\u0001\u0000"+
|
|
"\u0000\u0000\u075f\u075c\u0001\u0000\u0000\u0000\u075f\u075d\u0001\u0000"+
|
|
"\u0000\u0000\u075f\u075e\u0001\u0000\u0000\u0000\u0760\u0161\u0001\u0000"+
|
|
"\u0000\u0000\u0761\u0762\u0001\u0000\u0000\u0000\u0762\u0163\u0001\u0000"+
|
|
"\u0000\u0000\u0763\u0780\u0003\u0000\u0000\u0000\u0764\u0769\u00034\u001a"+
|
|
"\u0000\u0765\u0766\u0005=\u0000\u0000\u0766\u0768\u0005>\u0000\u0000\u0767"+
|
|
"\u0765\u0001\u0000\u0000\u0000\u0768\u076b\u0001\u0000\u0000\u0000\u0769"+
|
|
"\u0767\u0001\u0000\u0000\u0000\u0769\u076a\u0001\u0000\u0000\u0000\u076a"+
|
|
"\u076c\u0001\u0000\u0000\u0000\u076b\u0769\u0001\u0000\u0000\u0000\u076c"+
|
|
"\u076d\u0005A\u0000\u0000\u076d\u076e\u0005\t\u0000\u0000\u076e\u0780"+
|
|
"\u0001\u0000\u0000\u0000\u076f\u0770\u00050\u0000\u0000\u0770\u0771\u0005"+
|
|
"A\u0000\u0000\u0771\u0780\u0005\t\u0000\u0000\u0772\u0780\u0005+\u0000"+
|
|
"\u0000\u0773\u0774\u00034\u001a\u0000\u0774\u0775\u0005A\u0000\u0000\u0775"+
|
|
"\u0776\u0005+\u0000\u0000\u0776\u0780\u0001\u0000\u0000\u0000\u0777\u0778"+
|
|
"\u00059\u0000\u0000\u0778\u0779\u0003\u019c\u00ce\u0000\u0779\u077a\u0005"+
|
|
":\u0000\u0000\u077a\u0780\u0001\u0000\u0000\u0000\u077b\u0780\u0003\u0172"+
|
|
"\u00b9\u0000\u077c\u0780\u0003\u017a\u00bd\u0000\u077d\u0780\u0003\u0186"+
|
|
"\u00c3\u0000\u077e\u0780\u0003\u018e\u00c7\u0000\u077f\u0763\u0001\u0000"+
|
|
"\u0000\u0000\u077f\u0764\u0001\u0000\u0000\u0000\u077f\u076f\u0001\u0000"+
|
|
"\u0000\u0000\u077f\u0772\u0001\u0000\u0000\u0000\u077f\u0773\u0001\u0000"+
|
|
"\u0000\u0000\u077f\u0777\u0001\u0000\u0000\u0000\u077f\u077b\u0001\u0000"+
|
|
"\u0000\u0000\u077f\u077c\u0001\u0000\u0000\u0000\u077f\u077d\u0001\u0000"+
|
|
"\u0000\u0000\u077f\u077e\u0001\u0000\u0000\u0000\u0780\u0165\u0001\u0000"+
|
|
"\u0000\u0000\u0781\u0787\u0003\u0174\u00ba\u0000\u0782\u0787\u0003\u017c"+
|
|
"\u00be\u0000\u0783\u0787\u0003\u0182\u00c1\u0000\u0784\u0787\u0003\u0188"+
|
|
"\u00c4\u0000\u0785\u0787\u0003\u0190\u00c8\u0000\u0786\u0781\u0001\u0000"+
|
|
"\u0000\u0000\u0786\u0782\u0001\u0000\u0000\u0000\u0786\u0783\u0001\u0000"+
|
|
"\u0000\u0000\u0786\u0784\u0001\u0000\u0000\u0000\u0786\u0785\u0001\u0000"+
|
|
"\u0000\u0000\u0787\u0167\u0001\u0000\u0000\u0000\u0788\u0789\u0001\u0000"+
|
|
"\u0000\u0000\u0789\u0169\u0001\u0000\u0000\u0000\u078a\u078f\u0003\u0174"+
|
|
"\u00ba\u0000\u078b\u078f\u0003\u017c\u00be\u0000\u078c\u078f\u0003\u0188"+
|
|
"\u00c4\u0000\u078d\u078f\u0003\u0190\u00c8\u0000\u078e\u078a\u0001\u0000"+
|
|
"\u0000\u0000\u078e\u078b\u0001\u0000\u0000\u0000\u078e\u078c\u0001\u0000"+
|
|
"\u0000\u0000\u078e\u078d\u0001\u0000\u0000\u0000\u078f\u016b\u0001\u0000"+
|
|
"\u0000\u0000\u0790\u07b9\u0003\u0000\u0000\u0000\u0791\u0796\u00034\u001a"+
|
|
"\u0000\u0792\u0793\u0005=\u0000\u0000\u0793\u0795\u0005>\u0000\u0000\u0794"+
|
|
"\u0792\u0001\u0000\u0000\u0000\u0795\u0798\u0001\u0000\u0000\u0000\u0796"+
|
|
"\u0794\u0001\u0000\u0000\u0000\u0796\u0797\u0001\u0000\u0000\u0000\u0797"+
|
|
"\u0799\u0001\u0000\u0000\u0000\u0798\u0796\u0001\u0000\u0000\u0000\u0799"+
|
|
"\u079a\u0005A\u0000\u0000\u079a\u079b\u0005\t\u0000\u0000\u079b\u07b9"+
|
|
"\u0001\u0000\u0000\u0000\u079c\u07a1\u0003t:\u0000\u079d\u079e\u0005="+
|
|
"\u0000\u0000\u079e\u07a0\u0005>\u0000\u0000\u079f\u079d\u0001\u0000\u0000"+
|
|
"\u0000\u07a0\u07a3\u0001\u0000\u0000\u0000\u07a1\u079f\u0001\u0000\u0000"+
|
|
"\u0000\u07a1\u07a2\u0001\u0000\u0000\u0000\u07a2\u07a4\u0001\u0000\u0000"+
|
|
"\u0000\u07a3\u07a1\u0001\u0000\u0000\u0000\u07a4\u07a5\u0005A\u0000\u0000"+
|
|
"\u07a5\u07a6\u0005\t\u0000\u0000\u07a6\u07b9\u0001\u0000\u0000\u0000\u07a7"+
|
|
"\u07a8\u00050\u0000\u0000\u07a8\u07a9\u0005A\u0000\u0000\u07a9\u07b9\u0005"+
|
|
"\t\u0000\u0000\u07aa\u07b9\u0005+\u0000\u0000\u07ab\u07ac\u00034\u001a"+
|
|
"\u0000\u07ac\u07ad\u0005A\u0000\u0000\u07ad\u07ae\u0005+\u0000\u0000\u07ae"+
|
|
"\u07b9\u0001\u0000\u0000\u0000\u07af\u07b0\u00059\u0000\u0000\u07b0\u07b1"+
|
|
"\u0003\u019c\u00ce\u0000\u07b1\u07b2\u0005:\u0000\u0000\u07b2\u07b9\u0001"+
|
|
"\u0000\u0000\u0000\u07b3\u07b9\u0003\u0176\u00bb\u0000\u07b4\u07b9\u0003"+
|
|
"\u017e\u00bf\u0000\u07b5\u07b9\u0003\u0184\u00c2\u0000\u07b6\u07b9\u0003"+
|
|
"\u018a\u00c5\u0000\u07b7\u07b9\u0003\u0192\u00c9\u0000\u07b8\u0790\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u0791\u0001\u0000\u0000\u0000\u07b8\u079c\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u07a7\u0001\u0000\u0000\u0000\u07b8\u07aa\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u07ab\u0001\u0000\u0000\u0000\u07b8\u07af\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u07b3\u0001\u0000\u0000\u0000\u07b8\u07b4\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u07b5\u0001\u0000\u0000\u0000\u07b8\u07b6\u0001"+
|
|
"\u0000\u0000\u0000\u07b8\u07b7\u0001\u0000\u0000\u0000\u07b9\u016d\u0001"+
|
|
"\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000\u07bb\u016f\u0001"+
|
|
"\u0000\u0000\u0000\u07bc\u07e4\u0003\u0000\u0000\u0000\u07bd\u07c2\u0003"+
|
|
"4\u001a\u0000\u07be\u07bf\u0005=\u0000\u0000\u07bf\u07c1\u0005>\u0000"+
|
|
"\u0000\u07c0\u07be\u0001\u0000\u0000\u0000\u07c1\u07c4\u0001\u0000\u0000"+
|
|
"\u0000\u07c2\u07c0\u0001\u0000\u0000\u0000\u07c2\u07c3\u0001\u0000\u0000"+
|
|
"\u0000\u07c3\u07c5\u0001\u0000\u0000\u0000\u07c4\u07c2\u0001\u0000\u0000"+
|
|
"\u0000\u07c5\u07c6\u0005A\u0000\u0000\u07c6\u07c7\u0005\t\u0000\u0000"+
|
|
"\u07c7\u07e4\u0001\u0000\u0000\u0000\u07c8\u07cd\u0003t:\u0000\u07c9\u07ca"+
|
|
"\u0005=\u0000\u0000\u07ca\u07cc\u0005>\u0000\u0000\u07cb\u07c9\u0001\u0000"+
|
|
"\u0000\u0000\u07cc\u07cf\u0001\u0000\u0000\u0000\u07cd\u07cb\u0001\u0000"+
|
|
"\u0000\u0000\u07cd\u07ce\u0001\u0000\u0000\u0000\u07ce\u07d0\u0001\u0000"+
|
|
"\u0000\u0000\u07cf\u07cd\u0001\u0000\u0000\u0000\u07d0\u07d1\u0005A\u0000"+
|
|
"\u0000\u07d1\u07d2\u0005\t\u0000\u0000\u07d2\u07e4\u0001\u0000\u0000\u0000"+
|
|
"\u07d3\u07d4\u00050\u0000\u0000\u07d4\u07d5\u0005A\u0000\u0000\u07d5\u07e4"+
|
|
"\u0005\t\u0000\u0000\u07d6\u07e4\u0005+\u0000\u0000\u07d7\u07d8\u0003"+
|
|
"4\u001a\u0000\u07d8\u07d9\u0005A\u0000\u0000\u07d9\u07da\u0005+\u0000"+
|
|
"\u0000\u07da\u07e4\u0001\u0000\u0000\u0000\u07db\u07dc\u00059\u0000\u0000"+
|
|
"\u07dc\u07dd\u0003\u019c\u00ce\u0000\u07dd\u07de\u0005:\u0000\u0000\u07de"+
|
|
"\u07e4\u0001\u0000\u0000\u0000\u07df\u07e4\u0003\u0176\u00bb\u0000\u07e0"+
|
|
"\u07e4\u0003\u017e\u00bf\u0000\u07e1\u07e4\u0003\u018a\u00c5\u0000\u07e2"+
|
|
"\u07e4\u0003\u0192\u00c9\u0000\u07e3\u07bc\u0001\u0000\u0000\u0000\u07e3"+
|
|
"\u07bd\u0001\u0000\u0000\u0000\u07e3\u07c8\u0001\u0000\u0000\u0000\u07e3"+
|
|
"\u07d3\u0001\u0000\u0000\u0000\u07e3\u07d6\u0001\u0000\u0000\u0000\u07e3"+
|
|
"\u07d7\u0001\u0000\u0000\u0000\u07e3\u07db\u0001\u0000\u0000\u0000\u07e3"+
|
|
"\u07df\u0001\u0000\u0000\u0000\u07e3\u07e0\u0001\u0000\u0000\u0000\u07e3"+
|
|
"\u07e1\u0001\u0000\u0000\u0000\u07e3\u07e2\u0001\u0000\u0000\u0000\u07e4"+
|
|
"\u0171\u0001\u0000\u0000\u0000\u07e5\u07e7\u0005\u001f\u0000\u0000\u07e6"+
|
|
"\u07e8\u0003(\u0014\u0000\u07e7\u07e6\u0001\u0000\u0000\u0000\u07e7\u07e8"+
|
|
"\u0001\u0000\u0000\u0000\u07e8\u07ec\u0001\u0000\u0000\u0000\u07e9\u07eb"+
|
|
"\u0003\u00e4r\u0000\u07ea\u07e9\u0001\u0000\u0000\u0000\u07eb\u07ee\u0001"+
|
|
"\u0000\u0000\u0000\u07ec\u07ea\u0001\u0000\u0000\u0000\u07ec\u07ed\u0001"+
|
|
"\u0000\u0000\u0000\u07ed\u07ef\u0001\u0000\u0000\u0000\u07ee\u07ec\u0001"+
|
|
"\u0000\u0000\u0000\u07ef\u07fa\u0005f\u0000\u0000\u07f0\u07f4\u0005A\u0000"+
|
|
"\u0000\u07f1\u07f3\u0003\u00e4r\u0000\u07f2\u07f1\u0001\u0000\u0000\u0000"+
|
|
"\u07f3\u07f6\u0001\u0000\u0000\u0000\u07f4\u07f2\u0001\u0000\u0000\u0000"+
|
|
"\u07f4\u07f5\u0001\u0000\u0000\u0000\u07f5\u07f7\u0001\u0000\u0000\u0000"+
|
|
"\u07f6\u07f4\u0001\u0000\u0000\u0000\u07f7\u07f9\u0005f\u0000\u0000\u07f8"+
|
|
"\u07f0\u0001\u0000\u0000\u0000\u07f9\u07fc\u0001\u0000\u0000\u0000\u07fa"+
|
|
"\u07f8\u0001\u0000\u0000\u0000\u07fa\u07fb\u0001\u0000\u0000\u0000\u07fb"+
|
|
"\u07fe\u0001\u0000\u0000\u0000\u07fc\u07fa\u0001\u0000\u0000\u0000\u07fd"+
|
|
"\u07ff\u0003\u0178\u00bc\u0000\u07fe\u07fd\u0001\u0000\u0000\u0000\u07fe"+
|
|
"\u07ff\u0001\u0000\u0000\u0000\u07ff\u0800\u0001\u0000\u0000\u0000\u0800"+
|
|
"\u0802\u00059\u0000\u0000\u0801\u0803\u0003\u018c\u00c6\u0000\u0802\u0801"+
|
|
"\u0001\u0000\u0000\u0000\u0802\u0803\u0001\u0000\u0000\u0000\u0803\u0804"+
|
|
"\u0001\u0000\u0000\u0000\u0804\u0806\u0005:\u0000\u0000\u0805\u0807\u0003"+
|
|
"`0\u0000\u0806\u0805\u0001\u0000\u0000\u0000\u0806\u0807\u0001\u0000\u0000"+
|
|
"\u0000\u0807\u0839\u0001\u0000\u0000\u0000\u0808\u0809\u00038\u001c\u0000"+
|
|
"\u0809\u080a\u0005A\u0000\u0000\u080a\u080c\u0005\u001f\u0000\u0000\u080b"+
|
|
"\u080d\u0003(\u0014\u0000\u080c\u080b\u0001\u0000\u0000\u0000\u080c\u080d"+
|
|
"\u0001\u0000\u0000\u0000\u080d\u0811\u0001\u0000\u0000\u0000\u080e\u0810"+
|
|
"\u0003\u00e4r\u0000\u080f\u080e\u0001\u0000\u0000\u0000\u0810\u0813\u0001"+
|
|
"\u0000\u0000\u0000\u0811\u080f\u0001\u0000\u0000\u0000\u0811\u0812\u0001"+
|
|
"\u0000\u0000\u0000\u0812\u0814\u0001\u0000\u0000\u0000\u0813\u0811\u0001"+
|
|
"\u0000\u0000\u0000\u0814\u0816\u0005f\u0000\u0000\u0815\u0817\u0003\u0178"+
|
|
"\u00bc\u0000\u0816\u0815\u0001\u0000\u0000\u0000\u0816\u0817\u0001\u0000"+
|
|
"\u0000\u0000\u0817\u0818\u0001\u0000\u0000\u0000\u0818\u081a\u00059\u0000"+
|
|
"\u0000\u0819\u081b\u0003\u018c\u00c6\u0000\u081a\u0819\u0001\u0000\u0000"+
|
|
"\u0000\u081a\u081b\u0001\u0000\u0000\u0000\u081b\u081c\u0001\u0000\u0000"+
|
|
"\u0000\u081c\u081e\u0005:\u0000\u0000\u081d\u081f\u0003`0\u0000\u081e"+
|
|
"\u081d\u0001\u0000\u0000\u0000\u081e\u081f\u0001\u0000\u0000\u0000\u081f"+
|
|
"\u0839\u0001\u0000\u0000\u0000\u0820\u0821\u0003\u015e\u00af\u0000\u0821"+
|
|
"\u0822\u0005A\u0000\u0000\u0822\u0824\u0005\u001f\u0000\u0000\u0823\u0825"+
|
|
"\u0003(\u0014\u0000\u0824\u0823\u0001\u0000\u0000\u0000\u0824\u0825\u0001"+
|
|
"\u0000\u0000\u0000\u0825\u0829\u0001\u0000\u0000\u0000\u0826\u0828\u0003"+
|
|
"\u00e4r\u0000\u0827\u0826\u0001\u0000\u0000\u0000\u0828\u082b\u0001\u0000"+
|
|
"\u0000\u0000\u0829\u0827\u0001\u0000\u0000\u0000\u0829\u082a\u0001\u0000"+
|
|
"\u0000\u0000\u082a\u082c\u0001\u0000\u0000\u0000\u082b\u0829\u0001\u0000"+
|
|
"\u0000\u0000\u082c\u082e\u0005f\u0000\u0000\u082d\u082f\u0003\u0178\u00bc"+
|
|
"\u0000\u082e\u082d\u0001\u0000\u0000\u0000\u082e\u082f\u0001\u0000\u0000"+
|
|
"\u0000\u082f\u0830\u0001\u0000\u0000\u0000\u0830\u0832\u00059\u0000\u0000"+
|
|
"\u0831\u0833\u0003\u018c\u00c6\u0000\u0832\u0831\u0001\u0000\u0000\u0000"+
|
|
"\u0832\u0833\u0001\u0000\u0000\u0000\u0833\u0834\u0001\u0000\u0000\u0000"+
|
|
"\u0834\u0836\u0005:\u0000\u0000\u0835\u0837\u0003`0\u0000\u0836\u0835"+
|
|
"\u0001\u0000\u0000\u0000\u0836\u0837\u0001\u0000\u0000\u0000\u0837\u0839"+
|
|
"\u0001\u0000\u0000\u0000\u0838\u07e5\u0001\u0000\u0000\u0000\u0838\u0808"+
|
|
"\u0001\u0000\u0000\u0000\u0838\u0820\u0001\u0000\u0000\u0000\u0839\u0173"+
|
|
"\u0001\u0000\u0000\u0000\u083a\u083b\u0005A\u0000\u0000\u083b\u083d\u0005"+
|
|
"\u001f\u0000\u0000\u083c\u083e\u0003(\u0014\u0000\u083d\u083c\u0001\u0000"+
|
|
"\u0000\u0000\u083d\u083e\u0001\u0000\u0000\u0000\u083e\u0842\u0001\u0000"+
|
|
"\u0000\u0000\u083f\u0841\u0003\u00e4r\u0000\u0840\u083f\u0001\u0000\u0000"+
|
|
"\u0000\u0841\u0844\u0001\u0000\u0000\u0000\u0842\u0840\u0001\u0000\u0000"+
|
|
"\u0000\u0842\u0843\u0001\u0000\u0000\u0000\u0843\u0845\u0001\u0000\u0000"+
|
|
"\u0000\u0844\u0842\u0001\u0000\u0000\u0000\u0845\u0847\u0005f\u0000\u0000"+
|
|
"\u0846\u0848\u0003\u0178\u00bc\u0000\u0847\u0846\u0001\u0000\u0000\u0000"+
|
|
"\u0847\u0848\u0001\u0000\u0000\u0000\u0848\u0849\u0001\u0000\u0000\u0000"+
|
|
"\u0849\u084b\u00059\u0000\u0000\u084a\u084c\u0003\u018c\u00c6\u0000\u084b"+
|
|
"\u084a\u0001\u0000\u0000\u0000\u084b\u084c\u0001\u0000\u0000\u0000\u084c"+
|
|
"\u084d\u0001\u0000\u0000\u0000\u084d\u084f\u0005:\u0000\u0000\u084e\u0850"+
|
|
"\u0003`0\u0000\u084f\u084e\u0001\u0000\u0000\u0000\u084f\u0850\u0001\u0000"+
|
|
"\u0000\u0000\u0850\u0175\u0001\u0000\u0000\u0000\u0851\u0853\u0005\u001f"+
|
|
"\u0000\u0000\u0852\u0854\u0003(\u0014\u0000\u0853\u0852\u0001\u0000\u0000"+
|
|
"\u0000\u0853\u0854\u0001\u0000\u0000\u0000\u0854\u0858\u0001\u0000\u0000"+
|
|
"\u0000\u0855\u0857\u0003\u00e4r\u0000\u0856\u0855\u0001\u0000\u0000\u0000"+
|
|
"\u0857\u085a\u0001\u0000\u0000\u0000\u0858\u0856\u0001\u0000\u0000\u0000"+
|
|
"\u0858\u0859\u0001\u0000\u0000\u0000\u0859\u085b\u0001\u0000\u0000\u0000"+
|
|
"\u085a\u0858\u0001\u0000\u0000\u0000\u085b\u0866\u0005f\u0000\u0000\u085c"+
|
|
"\u0860\u0005A\u0000\u0000\u085d\u085f\u0003\u00e4r\u0000\u085e\u085d\u0001"+
|
|
"\u0000\u0000\u0000\u085f\u0862\u0001\u0000\u0000\u0000\u0860\u085e\u0001"+
|
|
"\u0000\u0000\u0000\u0860\u0861\u0001\u0000\u0000\u0000\u0861\u0863\u0001"+
|
|
"\u0000\u0000\u0000\u0862\u0860\u0001\u0000\u0000\u0000\u0863\u0865\u0005"+
|
|
"f\u0000\u0000\u0864\u085c\u0001\u0000\u0000\u0000\u0865\u0868\u0001\u0000"+
|
|
"\u0000\u0000\u0866\u0864\u0001\u0000\u0000\u0000\u0866\u0867\u0001\u0000"+
|
|
"\u0000\u0000\u0867\u086a\u0001\u0000\u0000\u0000\u0868\u0866\u0001\u0000"+
|
|
"\u0000\u0000\u0869\u086b\u0003\u0178\u00bc\u0000\u086a\u0869\u0001\u0000"+
|
|
"\u0000\u0000\u086a\u086b\u0001\u0000\u0000\u0000\u086b\u086c\u0001\u0000"+
|
|
"\u0000\u0000\u086c\u086e\u00059\u0000\u0000\u086d\u086f\u0003\u018c\u00c6"+
|
|
"\u0000\u086e\u086d\u0001\u0000\u0000\u0000\u086e\u086f\u0001\u0000\u0000"+
|
|
"\u0000\u086f\u0870\u0001\u0000\u0000\u0000\u0870\u0872\u0005:\u0000\u0000"+
|
|
"\u0871\u0873\u0003`0\u0000\u0872\u0871\u0001\u0000\u0000\u0000\u0872\u0873"+
|
|
"\u0001\u0000\u0000\u0000\u0873\u088d\u0001\u0000\u0000\u0000\u0874\u0875"+
|
|
"\u00038\u001c\u0000\u0875\u0876\u0005A\u0000\u0000\u0876\u0878\u0005\u001f"+
|
|
"\u0000\u0000\u0877\u0879\u0003(\u0014\u0000\u0878\u0877\u0001\u0000\u0000"+
|
|
"\u0000\u0878\u0879\u0001\u0000\u0000\u0000\u0879\u087d\u0001\u0000\u0000"+
|
|
"\u0000\u087a\u087c\u0003\u00e4r\u0000\u087b\u087a\u0001\u0000\u0000\u0000"+
|
|
"\u087c\u087f\u0001\u0000\u0000\u0000\u087d\u087b\u0001\u0000\u0000\u0000"+
|
|
"\u087d\u087e\u0001\u0000\u0000\u0000\u087e\u0880\u0001\u0000\u0000\u0000"+
|
|
"\u087f\u087d\u0001\u0000\u0000\u0000\u0880\u0882\u0005f\u0000\u0000\u0881"+
|
|
"\u0883\u0003\u0178\u00bc\u0000\u0882\u0881\u0001\u0000\u0000\u0000\u0882"+
|
|
"\u0883\u0001\u0000\u0000\u0000\u0883\u0884\u0001\u0000\u0000\u0000\u0884"+
|
|
"\u0886\u00059\u0000\u0000\u0885\u0887\u0003\u018c\u00c6\u0000\u0886\u0885"+
|
|
"\u0001\u0000\u0000\u0000\u0886\u0887\u0001\u0000\u0000\u0000\u0887\u0888"+
|
|
"\u0001\u0000\u0000\u0000\u0888\u088a\u0005:\u0000\u0000\u0889\u088b\u0003"+
|
|
"`0\u0000\u088a\u0889\u0001\u0000\u0000\u0000\u088a\u088b\u0001\u0000\u0000"+
|
|
"\u0000\u088b\u088d\u0001\u0000\u0000\u0000\u088c\u0851\u0001\u0000\u0000"+
|
|
"\u0000\u088c\u0874\u0001\u0000\u0000\u0000\u088d\u0177\u0001\u0000\u0000"+
|
|
"\u0000\u088e\u0892\u0003(\u0014\u0000\u088f\u0890\u0005D\u0000\u0000\u0890"+
|
|
"\u0892\u0005C\u0000\u0000\u0891\u088e\u0001\u0000\u0000\u0000\u0891\u088f"+
|
|
"\u0001\u0000\u0000\u0000\u0892\u0179\u0001\u0000\u0000\u0000\u0893\u0894"+
|
|
"\u0003\u015e\u00af\u0000\u0894\u0895\u0005A\u0000\u0000\u0895\u0896\u0005"+
|
|
"f\u0000\u0000\u0896\u08a1\u0001\u0000\u0000\u0000\u0897\u0898\u0005(\u0000"+
|
|
"\u0000\u0898\u0899\u0005A\u0000\u0000\u0899\u08a1\u0005f\u0000\u0000\u089a"+
|
|
"\u089b\u00034\u001a\u0000\u089b\u089c\u0005A\u0000\u0000\u089c\u089d\u0005"+
|
|
"(\u0000\u0000\u089d\u089e\u0005A\u0000\u0000\u089e\u089f\u0005f\u0000"+
|
|
"\u0000\u089f\u08a1\u0001\u0000\u0000\u0000\u08a0\u0893\u0001\u0000\u0000"+
|
|
"\u0000\u08a0\u0897\u0001\u0000\u0000\u0000\u08a0\u089a\u0001\u0000\u0000"+
|
|
"\u0000\u08a1\u017b\u0001\u0000\u0000\u0000\u08a2\u08a3\u0005A\u0000\u0000"+
|
|
"\u08a3\u08a4\u0005f\u0000\u0000\u08a4\u017d\u0001\u0000\u0000\u0000\u08a5"+
|
|
"\u08a6\u0005(\u0000\u0000\u08a6\u08a7\u0005A\u0000\u0000\u08a7\u08af\u0005"+
|
|
"f\u0000\u0000\u08a8\u08a9\u00034\u001a\u0000\u08a9\u08aa\u0005A\u0000"+
|
|
"\u0000\u08aa\u08ab\u0005(\u0000\u0000\u08ab\u08ac\u0005A\u0000\u0000\u08ac"+
|
|
"\u08ad\u0005f\u0000\u0000\u08ad\u08af\u0001\u0000\u0000\u0000\u08ae\u08a5"+
|
|
"\u0001\u0000\u0000\u0000\u08ae\u08a8\u0001\u0000\u0000\u0000\u08af\u017f"+
|
|
"\u0001\u0000\u0000\u0000\u08b0\u08b1\u00038\u001c\u0000\u08b1\u08b2\u0005"+
|
|
"=\u0000\u0000\u08b2\u08b3\u0003\u019c\u00ce\u0000\u08b3\u08b4\u0005>\u0000"+
|
|
"\u0000\u08b4\u08bb\u0001\u0000\u0000\u0000\u08b5\u08b6\u0003\u0164\u00b2"+
|
|
"\u0000\u08b6\u08b7\u0005=\u0000\u0000\u08b7\u08b8\u0003\u019c\u00ce\u0000"+
|
|
"\u08b8\u08b9\u0005>\u0000\u0000\u08b9\u08bb\u0001\u0000\u0000\u0000\u08ba"+
|
|
"\u08b0\u0001\u0000\u0000\u0000\u08ba\u08b5\u0001\u0000\u0000\u0000\u08bb"+
|
|
"\u08c3\u0001\u0000\u0000\u0000\u08bc\u08bd\u0003\u0162\u00b1\u0000\u08bd"+
|
|
"\u08be\u0005=\u0000\u0000\u08be\u08bf\u0003\u019c\u00ce\u0000\u08bf\u08c0"+
|
|
"\u0005>\u0000\u0000\u08c0\u08c2\u0001\u0000\u0000\u0000\u08c1\u08bc\u0001"+
|
|
"\u0000\u0000\u0000\u08c2\u08c5\u0001\u0000\u0000\u0000\u08c3\u08c1\u0001"+
|
|
"\u0000\u0000\u0000\u08c3\u08c4\u0001\u0000\u0000\u0000\u08c4\u0181\u0001"+
|
|
"\u0000\u0000\u0000\u08c5\u08c3\u0001\u0000\u0000\u0000\u08c6\u08c7\u0003"+
|
|
"\u016a\u00b5\u0000\u08c7\u08c8\u0005=\u0000\u0000\u08c8\u08c9\u0003\u019c"+
|
|
"\u00ce\u0000\u08c9\u08d1\u0005>\u0000\u0000\u08ca\u08cb\u0003\u0168\u00b4"+
|
|
"\u0000\u08cb\u08cc\u0005=\u0000\u0000\u08cc\u08cd\u0003\u019c\u00ce\u0000"+
|
|
"\u08cd\u08ce\u0005>\u0000\u0000\u08ce\u08d0\u0001\u0000\u0000\u0000\u08cf"+
|
|
"\u08ca\u0001\u0000\u0000\u0000\u08d0\u08d3\u0001\u0000\u0000\u0000\u08d1"+
|
|
"\u08cf\u0001\u0000\u0000\u0000\u08d1\u08d2\u0001\u0000\u0000\u0000\u08d2"+
|
|
"\u0183\u0001\u0000\u0000\u0000\u08d3\u08d1\u0001\u0000\u0000\u0000\u08d4"+
|
|
"\u08d5\u00038\u001c\u0000\u08d5\u08d6\u0005=\u0000\u0000\u08d6\u08d7\u0003"+
|
|
"\u019c\u00ce\u0000\u08d7\u08d8\u0005>\u0000\u0000\u08d8\u08df\u0001\u0000"+
|
|
"\u0000\u0000\u08d9\u08da\u0003\u0170\u00b8\u0000\u08da\u08db\u0005=\u0000"+
|
|
"\u0000\u08db\u08dc\u0003\u019c\u00ce\u0000\u08dc\u08dd\u0005>\u0000\u0000"+
|
|
"\u08dd\u08df\u0001\u0000\u0000\u0000\u08de\u08d4\u0001\u0000\u0000\u0000"+
|
|
"\u08de\u08d9\u0001\u0000\u0000\u0000\u08df\u08e7\u0001\u0000\u0000\u0000"+
|
|
"\u08e0\u08e1\u0003\u016e\u00b7\u0000\u08e1\u08e2\u0005=\u0000\u0000\u08e2"+
|
|
"\u08e3\u0003\u019c\u00ce\u0000\u08e3\u08e4\u0005>\u0000\u0000\u08e4\u08e6"+
|
|
"\u0001\u0000\u0000\u0000\u08e5\u08e0\u0001\u0000\u0000\u0000\u08e6\u08e9"+
|
|
"\u0001\u0000\u0000\u0000\u08e7\u08e5\u0001\u0000\u0000\u0000\u08e7\u08e8"+
|
|
"\u0001\u0000\u0000\u0000\u08e8\u0185\u0001\u0000\u0000\u0000\u08e9\u08e7"+
|
|
"\u0001\u0000\u0000\u0000\u08ea\u08eb\u0003:\u001d\u0000\u08eb\u08ed\u0005"+
|
|
"9\u0000\u0000\u08ec\u08ee\u0003\u018c\u00c6\u0000\u08ed\u08ec\u0001\u0000"+
|
|
"\u0000\u0000\u08ed\u08ee\u0001\u0000\u0000\u0000\u08ee\u08ef\u0001\u0000"+
|
|
"\u0000\u0000\u08ef\u08f0\u0005:\u0000\u0000\u08f0\u092f\u0001\u0000\u0000"+
|
|
"\u0000\u08f1\u08f2\u00034\u001a\u0000\u08f2\u08f4\u0005A\u0000\u0000\u08f3"+
|
|
"\u08f5\u0003(\u0014\u0000\u08f4\u08f3\u0001\u0000\u0000\u0000\u08f4\u08f5"+
|
|
"\u0001\u0000\u0000\u0000\u08f5\u08f6\u0001\u0000\u0000\u0000\u08f6\u08f7"+
|
|
"\u0005f\u0000\u0000\u08f7\u08f9\u00059\u0000\u0000\u08f8\u08fa\u0003\u018c"+
|
|
"\u00c6\u0000\u08f9\u08f8\u0001\u0000\u0000\u0000\u08f9\u08fa\u0001\u0000"+
|
|
"\u0000\u0000\u08fa\u08fb\u0001\u0000\u0000\u0000\u08fb\u08fc\u0005:\u0000"+
|
|
"\u0000\u08fc\u092f\u0001\u0000\u0000\u0000\u08fd\u08fe\u00038\u001c\u0000"+
|
|
"\u08fe\u0900\u0005A\u0000\u0000\u08ff\u0901\u0003(\u0014\u0000\u0900\u08ff"+
|
|
"\u0001\u0000\u0000\u0000\u0900\u0901\u0001\u0000\u0000\u0000\u0901\u0902"+
|
|
"\u0001\u0000\u0000\u0000\u0902\u0903\u0005f\u0000\u0000\u0903\u0905\u0005"+
|
|
"9\u0000\u0000\u0904\u0906\u0003\u018c\u00c6\u0000\u0905\u0904\u0001\u0000"+
|
|
"\u0000\u0000\u0905\u0906\u0001\u0000\u0000\u0000\u0906\u0907\u0001\u0000"+
|
|
"\u0000\u0000\u0907\u0908\u0005:\u0000\u0000\u0908\u092f\u0001\u0000\u0000"+
|
|
"\u0000\u0909\u090a\u0003\u015e\u00af\u0000\u090a\u090c\u0005A\u0000\u0000"+
|
|
"\u090b\u090d\u0003(\u0014\u0000\u090c\u090b\u0001\u0000\u0000\u0000\u090c"+
|
|
"\u090d\u0001\u0000\u0000\u0000\u090d\u090e\u0001\u0000\u0000\u0000\u090e"+
|
|
"\u090f\u0005f\u0000\u0000\u090f\u0911\u00059\u0000\u0000\u0910\u0912\u0003"+
|
|
"\u018c\u00c6\u0000\u0911\u0910\u0001\u0000\u0000\u0000\u0911\u0912\u0001"+
|
|
"\u0000\u0000\u0000\u0912\u0913\u0001\u0000\u0000\u0000\u0913\u0914\u0005"+
|
|
":\u0000\u0000\u0914\u092f\u0001\u0000\u0000\u0000\u0915\u0916\u0005(\u0000"+
|
|
"\u0000\u0916\u0918\u0005A\u0000\u0000\u0917\u0919\u0003(\u0014\u0000\u0918"+
|
|
"\u0917\u0001\u0000\u0000\u0000\u0918\u0919\u0001\u0000\u0000\u0000\u0919"+
|
|
"\u091a\u0001\u0000\u0000\u0000\u091a\u091b\u0005f\u0000\u0000\u091b\u091d"+
|
|
"\u00059\u0000\u0000\u091c\u091e\u0003\u018c\u00c6\u0000\u091d\u091c\u0001"+
|
|
"\u0000\u0000\u0000\u091d\u091e\u0001\u0000\u0000\u0000\u091e\u091f\u0001"+
|
|
"\u0000\u0000\u0000\u091f\u092f\u0005:\u0000\u0000\u0920\u0921\u00034\u001a"+
|
|
"\u0000\u0921\u0922\u0005A\u0000\u0000\u0922\u0923\u0005(\u0000\u0000\u0923"+
|
|
"\u0925\u0005A\u0000\u0000\u0924\u0926\u0003(\u0014\u0000\u0925\u0924\u0001"+
|
|
"\u0000\u0000\u0000\u0925\u0926\u0001\u0000\u0000\u0000\u0926\u0927\u0001"+
|
|
"\u0000\u0000\u0000\u0927\u0928\u0005f\u0000\u0000\u0928\u092a\u00059\u0000"+
|
|
"\u0000\u0929\u092b\u0003\u018c\u00c6\u0000\u092a\u0929\u0001\u0000\u0000"+
|
|
"\u0000\u092a\u092b\u0001\u0000\u0000\u0000\u092b\u092c\u0001\u0000\u0000"+
|
|
"\u0000\u092c\u092d\u0005:\u0000\u0000\u092d\u092f\u0001\u0000\u0000\u0000"+
|
|
"\u092e\u08ea\u0001\u0000\u0000\u0000\u092e\u08f1\u0001\u0000\u0000\u0000"+
|
|
"\u092e\u08fd\u0001\u0000\u0000\u0000\u092e\u0909\u0001\u0000\u0000\u0000"+
|
|
"\u092e\u0915\u0001\u0000\u0000\u0000\u092e\u0920\u0001\u0000\u0000\u0000"+
|
|
"\u092f\u0187\u0001\u0000\u0000\u0000\u0930\u0932\u0005A\u0000\u0000\u0931"+
|
|
"\u0933\u0003(\u0014\u0000\u0932\u0931\u0001\u0000\u0000\u0000\u0932\u0933"+
|
|
"\u0001\u0000\u0000\u0000\u0933\u0934\u0001\u0000\u0000\u0000\u0934\u0935"+
|
|
"\u0005f\u0000\u0000\u0935\u0937\u00059\u0000\u0000\u0936\u0938\u0003\u018c"+
|
|
"\u00c6\u0000\u0937\u0936\u0001\u0000\u0000\u0000\u0937\u0938\u0001\u0000"+
|
|
"\u0000\u0000\u0938\u0939\u0001\u0000\u0000\u0000\u0939\u093a\u0005:\u0000"+
|
|
"\u0000\u093a\u0189\u0001\u0000\u0000\u0000\u093b\u093c\u0003:\u001d\u0000"+
|
|
"\u093c\u093e\u00059\u0000\u0000\u093d\u093f\u0003\u018c\u00c6\u0000\u093e"+
|
|
"\u093d\u0001\u0000\u0000\u0000\u093e\u093f\u0001\u0000\u0000\u0000\u093f"+
|
|
"\u0940\u0001\u0000\u0000\u0000\u0940\u0941\u0005:\u0000\u0000\u0941\u0974"+
|
|
"\u0001\u0000\u0000\u0000\u0942\u0943\u00034\u001a\u0000\u0943\u0945\u0005"+
|
|
"A\u0000\u0000\u0944\u0946\u0003(\u0014\u0000\u0945\u0944\u0001\u0000\u0000"+
|
|
"\u0000\u0945\u0946\u0001\u0000\u0000\u0000\u0946\u0947\u0001\u0000\u0000"+
|
|
"\u0000\u0947\u0948\u0005f\u0000\u0000\u0948\u094a\u00059\u0000\u0000\u0949"+
|
|
"\u094b\u0003\u018c\u00c6\u0000\u094a\u0949\u0001\u0000\u0000\u0000\u094a"+
|
|
"\u094b\u0001\u0000\u0000\u0000\u094b\u094c\u0001\u0000\u0000\u0000\u094c"+
|
|
"\u094d\u0005:\u0000\u0000\u094d\u0974\u0001\u0000\u0000\u0000\u094e\u094f"+
|
|
"\u00038\u001c\u0000\u094f\u0951\u0005A\u0000\u0000\u0950\u0952\u0003("+
|
|
"\u0014\u0000\u0951\u0950\u0001\u0000\u0000\u0000\u0951\u0952\u0001\u0000"+
|
|
"\u0000\u0000\u0952\u0953\u0001\u0000\u0000\u0000\u0953\u0954\u0005f\u0000"+
|
|
"\u0000\u0954\u0956\u00059\u0000\u0000\u0955\u0957\u0003\u018c\u00c6\u0000"+
|
|
"\u0956\u0955\u0001\u0000\u0000\u0000\u0956\u0957\u0001\u0000\u0000\u0000"+
|
|
"\u0957\u0958\u0001\u0000\u0000\u0000\u0958\u0959\u0005:\u0000\u0000\u0959"+
|
|
"\u0974\u0001\u0000\u0000\u0000\u095a\u095b\u0005(\u0000\u0000\u095b\u095d"+
|
|
"\u0005A\u0000\u0000\u095c\u095e\u0003(\u0014\u0000\u095d\u095c\u0001\u0000"+
|
|
"\u0000\u0000\u095d\u095e\u0001\u0000\u0000\u0000\u095e\u095f\u0001\u0000"+
|
|
"\u0000\u0000\u095f\u0960\u0005f\u0000\u0000\u0960\u0962\u00059\u0000\u0000"+
|
|
"\u0961\u0963\u0003\u018c\u00c6\u0000\u0962\u0961\u0001\u0000\u0000\u0000"+
|
|
"\u0962\u0963\u0001\u0000\u0000\u0000\u0963\u0964\u0001\u0000\u0000\u0000"+
|
|
"\u0964\u0974\u0005:\u0000\u0000\u0965\u0966\u00034\u001a\u0000\u0966\u0967"+
|
|
"\u0005A\u0000\u0000\u0967\u0968\u0005(\u0000\u0000\u0968\u096a\u0005A"+
|
|
"\u0000\u0000\u0969\u096b\u0003(\u0014\u0000\u096a\u0969\u0001\u0000\u0000"+
|
|
"\u0000\u096a\u096b\u0001\u0000\u0000\u0000\u096b\u096c\u0001\u0000\u0000"+
|
|
"\u0000\u096c\u096d\u0005f\u0000\u0000\u096d";
|
|
private static final String _serializedATNSegment1 =
|
|
"\u096f\u00059\u0000\u0000\u096e\u0970\u0003\u018c\u00c6\u0000\u096f\u096e"+
|
|
"\u0001\u0000\u0000\u0000\u096f\u0970\u0001\u0000\u0000\u0000\u0970\u0971"+
|
|
"\u0001\u0000\u0000\u0000\u0971\u0972\u0005:\u0000\u0000\u0972\u0974\u0001"+
|
|
"\u0000\u0000\u0000\u0973\u093b\u0001\u0000\u0000\u0000\u0973\u0942\u0001"+
|
|
"\u0000\u0000\u0000\u0973\u094e\u0001\u0000\u0000\u0000\u0973\u095a\u0001"+
|
|
"\u0000\u0000\u0000\u0973\u0965\u0001\u0000\u0000\u0000\u0974\u018b\u0001"+
|
|
"\u0000\u0000\u0000\u0975\u097a\u0003\u019c\u00ce\u0000\u0976\u0977\u0005"+
|
|
"@\u0000\u0000\u0977\u0979\u0003\u019c\u00ce\u0000\u0978\u0976\u0001\u0000"+
|
|
"\u0000\u0000\u0979\u097c\u0001\u0000\u0000\u0000\u097a\u0978\u0001\u0000"+
|
|
"\u0000\u0000\u097a\u097b\u0001\u0000\u0000\u0000\u097b\u018d\u0001\u0000"+
|
|
"\u0000\u0000\u097c\u097a\u0001\u0000\u0000\u0000\u097d\u097e\u00038\u001c"+
|
|
"\u0000\u097e\u0980\u0005Z\u0000\u0000\u097f\u0981\u0003(\u0014\u0000\u0980"+
|
|
"\u097f\u0001\u0000\u0000\u0000\u0980\u0981\u0001\u0000\u0000\u0000\u0981"+
|
|
"\u0982\u0001\u0000\u0000\u0000\u0982\u0983\u0005f\u0000\u0000\u0983\u09ad"+
|
|
"\u0001\u0000\u0000\u0000\u0984\u0985\u0003\n\u0005\u0000\u0985\u0987\u0005"+
|
|
"Z\u0000\u0000\u0986\u0988\u0003(\u0014\u0000\u0987\u0986\u0001\u0000\u0000"+
|
|
"\u0000\u0987\u0988\u0001\u0000\u0000\u0000\u0988\u0989\u0001\u0000\u0000"+
|
|
"\u0000\u0989\u098a\u0005f\u0000\u0000\u098a\u09ad\u0001\u0000\u0000\u0000"+
|
|
"\u098b\u098c\u0003\u015e\u00af\u0000\u098c\u098e\u0005Z\u0000\u0000\u098d"+
|
|
"\u098f\u0003(\u0014\u0000\u098e\u098d\u0001\u0000\u0000\u0000\u098e\u098f"+
|
|
"\u0001\u0000\u0000\u0000\u098f\u0990\u0001\u0000\u0000\u0000\u0990\u0991"+
|
|
"\u0005f\u0000\u0000\u0991\u09ad\u0001\u0000\u0000\u0000\u0992\u0993\u0005"+
|
|
"(\u0000\u0000\u0993\u0995\u0005Z\u0000\u0000\u0994\u0996\u0003(\u0014"+
|
|
"\u0000\u0995\u0994\u0001\u0000\u0000\u0000\u0995\u0996\u0001\u0000\u0000"+
|
|
"\u0000\u0996\u0997\u0001\u0000\u0000\u0000\u0997\u09ad\u0005f\u0000\u0000"+
|
|
"\u0998\u0999\u00034\u001a\u0000\u0999\u099a\u0005A\u0000\u0000\u099a\u099b"+
|
|
"\u0005(\u0000\u0000\u099b\u099d\u0005Z\u0000\u0000\u099c\u099e\u0003("+
|
|
"\u0014\u0000\u099d\u099c\u0001\u0000\u0000\u0000\u099d\u099e\u0001\u0000"+
|
|
"\u0000\u0000\u099e\u099f\u0001\u0000\u0000\u0000\u099f\u09a0\u0005f\u0000"+
|
|
"\u0000\u09a0\u09ad\u0001\u0000\u0000\u0000\u09a1\u09a2\u0003\u000e\u0007"+
|
|
"\u0000\u09a2\u09a4\u0005Z\u0000\u0000\u09a3\u09a5\u0003(\u0014\u0000\u09a4"+
|
|
"\u09a3\u0001\u0000\u0000\u0000\u09a4\u09a5\u0001\u0000\u0000\u0000\u09a5"+
|
|
"\u09a6\u0001\u0000\u0000\u0000\u09a6\u09a7\u0005\u001f\u0000\u0000\u09a7"+
|
|
"\u09ad\u0001\u0000\u0000\u0000\u09a8\u09a9\u0003\u001c\u000e\u0000\u09a9"+
|
|
"\u09aa\u0005Z\u0000\u0000\u09aa\u09ab\u0005\u001f\u0000\u0000\u09ab\u09ad"+
|
|
"\u0001\u0000\u0000\u0000\u09ac\u097d\u0001\u0000\u0000\u0000\u09ac\u0984"+
|
|
"\u0001\u0000\u0000\u0000\u09ac\u098b\u0001\u0000\u0000\u0000\u09ac\u0992"+
|
|
"\u0001\u0000\u0000\u0000\u09ac\u0998\u0001\u0000\u0000\u0000\u09ac\u09a1"+
|
|
"\u0001\u0000\u0000\u0000\u09ac\u09a8\u0001\u0000\u0000\u0000\u09ad\u018f"+
|
|
"\u0001\u0000\u0000\u0000\u09ae\u09b0\u0005Z\u0000\u0000\u09af\u09b1\u0003"+
|
|
"(\u0014\u0000\u09b0\u09af\u0001\u0000\u0000\u0000\u09b0\u09b1\u0001\u0000"+
|
|
"\u0000\u0000\u09b1\u09b2\u0001\u0000\u0000\u0000\u09b2\u09b3\u0005f\u0000"+
|
|
"\u0000\u09b3\u0191\u0001\u0000\u0000\u0000\u09b4\u09b5\u00038\u001c\u0000"+
|
|
"\u09b5\u09b7\u0005Z\u0000\u0000\u09b6\u09b8\u0003(\u0014\u0000\u09b7\u09b6"+
|
|
"\u0001\u0000\u0000\u0000\u09b7\u09b8\u0001\u0000\u0000\u0000\u09b8\u09b9"+
|
|
"\u0001\u0000\u0000\u0000\u09b9\u09ba\u0005f\u0000\u0000\u09ba\u09dd\u0001"+
|
|
"\u0000\u0000\u0000\u09bb\u09bc\u0003\n\u0005\u0000\u09bc\u09be\u0005Z"+
|
|
"\u0000\u0000\u09bd\u09bf\u0003(\u0014\u0000\u09be\u09bd\u0001\u0000\u0000"+
|
|
"\u0000\u09be\u09bf\u0001\u0000\u0000\u0000\u09bf\u09c0\u0001\u0000\u0000"+
|
|
"\u0000\u09c0\u09c1\u0005f\u0000\u0000\u09c1\u09dd\u0001\u0000\u0000\u0000"+
|
|
"\u09c2\u09c3\u0005(\u0000\u0000\u09c3\u09c5\u0005Z\u0000\u0000\u09c4\u09c6"+
|
|
"\u0003(\u0014\u0000\u09c5\u09c4\u0001\u0000\u0000\u0000\u09c5\u09c6\u0001"+
|
|
"\u0000\u0000\u0000\u09c6\u09c7\u0001\u0000\u0000\u0000\u09c7\u09dd\u0005"+
|
|
"f\u0000\u0000\u09c8\u09c9\u00034\u001a\u0000\u09c9\u09ca\u0005A\u0000"+
|
|
"\u0000\u09ca\u09cb\u0005(\u0000\u0000\u09cb\u09cd\u0005Z\u0000\u0000\u09cc"+
|
|
"\u09ce\u0003(\u0014\u0000\u09cd\u09cc\u0001\u0000\u0000\u0000\u09cd\u09ce"+
|
|
"\u0001\u0000\u0000\u0000\u09ce\u09cf\u0001\u0000\u0000\u0000\u09cf\u09d0"+
|
|
"\u0005f\u0000\u0000\u09d0\u09dd\u0001\u0000\u0000\u0000\u09d1\u09d2\u0003"+
|
|
"\u000e\u0007\u0000\u09d2\u09d4\u0005Z\u0000\u0000\u09d3\u09d5\u0003(\u0014"+
|
|
"\u0000\u09d4\u09d3\u0001\u0000\u0000\u0000\u09d4\u09d5\u0001\u0000\u0000"+
|
|
"\u0000\u09d5\u09d6\u0001\u0000\u0000\u0000\u09d6\u09d7\u0005\u001f\u0000"+
|
|
"\u0000\u09d7\u09dd\u0001\u0000\u0000\u0000\u09d8\u09d9\u0003\u001c\u000e"+
|
|
"\u0000\u09d9\u09da\u0005Z\u0000\u0000\u09da\u09db\u0005\u001f\u0000\u0000"+
|
|
"\u09db\u09dd\u0001\u0000\u0000\u0000\u09dc\u09b4\u0001\u0000\u0000\u0000"+
|
|
"\u09dc\u09bb\u0001\u0000\u0000\u0000\u09dc\u09c2\u0001\u0000\u0000\u0000"+
|
|
"\u09dc\u09c8\u0001\u0000\u0000\u0000\u09dc\u09d1\u0001\u0000\u0000\u0000"+
|
|
"\u09dc\u09d8\u0001\u0000\u0000\u0000\u09dd\u0193\u0001\u0000\u0000\u0000"+
|
|
"\u09de\u09df\u0005\u001f\u0000\u0000\u09df\u09e0\u0003\u0002\u0001\u0000"+
|
|
"\u09e0\u09e2\u0003\u0196\u00cb\u0000\u09e1\u09e3\u0003\u001e\u000f\u0000"+
|
|
"\u09e2\u09e1\u0001\u0000\u0000\u0000\u09e2\u09e3\u0001\u0000\u0000\u0000"+
|
|
"\u09e3\u09f5\u0001\u0000\u0000\u0000\u09e4\u09e5\u0005\u001f\u0000\u0000"+
|
|
"\u09e5\u09e6\u0003\f\u0006\u0000\u09e6\u09e8\u0003\u0196\u00cb\u0000\u09e7"+
|
|
"\u09e9\u0003\u001e\u000f\u0000\u09e8\u09e7\u0001\u0000\u0000\u0000\u09e8"+
|
|
"\u09e9\u0001\u0000\u0000\u0000\u09e9\u09f5\u0001\u0000\u0000\u0000\u09ea"+
|
|
"\u09eb\u0005\u001f\u0000\u0000\u09eb\u09ec\u0003\u0002\u0001\u0000\u09ec"+
|
|
"\u09ed\u0003\u001e\u000f\u0000\u09ed\u09ee\u0003\u00f6{\u0000\u09ee\u09f5"+
|
|
"\u0001\u0000\u0000\u0000\u09ef\u09f0\u0005\u001f\u0000\u0000\u09f0\u09f1"+
|
|
"\u0003\f\u0006\u0000\u09f1\u09f2\u0003\u001e\u000f\u0000\u09f2\u09f3\u0003"+
|
|
"\u00f6{\u0000\u09f3\u09f5\u0001\u0000\u0000\u0000\u09f4\u09de\u0001\u0000"+
|
|
"\u0000\u0000\u09f4\u09e4\u0001\u0000\u0000\u0000\u09f4\u09ea\u0001\u0000"+
|
|
"\u0000\u0000\u09f4\u09ef\u0001\u0000\u0000\u0000\u09f5\u0195\u0001\u0000"+
|
|
"\u0000\u0000\u09f6\u09fa\u0003\u0198\u00cc\u0000\u09f7\u09f9\u0003\u0198"+
|
|
"\u00cc\u0000\u09f8\u09f7\u0001\u0000\u0000\u0000\u09f9\u09fc\u0001\u0000"+
|
|
"\u0000\u0000\u09fa\u09f8\u0001\u0000\u0000\u0000\u09fa\u09fb\u0001\u0000"+
|
|
"\u0000\u0000\u09fb\u0197\u0001\u0000\u0000\u0000\u09fc\u09fa\u0001\u0000"+
|
|
"\u0000\u0000\u09fd\u09ff\u0003\u00e4r\u0000\u09fe\u09fd\u0001\u0000\u0000"+
|
|
"\u0000\u09ff\u0a02\u0001\u0000\u0000\u0000\u0a00\u09fe\u0001\u0000\u0000"+
|
|
"\u0000\u0a00\u0a01\u0001\u0000\u0000\u0000\u0a01\u0a03\u0001\u0000\u0000"+
|
|
"\u0000\u0a02\u0a00\u0001\u0000\u0000\u0000\u0a03\u0a04\u0005=\u0000\u0000"+
|
|
"\u0a04\u0a05\u0003\u019c\u00ce\u0000\u0a05\u0a06\u0005>\u0000\u0000\u0a06"+
|
|
"\u0199\u0001\u0000\u0000\u0000\u0a07\u0a08\u0003\u019c\u00ce\u0000\u0a08"+
|
|
"\u019b\u0001\u0000\u0000\u0000\u0a09\u0a0c\u0003\u019e\u00cf\u0000\u0a0a"+
|
|
"\u0a0c\u0003\u01a6\u00d3\u0000\u0a0b\u0a09\u0001\u0000\u0000\u0000\u0a0b"+
|
|
"\u0a0a\u0001\u0000\u0000\u0000\u0a0c\u019d\u0001\u0000\u0000\u0000\u0a0d"+
|
|
"\u0a0e\u0003\u01a0\u00d0\u0000\u0a0e\u0a0f\u0005Y\u0000\u0000\u0a0f\u0a10"+
|
|
"\u0003\u01a4\u00d2\u0000\u0a10\u019f\u0001\u0000\u0000\u0000\u0a11\u0a1c"+
|
|
"\u0005f\u0000\u0000\u0a12\u0a14\u00059\u0000\u0000\u0a13\u0a15\u0003\u0094"+
|
|
"J\u0000\u0a14\u0a13\u0001\u0000\u0000\u0000\u0a14\u0a15\u0001\u0000\u0000"+
|
|
"\u0000\u0a15\u0a16\u0001\u0000\u0000\u0000\u0a16\u0a1c\u0005:\u0000\u0000"+
|
|
"\u0a17\u0a18\u00059\u0000\u0000\u0a18\u0a19\u0003\u01a2\u00d1\u0000\u0a19"+
|
|
"\u0a1a\u0005:\u0000\u0000\u0a1a\u0a1c\u0001\u0000\u0000\u0000\u0a1b\u0a11"+
|
|
"\u0001\u0000\u0000\u0000\u0a1b\u0a12\u0001\u0000\u0000\u0000\u0a1b\u0a17"+
|
|
"\u0001\u0000\u0000\u0000\u0a1c\u01a1\u0001\u0000\u0000\u0000\u0a1d\u0a22"+
|
|
"\u0005f\u0000\u0000\u0a1e\u0a1f\u0005@\u0000\u0000\u0a1f\u0a21\u0005f"+
|
|
"\u0000\u0000\u0a20\u0a1e\u0001\u0000\u0000\u0000\u0a21\u0a24\u0001\u0000"+
|
|
"\u0000\u0000\u0a22\u0a20\u0001\u0000\u0000\u0000\u0a22\u0a23\u0001\u0000"+
|
|
"\u0000\u0000\u0a23\u01a3\u0001\u0000\u0000\u0000\u0a24\u0a22\u0001\u0000"+
|
|
"\u0000\u0000\u0a25\u0a28\u0003\u019c\u00ce\u0000\u0a26\u0a28\u0003\u00fa"+
|
|
"}\u0000\u0a27\u0a25\u0001\u0000\u0000\u0000\u0a27\u0a26\u0001\u0000\u0000"+
|
|
"\u0000\u0a28\u01a5\u0001\u0000\u0000\u0000\u0a29\u0a2c\u0003\u01ae\u00d7"+
|
|
"\u0000\u0a2a\u0a2c\u0003\u01a8\u00d4\u0000\u0a2b\u0a29\u0001\u0000\u0000"+
|
|
"\u0000\u0a2b\u0a2a\u0001\u0000\u0000\u0000\u0a2c\u01a7\u0001\u0000\u0000"+
|
|
"\u0000\u0a2d\u0a2e\u0003\u01aa\u00d5\u0000\u0a2e\u0a2f\u0003\u01ac\u00d6"+
|
|
"\u0000\u0a2f\u0a30\u0003\u019c\u00ce\u0000\u0a30\u01a9\u0001\u0000\u0000"+
|
|
"\u0000\u0a31\u0a35\u00038\u001c\u0000\u0a32\u0a35\u0003\u017a\u00bd\u0000"+
|
|
"\u0a33\u0a35\u0003\u0180\u00c0\u0000\u0a34\u0a31\u0001\u0000\u0000\u0000"+
|
|
"\u0a34\u0a32\u0001\u0000\u0000\u0000\u0a34\u0a33\u0001\u0000\u0000\u0000"+
|
|
"\u0a35\u01ab\u0001\u0000\u0000\u0000\u0a36\u0a37\u0007\u0003\u0000\u0000"+
|
|
"\u0a37\u01ad\u0001\u0000\u0000\u0000\u0a38\u0a40\u0003\u01b0\u00d8\u0000"+
|
|
"\u0a39\u0a3a\u0003\u01b0\u00d8\u0000\u0a3a\u0a3b\u0005G\u0000\u0000\u0a3b"+
|
|
"\u0a3c\u0003\u019c\u00ce\u0000\u0a3c\u0a3d\u0005H\u0000\u0000\u0a3d\u0a3e"+
|
|
"\u0003\u01ae\u00d7\u0000\u0a3e\u0a40\u0001\u0000\u0000\u0000\u0a3f\u0a38"+
|
|
"\u0001\u0000\u0000\u0000\u0a3f\u0a39\u0001\u0000\u0000\u0000\u0a40\u01af"+
|
|
"\u0001\u0000\u0000\u0000\u0a41\u0a42\u0006\u00d8\uffff\uffff\u0000\u0a42"+
|
|
"\u0a43\u0003\u01b2\u00d9\u0000\u0a43\u0a49\u0001\u0000\u0000\u0000\u0a44"+
|
|
"\u0a45\n\u0001\u0000\u0000\u0a45\u0a46\u0005N\u0000\u0000\u0a46\u0a48"+
|
|
"\u0003\u01b2\u00d9\u0000\u0a47\u0a44\u0001\u0000\u0000\u0000\u0a48\u0a4b"+
|
|
"\u0001\u0000\u0000\u0000\u0a49\u0a47\u0001\u0000\u0000\u0000\u0a49\u0a4a"+
|
|
"\u0001\u0000\u0000\u0000\u0a4a\u01b1\u0001\u0000\u0000\u0000\u0a4b\u0a49"+
|
|
"\u0001\u0000\u0000\u0000\u0a4c\u0a4d\u0006\u00d9\uffff\uffff\u0000\u0a4d"+
|
|
"\u0a4e\u0003\u01b4\u00da\u0000\u0a4e\u0a54\u0001\u0000\u0000\u0000\u0a4f"+
|
|
"\u0a50\n\u0001\u0000\u0000\u0a50\u0a51\u0005M\u0000\u0000\u0a51\u0a53"+
|
|
"\u0003\u01b4\u00da\u0000\u0a52\u0a4f\u0001\u0000\u0000\u0000\u0a53\u0a56"+
|
|
"\u0001\u0000\u0000\u0000\u0a54\u0a52\u0001\u0000\u0000\u0000\u0a54\u0a55"+
|
|
"\u0001\u0000\u0000\u0000\u0a55\u01b3\u0001\u0000\u0000\u0000\u0a56\u0a54"+
|
|
"\u0001\u0000\u0000\u0000\u0a57\u0a58\u0006\u00da\uffff\uffff\u0000\u0a58"+
|
|
"\u0a59\u0003\u01b6\u00db\u0000\u0a59\u0a5f\u0001\u0000\u0000\u0000\u0a5a"+
|
|
"\u0a5b\n\u0001\u0000\u0000\u0a5b\u0a5c\u0005V\u0000\u0000\u0a5c\u0a5e"+
|
|
"\u0003\u01b6\u00db\u0000\u0a5d\u0a5a\u0001\u0000\u0000\u0000\u0a5e\u0a61"+
|
|
"\u0001\u0000\u0000\u0000\u0a5f\u0a5d\u0001\u0000\u0000\u0000\u0a5f\u0a60"+
|
|
"\u0001\u0000\u0000\u0000\u0a60\u01b5\u0001\u0000\u0000\u0000\u0a61\u0a5f"+
|
|
"\u0001\u0000\u0000\u0000\u0a62\u0a63\u0006\u00db\uffff\uffff\u0000\u0a63"+
|
|
"\u0a64\u0003\u01b8\u00dc\u0000\u0a64\u0a6a\u0001\u0000\u0000\u0000\u0a65"+
|
|
"\u0a66\n\u0001\u0000\u0000\u0a66\u0a67\u0005W\u0000\u0000\u0a67\u0a69"+
|
|
"\u0003\u01b8\u00dc\u0000\u0a68\u0a65\u0001\u0000\u0000\u0000\u0a69\u0a6c"+
|
|
"\u0001\u0000\u0000\u0000\u0a6a\u0a68\u0001\u0000\u0000\u0000\u0a6a\u0a6b"+
|
|
"\u0001\u0000\u0000\u0000\u0a6b\u01b7\u0001\u0000\u0000\u0000\u0a6c\u0a6a"+
|
|
"\u0001\u0000\u0000\u0000\u0a6d\u0a6e\u0006\u00dc\uffff\uffff\u0000\u0a6e"+
|
|
"\u0a6f\u0003\u01ba\u00dd\u0000\u0a6f\u0a75\u0001\u0000\u0000\u0000\u0a70"+
|
|
"\u0a71\n\u0001\u0000\u0000\u0a71\u0a72\u0005U\u0000\u0000\u0a72\u0a74"+
|
|
"\u0003\u01ba\u00dd\u0000\u0a73\u0a70\u0001\u0000\u0000\u0000\u0a74\u0a77"+
|
|
"\u0001\u0000\u0000\u0000\u0a75\u0a73\u0001\u0000\u0000\u0000\u0a75\u0a76"+
|
|
"\u0001\u0000\u0000\u0000\u0a76\u01b9\u0001\u0000\u0000\u0000\u0a77\u0a75"+
|
|
"\u0001\u0000\u0000\u0000\u0a78\u0a79\u0006\u00dd\uffff\uffff\u0000\u0a79"+
|
|
"\u0a7a\u0003\u01bc\u00de\u0000\u0a7a\u0a83\u0001\u0000\u0000\u0000\u0a7b"+
|
|
"\u0a7c\n\u0002\u0000\u0000\u0a7c\u0a7d\u0005I\u0000\u0000\u0a7d\u0a82"+
|
|
"\u0003\u01bc\u00de\u0000\u0a7e\u0a7f\n\u0001\u0000\u0000\u0a7f\u0a80\u0005"+
|
|
"L\u0000\u0000\u0a80\u0a82\u0003\u01bc\u00de\u0000\u0a81\u0a7b\u0001\u0000"+
|
|
"\u0000\u0000\u0a81\u0a7e\u0001\u0000\u0000\u0000\u0a82\u0a85\u0001\u0000"+
|
|
"\u0000\u0000\u0a83\u0a81\u0001\u0000\u0000\u0000\u0a83\u0a84\u0001\u0000"+
|
|
"\u0000\u0000\u0a84\u01bb\u0001\u0000\u0000\u0000\u0a85\u0a83\u0001\u0000"+
|
|
"\u0000\u0000\u0a86\u0a87\u0006\u00de\uffff\uffff\u0000\u0a87\u0a88\u0003"+
|
|
"\u01be\u00df\u0000\u0a88\u0a9a\u0001\u0000\u0000\u0000\u0a89\u0a8a\n\u0005"+
|
|
"\u0000\u0000\u0a8a\u0a8b\u0005D\u0000\u0000\u0a8b\u0a99\u0003\u01be\u00df"+
|
|
"\u0000\u0a8c\u0a8d\n\u0004\u0000\u0000\u0a8d\u0a8e\u0005C\u0000\u0000"+
|
|
"\u0a8e\u0a99\u0003\u01be\u00df\u0000\u0a8f\u0a90\n\u0003\u0000\u0000\u0a90"+
|
|
"\u0a91\u0005J\u0000\u0000\u0a91\u0a99\u0003\u01be\u00df\u0000\u0a92\u0a93"+
|
|
"\n\u0002\u0000\u0000\u0a93\u0a94\u0005K\u0000\u0000\u0a94\u0a99\u0003"+
|
|
"\u01be\u00df\u0000\u0a95\u0a96\n\u0001\u0000\u0000\u0a96\u0a97\u0005\u001a"+
|
|
"\u0000\u0000\u0a97\u0a99\u0003\n\u0005\u0000\u0a98\u0a89\u0001\u0000\u0000"+
|
|
"\u0000\u0a98\u0a8c\u0001\u0000\u0000\u0000\u0a98\u0a8f\u0001\u0000\u0000"+
|
|
"\u0000\u0a98\u0a92\u0001\u0000\u0000\u0000\u0a98\u0a95\u0001\u0000\u0000"+
|
|
"\u0000\u0a99\u0a9c\u0001\u0000\u0000\u0000\u0a9a\u0a98\u0001\u0000\u0000"+
|
|
"\u0000\u0a9a\u0a9b\u0001\u0000\u0000\u0000\u0a9b\u01bd\u0001\u0000\u0000"+
|
|
"\u0000\u0a9c\u0a9a\u0001\u0000\u0000\u0000\u0a9d\u0a9e\u0006\u00df\uffff"+
|
|
"\uffff\u0000\u0a9e\u0a9f\u0003\u01c0\u00e0\u0000\u0a9f\u0aaf\u0001\u0000"+
|
|
"\u0000\u0000\u0aa0\u0aa1\n\u0003\u0000\u0000\u0aa1\u0aa2\u0005D\u0000"+
|
|
"\u0000\u0aa2\u0aa3\u0005D\u0000\u0000\u0aa3\u0aae\u0003\u01c0\u00e0\u0000"+
|
|
"\u0aa4\u0aa5\n\u0002\u0000\u0000\u0aa5\u0aa6\u0005C\u0000\u0000\u0aa6"+
|
|
"\u0aa7\u0005C\u0000\u0000\u0aa7\u0aae\u0003\u01c0\u00e0\u0000\u0aa8\u0aa9"+
|
|
"\n\u0001\u0000\u0000\u0aa9\u0aaa\u0005C\u0000\u0000\u0aaa\u0aab\u0005"+
|
|
"C\u0000\u0000\u0aab\u0aac\u0005C\u0000\u0000\u0aac\u0aae\u0003\u01c0\u00e0"+
|
|
"\u0000\u0aad\u0aa0\u0001\u0000\u0000\u0000\u0aad\u0aa4\u0001\u0000\u0000"+
|
|
"\u0000\u0aad\u0aa8\u0001\u0000\u0000\u0000\u0aae\u0ab1\u0001\u0000\u0000"+
|
|
"\u0000\u0aaf\u0aad\u0001\u0000\u0000\u0000\u0aaf\u0ab0\u0001\u0000\u0000"+
|
|
"\u0000\u0ab0\u01bf\u0001\u0000\u0000\u0000\u0ab1\u0aaf\u0001\u0000\u0000"+
|
|
"\u0000\u0ab2\u0ab3\u0006\u00e0\uffff\uffff\u0000\u0ab3\u0ab4\u0003\u01c2"+
|
|
"\u00e1\u0000\u0ab4\u0abd\u0001\u0000\u0000\u0000\u0ab5\u0ab6\n\u0002\u0000"+
|
|
"\u0000\u0ab6\u0ab7\u0005Q\u0000\u0000\u0ab7\u0abc\u0003\u01c2\u00e1\u0000"+
|
|
"\u0ab8\u0ab9\n\u0001\u0000\u0000\u0ab9\u0aba\u0005R\u0000\u0000\u0aba"+
|
|
"\u0abc\u0003\u01c2\u00e1\u0000\u0abb\u0ab5\u0001\u0000\u0000\u0000\u0abb"+
|
|
"\u0ab8\u0001\u0000\u0000\u0000\u0abc\u0abf\u0001\u0000\u0000\u0000\u0abd"+
|
|
"\u0abb\u0001\u0000\u0000\u0000\u0abd\u0abe\u0001\u0000\u0000\u0000\u0abe"+
|
|
"\u01c1\u0001\u0000\u0000\u0000\u0abf\u0abd\u0001\u0000\u0000\u0000\u0ac0"+
|
|
"\u0ac1\u0006\u00e1\uffff\uffff\u0000\u0ac1\u0ac2\u0003\u01c4\u00e2\u0000"+
|
|
"\u0ac2\u0ace\u0001\u0000\u0000\u0000\u0ac3\u0ac4\n\u0003\u0000\u0000\u0ac4"+
|
|
"\u0ac5\u0005S\u0000\u0000\u0ac5\u0acd\u0003\u01c4\u00e2\u0000\u0ac6\u0ac7"+
|
|
"\n\u0002\u0000\u0000\u0ac7\u0ac8\u0005T\u0000\u0000\u0ac8\u0acd\u0003"+
|
|
"\u01c4\u00e2\u0000\u0ac9\u0aca\n\u0001\u0000\u0000\u0aca\u0acb\u0005X"+
|
|
"\u0000\u0000\u0acb\u0acd\u0003\u01c4\u00e2\u0000\u0acc\u0ac3\u0001\u0000"+
|
|
"\u0000\u0000\u0acc\u0ac6\u0001\u0000\u0000\u0000\u0acc\u0ac9\u0001\u0000"+
|
|
"\u0000\u0000\u0acd\u0ad0\u0001\u0000\u0000\u0000\u0ace\u0acc\u0001\u0000"+
|
|
"\u0000\u0000\u0ace\u0acf\u0001\u0000\u0000\u0000\u0acf\u01c3\u0001\u0000"+
|
|
"\u0000\u0000\u0ad0\u0ace\u0001\u0000\u0000\u0000\u0ad1\u0ad9\u0003\u01c6"+
|
|
"\u00e3\u0000\u0ad2\u0ad9\u0003\u01c8\u00e4\u0000\u0ad3\u0ad4\u0005Q\u0000"+
|
|
"\u0000\u0ad4\u0ad9\u0003\u01c4\u00e2\u0000\u0ad5\u0ad6\u0005R\u0000\u0000"+
|
|
"\u0ad6\u0ad9\u0003\u01c4\u00e2\u0000\u0ad7\u0ad9\u0003\u01ca\u00e5\u0000"+
|
|
"\u0ad8\u0ad1\u0001\u0000\u0000\u0000\u0ad8\u0ad2\u0001\u0000\u0000\u0000"+
|
|
"\u0ad8\u0ad3\u0001\u0000\u0000\u0000\u0ad8\u0ad5\u0001\u0000\u0000\u0000"+
|
|
"\u0ad8\u0ad7\u0001\u0000\u0000\u0000\u0ad9\u01c5\u0001\u0000\u0000\u0000"+
|
|
"\u0ada\u0adb\u0005O\u0000\u0000\u0adb\u0adc\u0003\u01c4\u00e2\u0000\u0adc"+
|
|
"\u01c7\u0001\u0000\u0000\u0000\u0add\u0ade\u0005P\u0000\u0000\u0ade\u0adf"+
|
|
"\u0003\u01c4\u00e2\u0000\u0adf\u01c9\u0001\u0000\u0000\u0000\u0ae0\u0ae7"+
|
|
"\u0003\u01cc\u00e6\u0000\u0ae1\u0ae2\u0005F\u0000\u0000\u0ae2\u0ae7\u0003"+
|
|
"\u01c4\u00e2\u0000\u0ae3\u0ae4\u0005E\u0000\u0000\u0ae4\u0ae7\u0003\u01c4"+
|
|
"\u00e2\u0000\u0ae5\u0ae7\u0003\u01d6\u00eb\u0000\u0ae6\u0ae0\u0001\u0000"+
|
|
"\u0000\u0000\u0ae6\u0ae1\u0001\u0000\u0000\u0000\u0ae6\u0ae3\u0001\u0000"+
|
|
"\u0000\u0000\u0ae6\u0ae5\u0001\u0000\u0000\u0000\u0ae7\u01cb\u0001\u0000"+
|
|
"\u0000\u0000\u0ae8\u0aeb\u0003\u015e\u00af\u0000\u0ae9\u0aeb\u00038\u001c"+
|
|
"\u0000\u0aea\u0ae8\u0001\u0000\u0000\u0000\u0aea\u0ae9\u0001\u0000\u0000"+
|
|
"\u0000\u0aeb\u0af0\u0001\u0000\u0000\u0000\u0aec\u0aef\u0003\u01d0\u00e8"+
|
|
"\u0000\u0aed\u0aef\u0003\u01d4\u00ea\u0000\u0aee\u0aec\u0001\u0000\u0000"+
|
|
"\u0000\u0aee\u0aed\u0001\u0000\u0000\u0000\u0aef\u0af2\u0001\u0000\u0000"+
|
|
"\u0000\u0af0\u0aee\u0001\u0000\u0000\u0000\u0af0\u0af1\u0001\u0000\u0000"+
|
|
"\u0000\u0af1\u01cd\u0001\u0000\u0000\u0000\u0af2\u0af0\u0001\u0000\u0000"+
|
|
"\u0000\u0af3\u0af4\u0003\u01cc\u00e6\u0000\u0af4\u0af5\u0005O\u0000\u0000"+
|
|
"\u0af5\u01cf\u0001\u0000\u0000\u0000\u0af6\u0af7\u0005O\u0000\u0000\u0af7"+
|
|
"\u01d1\u0001\u0000\u0000\u0000\u0af8\u0af9\u0003\u01cc\u00e6\u0000\u0af9"+
|
|
"\u0afa\u0005P\u0000\u0000\u0afa\u01d3\u0001\u0000\u0000\u0000\u0afb\u0afc"+
|
|
"\u0005P\u0000\u0000\u0afc\u01d5\u0001\u0000\u0000\u0000\u0afd\u0afe\u0005"+
|
|
"9\u0000\u0000\u0afe\u0aff\u0003\u0002\u0001\u0000\u0aff\u0b00\u0005:\u0000"+
|
|
"\u0000\u0b00\u0b01\u0003\u01c4\u00e2\u0000\u0b01\u0b19\u0001\u0000\u0000"+
|
|
"\u0000\u0b02\u0b03\u00059\u0000\u0000\u0b03\u0b07\u0003\n\u0005\u0000"+
|
|
"\u0b04\u0b06\u0003&\u0013\u0000\u0b05\u0b04\u0001\u0000\u0000\u0000\u0b06"+
|
|
"\u0b09\u0001\u0000\u0000\u0000\u0b07\u0b05\u0001\u0000\u0000\u0000\u0b07"+
|
|
"\u0b08\u0001\u0000\u0000\u0000\u0b08\u0b0a\u0001\u0000\u0000\u0000\u0b09"+
|
|
"\u0b07\u0001\u0000\u0000\u0000\u0b0a\u0b0b\u0005:\u0000\u0000\u0b0b\u0b0c"+
|
|
"\u0003\u01ca\u00e5\u0000\u0b0c\u0b19\u0001\u0000\u0000\u0000\u0b0d\u0b0e"+
|
|
"\u00059\u0000\u0000\u0b0e\u0b12\u0003\n\u0005\u0000\u0b0f\u0b11\u0003"+
|
|
"&\u0013\u0000\u0b10\u0b0f\u0001\u0000\u0000\u0000\u0b11\u0b14\u0001\u0000"+
|
|
"\u0000\u0000\u0b12\u0b10\u0001\u0000\u0000\u0000\u0b12\u0b13\u0001\u0000"+
|
|
"\u0000\u0000\u0b13\u0b15\u0001\u0000\u0000\u0000\u0b14\u0b12\u0001\u0000"+
|
|
"\u0000\u0000\u0b15\u0b16\u0005:\u0000\u0000\u0b16\u0b17\u0003\u019e\u00cf"+
|
|
"\u0000\u0b17\u0b19\u0001\u0000\u0000\u0000\u0b18\u0afd\u0001\u0000\u0000"+
|
|
"\u0000\u0b18\u0b02\u0001\u0000\u0000\u0000\u0b18\u0b0d\u0001\u0000\u0000"+
|
|
"\u0000\u0b19\u01d7\u0001\u0000\u0000\u0000\u0142\u01dd\u01e4\u01e8\u01ec"+
|
|
"\u01f5\u01f9\u01fd\u01ff\u0205\u020a\u0211\u0216\u0218\u021e\u0223\u0228"+
|
|
"\u022d\u0238\u0246\u024b\u0253\u025a\u0260\u0265\u0270\u0273\u0281\u0286"+
|
|
"\u028b\u0290\u0296\u02a0\u02a8\u02b2\u02ba\u02c6\u02ca\u02cf\u02d5\u02dd"+
|
|
"\u02ea\u0307\u030b\u0310\u0316\u0319\u031c\u0328\u0333\u0341\u0348\u0351"+
|
|
"\u0358\u035d\u036c\u0373\u0379\u037d\u0381\u0385\u0389\u038e\u0392\u0396"+
|
|
"\u0398\u039d\u03a4\u03a9\u03ab\u03b1\u03b6\u03ba\u03cd\u03d2\u03e2\u03e7"+
|
|
"\u03ed\u03f3\u03f5\u03f9\u03fe\u0402\u040a\u0411\u0419\u041c\u0421\u0429"+
|
|
"\u042e\u0435\u043c\u0441\u0447\u0453\u0458\u045c\u0466\u046b\u0473\u0476"+
|
|
"\u047b\u0483\u0486\u048b\u0490\u0495\u049a\u04a1\u04a6\u04ae\u04b3\u04b8"+
|
|
"\u04bd\u04c3\u04c9\u04cc\u04cf\u04d8\u04de\u04e4\u04e7\u04ea\u04f2\u04f7"+
|
|
"\u04fc\u0502\u0505\u0510\u0519\u0523\u0528\u0533\u0538\u0544\u0549\u0555"+
|
|
"\u055f\u0564\u056c\u056f\u0576\u057e\u0584\u058d\u0597\u059b\u059e\u05a7"+
|
|
"\u05b5\u05b8\u05c1\u05c6\u05cd\u05d2\u05da\u05e6\u05ed\u05fb\u0611\u0633"+
|
|
"\u063f\u0645\u0651\u065e\u0678\u067c\u0681\u0685\u0689\u0691\u0695\u0699"+
|
|
"\u06a0\u06a9\u06b1\u06c0\u06cc\u06d2\u06d8\u06ed\u06f2\u06f8\u0704\u070f"+
|
|
"\u0719\u071c\u0721\u072a\u0730\u073a\u073f\u0748\u075f\u0769\u077f\u0786"+
|
|
"\u078e\u0796\u07a1\u07b8\u07c2\u07cd\u07e3\u07e7\u07ec\u07f4\u07fa\u07fe"+
|
|
"\u0802\u0806\u080c\u0811\u0816\u081a\u081e\u0824\u0829\u082e\u0832\u0836"+
|
|
"\u0838\u083d\u0842\u0847\u084b\u084f\u0853\u0858\u0860\u0866\u086a\u086e"+
|
|
"\u0872\u0878\u087d\u0882\u0886\u088a\u088c\u0891\u08a0\u08ae\u08ba\u08c3"+
|
|
"\u08d1\u08de\u08e7\u08ed\u08f4\u08f9\u0900\u0905\u090c\u0911\u0918\u091d"+
|
|
"\u0925\u092a\u092e\u0932\u0937\u093e\u0945\u094a\u0951\u0956\u095d\u0962"+
|
|
"\u096a\u096f\u0973\u097a\u0980\u0987\u098e\u0995\u099d\u09a4\u09ac\u09b0"+
|
|
"\u09b7\u09be\u09c5\u09cd\u09d4\u09dc\u09e2\u09e8\u09f4\u09fa\u0a00\u0a0b"+
|
|
"\u0a14\u0a1b\u0a22\u0a27\u0a2b\u0a34\u0a3f\u0a49\u0a54\u0a5f\u0a6a\u0a75"+
|
|
"\u0a81\u0a83\u0a98\u0a9a\u0aad\u0aaf\u0abb\u0abd\u0acc\u0ace\u0ad8\u0ae6"+
|
|
"\u0aea\u0aee\u0af0\u0b07\u0b12\u0b18";
|
|
public static final String _serializedATN = Utils.join(
|
|
new String[] {
|
|
_serializedATNSegment0,
|
|
_serializedATNSegment1
|
|
},
|
|
""
|
|
);
|
|
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);
|
|
}
|
|
}
|
|
} |