c7f4a2d4c1
Some checks failed
Build and Test with Maven / Build-and-test-with-Maven (push) Has been cancelled
15625 lines
547 KiB
Java
15625 lines
547 KiB
Java
// Generated from C:/Users/ruben/IdeaProjects/JavaCompilerCore/src/main/antlr4/de/dhbwstuttgart/parser/antlr/Java17Parser.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 Java17Parser 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, MODULE=51, OPEN=52, REQUIRES=53, EXPORTS=54, OPENS=55, TO=56,
|
|
USES=57, PROVIDES=58, WITH=59, TRANSITIVE=60, VAR=61, YIELD=62, RECORD=63,
|
|
SEALED=64, PERMITS=65, NON_SEALED=66, DECIMAL_LITERAL=67, HEX_LITERAL=68,
|
|
OCT_LITERAL=69, BINARY_LITERAL=70, FLOAT_LITERAL=71, HEX_FLOAT_LITERAL=72,
|
|
BOOL_LITERAL=73, CHAR_LITERAL=74, STRING_LITERAL=75, TEXT_BLOCK=76, NULL_LITERAL=77,
|
|
LPAREN=78, RPAREN=79, LBRACE=80, RBRACE=81, LBRACK=82, RBRACK=83, SEMI=84,
|
|
COMMA=85, DOT=86, ASSIGN=87, GT=88, LT=89, BANG=90, TILDE=91, QUESTION=92,
|
|
COLON=93, EQUAL=94, LE=95, GE=96, NOTEQUAL=97, AND=98, OR=99, INC=100,
|
|
DEC=101, ADD=102, SUB=103, MUL=104, DIV=105, BITAND=106, BITOR=107, CARET=108,
|
|
MOD=109, ADD_ASSIGN=110, SUB_ASSIGN=111, MUL_ASSIGN=112, DIV_ASSIGN=113,
|
|
AND_ASSIGN=114, OR_ASSIGN=115, XOR_ASSIGN=116, MOD_ASSIGN=117, LSHIFT_ASSIGN=118,
|
|
RSHIFT_ASSIGN=119, URSHIFT_ASSIGN=120, ARROW=121, COLONCOLON=122, AT=123,
|
|
ELLIPSIS=124, WS=125, COMMENT=126, LINE_COMMENT=127, IDENTIFIER=128;
|
|
public static final int
|
|
RULE_sourceFile = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2,
|
|
RULE_classOrInterface = 3, RULE_modifier = 4, RULE_classOrInterfaceModifier = 5,
|
|
RULE_variableModifier = 6, RULE_classDeclaration = 7, RULE_genericDeclarationList = 8,
|
|
RULE_genericTypeVar = 9, RULE_typeBound = 10, RULE_enumDeclaration = 11,
|
|
RULE_enumConstants = 12, RULE_enumConstant = 13, RULE_enumBodyDeclarations = 14,
|
|
RULE_interfaceDeclaration = 15, RULE_classBody = 16, RULE_interfaceBody = 17,
|
|
RULE_classBodyDeclaration = 18, RULE_memberDeclaration = 19, RULE_method = 20,
|
|
RULE_methodDeclaration = 21, RULE_methodHeader = 22, RULE_methodBody = 23,
|
|
RULE_refType = 24, RULE_genericMethodDeclaration = 25, RULE_constructor = 26,
|
|
RULE_genericConstructorDeclaration = 27, RULE_constructorDeclaration = 28,
|
|
RULE_fieldDeclaration = 29, RULE_interfaceBodyDeclaration = 30, RULE_interfaceMemberDeclaration = 31,
|
|
RULE_constDeclaration = 32, RULE_constantDeclarator = 33, RULE_interfaceMethodDeclaration = 34,
|
|
RULE_interfaceMethodModifier = 35, RULE_genericInterfaceMethodDeclaration = 36,
|
|
RULE_interfaceCommonBodyDeclaration = 37, RULE_variableDeclarators = 38,
|
|
RULE_variableDeclarator = 39, RULE_variableDeclaratorId = 40, RULE_variableInitializer = 41,
|
|
RULE_arrayInitializer = 42, RULE_classOrInterfaceType = 43, RULE_typeArgument = 44,
|
|
RULE_wildcardType = 45, RULE_extendsWildcardType = 46, RULE_superWildcardType = 47,
|
|
RULE_qualifiedNameList = 48, RULE_exceptionList = 49, RULE_formalParameters = 50,
|
|
RULE_receiverParameter = 51, RULE_formalParameterList = 52, RULE_formalParameter = 53,
|
|
RULE_lastFormalParameter = 54, RULE_lambdaLVTIList = 55, RULE_lambdaLVTIParameter = 56,
|
|
RULE_qualifiedName = 57, RULE_literal = 58, RULE_integerLiteral = 59,
|
|
RULE_floatLiteral = 60, RULE_altAnnotationQualifiedName = 61, RULE_annotation = 62,
|
|
RULE_elementValuePairs = 63, RULE_elementValuePair = 64, RULE_elementValue = 65,
|
|
RULE_elementValueArrayInitializer = 66, RULE_annotationTypeDeclaration = 67,
|
|
RULE_annotationTypeBody = 68, RULE_annotationTypeElementDeclaration = 69,
|
|
RULE_annotationTypeElementRest = 70, RULE_annotationMethodOrConstantRest = 71,
|
|
RULE_annotationMethodRest = 72, RULE_annotationConstantRest = 73, RULE_defaultValue = 74,
|
|
RULE_moduleDeclaration = 75, RULE_moduleBody = 76, RULE_moduleDirective = 77,
|
|
RULE_requiresModifier = 78, RULE_recordDeclaration = 79, RULE_recordHeader = 80,
|
|
RULE_recordComponentList = 81, RULE_recordComponent = 82, RULE_recordBody = 83,
|
|
RULE_block = 84, RULE_blockStatement = 85, RULE_localVariableDeclaration = 86,
|
|
RULE_identifier = 87, RULE_typeIdentifier = 88, RULE_localTypeDeclaration = 89,
|
|
RULE_statement = 90, RULE_catchClause = 91, RULE_catchType = 92, RULE_finallyBlock = 93,
|
|
RULE_resourceSpecification = 94, RULE_resources = 95, RULE_resource = 96,
|
|
RULE_switchBlockStatementGroup = 97, RULE_switchLabel = 98, RULE_forControl = 99,
|
|
RULE_forInit = 100, RULE_enhancedForControl = 101, RULE_parExpression = 102,
|
|
RULE_expressionList = 103, RULE_methodCall = 104, RULE_expression = 105,
|
|
RULE_pattern = 106, RULE_primaryPattern = 107, RULE_recordPattern = 108,
|
|
RULE_typePattern = 109, RULE_recordStructurePattern = 110, RULE_recordComponentPatternElement = 111,
|
|
RULE_recordComponentPatternList = 112, RULE_lambdaExpression = 113, RULE_lambdaParameters = 114,
|
|
RULE_lambdaBody = 115, RULE_primary = 116, RULE_switchExpression = 117,
|
|
RULE_switchLabeledRule = 118, RULE_switchLabelCase = 119, RULE_guardedPattern = 120,
|
|
RULE_switchRuleOutcome = 121, RULE_classType = 122, RULE_creator = 123,
|
|
RULE_createdName = 124, RULE_innerCreator = 125, RULE_arrayCreatorRest = 126,
|
|
RULE_classCreatorRest = 127, RULE_explicitGenericInvocation = 128, RULE_typeArgumentsOrDiamond = 129,
|
|
RULE_nonWildcardTypeArgumentsOrDiamond = 130, RULE_nonWildcardTypeArguments = 131,
|
|
RULE_typeList = 132, RULE_typeType = 133, RULE_primitiveType = 134, RULE_typeArguments = 135,
|
|
RULE_superSuffix = 136, RULE_explicitGenericInvocationSuffix = 137, RULE_arguments = 138;
|
|
private static String[] makeRuleNames() {
|
|
return new String[] {
|
|
"sourceFile", "packageDeclaration", "importDeclaration", "classOrInterface",
|
|
"modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration",
|
|
"genericDeclarationList", "genericTypeVar", "typeBound", "enumDeclaration",
|
|
"enumConstants", "enumConstant", "enumBodyDeclarations", "interfaceDeclaration",
|
|
"classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration",
|
|
"method", "methodDeclaration", "methodHeader", "methodBody", "refType",
|
|
"genericMethodDeclaration", "constructor", "genericConstructorDeclaration",
|
|
"constructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration",
|
|
"interfaceMemberDeclaration", "constDeclaration", "constantDeclarator",
|
|
"interfaceMethodDeclaration", "interfaceMethodModifier", "genericInterfaceMethodDeclaration",
|
|
"interfaceCommonBodyDeclaration", "variableDeclarators", "variableDeclarator",
|
|
"variableDeclaratorId", "variableInitializer", "arrayInitializer", "classOrInterfaceType",
|
|
"typeArgument", "wildcardType", "extendsWildcardType", "superWildcardType",
|
|
"qualifiedNameList", "exceptionList", "formalParameters", "receiverParameter",
|
|
"formalParameterList", "formalParameter", "lastFormalParameter", "lambdaLVTIList",
|
|
"lambdaLVTIParameter", "qualifiedName", "literal", "integerLiteral",
|
|
"floatLiteral", "altAnnotationQualifiedName", "annotation", "elementValuePairs",
|
|
"elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration",
|
|
"annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest",
|
|
"annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest",
|
|
"defaultValue", "moduleDeclaration", "moduleBody", "moduleDirective",
|
|
"requiresModifier", "recordDeclaration", "recordHeader", "recordComponentList",
|
|
"recordComponent", "recordBody", "block", "blockStatement", "localVariableDeclaration",
|
|
"identifier", "typeIdentifier", "localTypeDeclaration", "statement",
|
|
"catchClause", "catchType", "finallyBlock", "resourceSpecification",
|
|
"resources", "resource", "switchBlockStatementGroup", "switchLabel",
|
|
"forControl", "forInit", "enhancedForControl", "parExpression", "expressionList",
|
|
"methodCall", "expression", "pattern", "primaryPattern", "recordPattern",
|
|
"typePattern", "recordStructurePattern", "recordComponentPatternElement",
|
|
"recordComponentPatternList", "lambdaExpression", "lambdaParameters",
|
|
"lambdaBody", "primary", "switchExpression", "switchLabeledRule", "switchLabelCase",
|
|
"guardedPattern", "switchRuleOutcome", "classType", "creator", "createdName",
|
|
"innerCreator", "arrayCreatorRest", "classCreatorRest", "explicitGenericInvocation",
|
|
"typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments",
|
|
"typeList", "typeType", "primitiveType", "typeArguments", "superSuffix",
|
|
"explicitGenericInvocationSuffix", "arguments"
|
|
};
|
|
}
|
|
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'", "'module'",
|
|
"'open'", "'requires'", "'exports'", "'opens'", "'to'", "'uses'", "'provides'",
|
|
"'with'", "'transitive'", "'var'", "'yield'", "'record'", "'sealed'",
|
|
"'permits'", "'non-sealed'", null, null, null, null, null, null, null,
|
|
null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'",
|
|
"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'",
|
|
"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'",
|
|
"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='", "'*='",
|
|
"'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='", "'->'",
|
|
"'::'", "'@'", "'...'"
|
|
};
|
|
}
|
|
private static final String[] _LITERAL_NAMES = makeLiteralNames();
|
|
private static String[] makeSymbolicNames() {
|
|
return new String[] {
|
|
null, "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", "MODULE",
|
|
"OPEN", "REQUIRES", "EXPORTS", "OPENS", "TO", "USES", "PROVIDES", "WITH",
|
|
"TRANSITIVE", "VAR", "YIELD", "RECORD", "SEALED", "PERMITS", "NON_SEALED",
|
|
"DECIMAL_LITERAL", "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL",
|
|
"HEX_FLOAT_LITERAL", "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL",
|
|
"TEXT_BLOCK", "NULL_LITERAL", "LPAREN", "RPAREN", "LBRACE", "RBRACE",
|
|
"LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG",
|
|
"TILDE", "QUESTION", "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND",
|
|
"OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET",
|
|
"MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN",
|
|
"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN",
|
|
"URSHIFT_ASSIGN", "ARROW", "COLONCOLON", "AT", "ELLIPSIS", "WS", "COMMENT",
|
|
"LINE_COMMENT", "IDENTIFIER"
|
|
};
|
|
}
|
|
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 "Java17Parser.g4"; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public Java17Parser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SourceFileContext extends ParserRuleContext {
|
|
public SourceFileContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_sourceFile; }
|
|
|
|
public SourceFileContext() { }
|
|
public void copyFrom(SourceFileContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SrcfileContext extends SourceFileContext {
|
|
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<ClassOrInterfaceContext> classOrInterface() {
|
|
return getRuleContexts(ClassOrInterfaceContext.class);
|
|
}
|
|
public ClassOrInterfaceContext classOrInterface(int i) {
|
|
return getRuleContext(ClassOrInterfaceContext.class,i);
|
|
}
|
|
public SrcfileContext(SourceFileContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSrcfile(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSrcfile(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSrcfile(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ModuledeclContext extends SourceFileContext {
|
|
public ModuleDeclarationContext moduleDeclaration() {
|
|
return getRuleContext(ModuleDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode EOF() { return getToken(Java17Parser.EOF, 0); }
|
|
public ModuledeclContext(SourceFileContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterModuledecl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitModuledecl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitModuledecl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SourceFileContext sourceFile() throws RecognitionException {
|
|
SourceFileContext _localctx = new SourceFileContext(_ctx, getState());
|
|
enterRule(_localctx, 0, RULE_sourceFile);
|
|
int _la;
|
|
try {
|
|
setState(296);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
|
|
case 1:
|
|
_localctx = new SrcfileContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(279);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(278);
|
|
packageDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
setState(284);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==IMPORT) {
|
|
{
|
|
{
|
|
setState(281);
|
|
importDeclaration();
|
|
}
|
|
}
|
|
setState(286);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(290);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -1125457390829311L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660702539773L) != 0)) {
|
|
{
|
|
{
|
|
setState(287);
|
|
classOrInterface();
|
|
}
|
|
}
|
|
setState(292);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new ModuledeclContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(293);
|
|
moduleDeclaration();
|
|
setState(294);
|
|
match(EOF);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
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(Java17Parser.PACKAGE, 0); }
|
|
public QualifiedNameContext qualifiedName() {
|
|
return getRuleContext(QualifiedNameContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_packageDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPackageDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPackageDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPackageDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
|
|
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 2, RULE_packageDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(301);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(298);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(303);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(304);
|
|
match(PACKAGE);
|
|
setState(305);
|
|
qualifiedName();
|
|
setState(306);
|
|
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 ImportDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode IMPORT() { return getToken(Java17Parser.IMPORT, 0); }
|
|
public QualifiedNameContext qualifiedName() {
|
|
return getRuleContext(QualifiedNameContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java17Parser.STATIC, 0); }
|
|
public TerminalNode DOT() { return getToken(Java17Parser.DOT, 0); }
|
|
public TerminalNode MUL() { return getToken(Java17Parser.MUL, 0); }
|
|
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_importDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterImportDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitImportDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitImportDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
|
|
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 4, RULE_importDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(308);
|
|
match(IMPORT);
|
|
setState(310);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==STATIC) {
|
|
{
|
|
setState(309);
|
|
match(STATIC);
|
|
}
|
|
}
|
|
|
|
setState(312);
|
|
qualifiedName();
|
|
setState(315);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==DOT) {
|
|
{
|
|
setState(313);
|
|
match(DOT);
|
|
setState(314);
|
|
match(MUL);
|
|
}
|
|
}
|
|
|
|
setState(317);
|
|
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 ClassOrInterfaceContext extends ParserRuleContext {
|
|
public ClassOrInterfaceContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classOrInterface; }
|
|
|
|
public ClassOrInterfaceContext() { }
|
|
public void copyFrom(ClassOrInterfaceContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NoclassorinterfaceContext extends ClassOrInterfaceContext {
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public NoclassorinterfaceContext(ClassOrInterfaceContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterNoclassorinterface(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitNoclassorinterface(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitNoclassorinterface(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassorinterfacedeclContext extends ClassOrInterfaceContext {
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public EnumDeclarationContext enumDeclaration() {
|
|
return getRuleContext(EnumDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
|
|
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
|
|
}
|
|
public RecordDeclarationContext recordDeclaration() {
|
|
return getRuleContext(RecordDeclarationContext.class,0);
|
|
}
|
|
public List<ClassOrInterfaceModifierContext> classOrInterfaceModifier() {
|
|
return getRuleContexts(ClassOrInterfaceModifierContext.class);
|
|
}
|
|
public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) {
|
|
return getRuleContext(ClassOrInterfaceModifierContext.class,i);
|
|
}
|
|
public ClassorinterfacedeclContext(ClassOrInterfaceContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassorinterfacedecl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassorinterfacedecl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassorinterfacedecl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassOrInterfaceContext classOrInterface() throws RecognitionException {
|
|
ClassOrInterfaceContext _localctx = new ClassOrInterfaceContext(_ctx, getState());
|
|
enterRule(_localctx, 6, RULE_classOrInterface);
|
|
try {
|
|
int _alt;
|
|
setState(333);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case ABSTRACT:
|
|
case CLASS:
|
|
case ENUM:
|
|
case FINAL:
|
|
case INTERFACE:
|
|
case PRIVATE:
|
|
case PROTECTED:
|
|
case PUBLIC:
|
|
case STATIC:
|
|
case STRICTFP:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case NON_SEALED:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
_localctx = new ClassorinterfacedeclContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(322);
|
|
_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(319);
|
|
classOrInterfaceModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(324);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
|
|
}
|
|
setState(330);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case CLASS:
|
|
{
|
|
setState(325);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case ENUM:
|
|
{
|
|
setState(326);
|
|
enumDeclaration();
|
|
}
|
|
break;
|
|
case INTERFACE:
|
|
{
|
|
setState(327);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case AT:
|
|
{
|
|
setState(328);
|
|
annotationTypeDeclaration();
|
|
}
|
|
break;
|
|
case RECORD:
|
|
{
|
|
setState(329);
|
|
recordDeclaration();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
case SEMI:
|
|
_localctx = new NoclassorinterfaceContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(332);
|
|
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 ModifierContext extends ParserRuleContext {
|
|
public ClassOrInterfaceModifierContext classOrInterfaceModifier() {
|
|
return getRuleContext(ClassOrInterfaceModifierContext.class,0);
|
|
}
|
|
public TerminalNode NATIVE() { return getToken(Java17Parser.NATIVE, 0); }
|
|
public TerminalNode SYNCHRONIZED() { return getToken(Java17Parser.SYNCHRONIZED, 0); }
|
|
public TerminalNode TRANSIENT() { return getToken(Java17Parser.TRANSIENT, 0); }
|
|
public TerminalNode VOLATILE() { return getToken(Java17Parser.VOLATILE, 0); }
|
|
public ModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_modifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterModifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitModifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitModifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ModifierContext modifier() throws RecognitionException {
|
|
ModifierContext _localctx = new ModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 8, RULE_modifier);
|
|
try {
|
|
setState(340);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case ABSTRACT:
|
|
case FINAL:
|
|
case PRIVATE:
|
|
case PROTECTED:
|
|
case PUBLIC:
|
|
case STATIC:
|
|
case STRICTFP:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case NON_SEALED:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(335);
|
|
classOrInterfaceModifier();
|
|
}
|
|
break;
|
|
case NATIVE:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(336);
|
|
match(NATIVE);
|
|
}
|
|
break;
|
|
case SYNCHRONIZED:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(337);
|
|
match(SYNCHRONIZED);
|
|
}
|
|
break;
|
|
case TRANSIENT:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(338);
|
|
match(TRANSIENT);
|
|
}
|
|
break;
|
|
case VOLATILE:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(339);
|
|
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 ClassOrInterfaceModifierContext extends ParserRuleContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public TerminalNode PUBLIC() { return getToken(Java17Parser.PUBLIC, 0); }
|
|
public TerminalNode PROTECTED() { return getToken(Java17Parser.PROTECTED, 0); }
|
|
public TerminalNode PRIVATE() { return getToken(Java17Parser.PRIVATE, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java17Parser.STATIC, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java17Parser.ABSTRACT, 0); }
|
|
public TerminalNode FINAL() { return getToken(Java17Parser.FINAL, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java17Parser.STRICTFP, 0); }
|
|
public TerminalNode SEALED() { return getToken(Java17Parser.SEALED, 0); }
|
|
public TerminalNode NON_SEALED() { return getToken(Java17Parser.NON_SEALED, 0); }
|
|
public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassOrInterfaceModifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassOrInterfaceModifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassOrInterfaceModifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException {
|
|
ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 10, RULE_classOrInterfaceModifier);
|
|
try {
|
|
setState(352);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(342);
|
|
annotation();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(343);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(344);
|
|
match(PROTECTED);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(345);
|
|
match(PRIVATE);
|
|
}
|
|
break;
|
|
case 5:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(346);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case 6:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(347);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case 7:
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(348);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
case 8:
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(349);
|
|
match(STRICTFP);
|
|
}
|
|
break;
|
|
case 9:
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(350);
|
|
match(SEALED);
|
|
}
|
|
break;
|
|
case 10:
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(351);
|
|
match(NON_SEALED);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
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 VariableModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableModifier; }
|
|
|
|
public VariableModifierContext() { }
|
|
public void copyFrom(VariableModifierContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FinalvarmodContext extends VariableModifierContext {
|
|
public TerminalNode FINAL() { return getToken(Java17Parser.FINAL, 0); }
|
|
public FinalvarmodContext(VariableModifierContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFinalvarmod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFinalvarmod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFinalvarmod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationvarmodContext extends VariableModifierContext {
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public AnnotationvarmodContext(VariableModifierContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationvarmod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationvarmod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationvarmod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VariableModifierContext variableModifier() throws RecognitionException {
|
|
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 12, RULE_variableModifier);
|
|
try {
|
|
setState(356);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case FINAL:
|
|
_localctx = new FinalvarmodContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(354);
|
|
match(FINAL);
|
|
}
|
|
break;
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
_localctx = new AnnotationvarmodContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(355);
|
|
annotation();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode CLASS() { return getToken(Java17Parser.CLASS, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public TerminalNode EXTENDS() { return getToken(Java17Parser.EXTENDS, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public TerminalNode IMPLEMENTS() { return getToken(Java17Parser.IMPLEMENTS, 0); }
|
|
public List<TypeListContext> typeList() {
|
|
return getRuleContexts(TypeListContext.class);
|
|
}
|
|
public TypeListContext typeList(int i) {
|
|
return getRuleContext(TypeListContext.class,i);
|
|
}
|
|
public TerminalNode PERMITS() { return getToken(Java17Parser.PERMITS, 0); }
|
|
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
|
|
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 14, RULE_classDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(358);
|
|
match(CLASS);
|
|
setState(359);
|
|
identifier();
|
|
setState(361);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(360);
|
|
genericDeclarationList();
|
|
}
|
|
}
|
|
|
|
setState(365);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS) {
|
|
{
|
|
setState(363);
|
|
match(EXTENDS);
|
|
setState(364);
|
|
typeType();
|
|
}
|
|
}
|
|
|
|
setState(369);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==IMPLEMENTS) {
|
|
{
|
|
setState(367);
|
|
match(IMPLEMENTS);
|
|
setState(368);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(373);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==PERMITS) {
|
|
{
|
|
setState(371);
|
|
match(PERMITS);
|
|
setState(372);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(375);
|
|
classBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GenericDeclarationListContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public List<GenericTypeVarContext> genericTypeVar() {
|
|
return getRuleContexts(GenericTypeVarContext.class);
|
|
}
|
|
public GenericTypeVarContext genericTypeVar(int i) {
|
|
return getRuleContext(GenericTypeVarContext.class,i);
|
|
}
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public GenericDeclarationListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_genericDeclarationList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericDeclarationList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericDeclarationList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericDeclarationList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GenericDeclarationListContext genericDeclarationList() throws RecognitionException {
|
|
GenericDeclarationListContext _localctx = new GenericDeclarationListContext(_ctx, getState());
|
|
enterRule(_localctx, 16, RULE_genericDeclarationList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(377);
|
|
match(LT);
|
|
setState(378);
|
|
genericTypeVar();
|
|
setState(383);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(379);
|
|
match(COMMA);
|
|
setState(380);
|
|
genericTypeVar();
|
|
}
|
|
}
|
|
setState(385);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(386);
|
|
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 GenericTypeVarContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public TypeBoundContext typeBound() {
|
|
return getRuleContext(TypeBoundContext.class,0);
|
|
}
|
|
public TerminalNode EXTENDS() { return getToken(Java17Parser.EXTENDS, 0); }
|
|
public TerminalNode IMPLEMENTS() { return getToken(Java17Parser.IMPLEMENTS, 0); }
|
|
public GenericTypeVarContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_genericTypeVar; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericTypeVar(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericTypeVar(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericTypeVar(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GenericTypeVarContext genericTypeVar() throws RecognitionException {
|
|
GenericTypeVarContext _localctx = new GenericTypeVarContext(_ctx, getState());
|
|
enterRule(_localctx, 18, RULE_genericTypeVar);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(391);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(388);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(393);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,18,_ctx);
|
|
}
|
|
setState(394);
|
|
identifier();
|
|
setState(403);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS || _la==IMPLEMENTS) {
|
|
{
|
|
setState(395);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==EXTENDS || _la==IMPLEMENTS) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(399);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(396);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(401);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
|
|
}
|
|
setState(402);
|
|
typeBound();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
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 List<TypeTypeContext> typeType() {
|
|
return getRuleContexts(TypeTypeContext.class);
|
|
}
|
|
public TypeTypeContext typeType(int i) {
|
|
return getRuleContext(TypeTypeContext.class,i);
|
|
}
|
|
public List<TerminalNode> BITAND() { return getTokens(Java17Parser.BITAND); }
|
|
public TerminalNode BITAND(int i) {
|
|
return getToken(Java17Parser.BITAND, i);
|
|
}
|
|
public TypeBoundContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeBound; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeBound(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeBound(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeBound(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeBoundContext typeBound() throws RecognitionException {
|
|
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
|
|
enterRule(_localctx, 20, RULE_typeBound);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(405);
|
|
typeType();
|
|
setState(410);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITAND) {
|
|
{
|
|
{
|
|
setState(406);
|
|
match(BITAND);
|
|
setState(407);
|
|
typeType();
|
|
}
|
|
}
|
|
setState(412);
|
|
_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 EnumDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode ENUM() { return getToken(Java17Parser.ENUM, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public TerminalNode IMPLEMENTS() { return getToken(Java17Parser.IMPLEMENTS, 0); }
|
|
public TypeListContext typeList() {
|
|
return getRuleContext(TypeListContext.class,0);
|
|
}
|
|
public EnumConstantsContext enumConstants() {
|
|
return getRuleContext(EnumConstantsContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java17Parser.COMMA, 0); }
|
|
public EnumBodyDeclarationsContext enumBodyDeclarations() {
|
|
return getRuleContext(EnumBodyDeclarationsContext.class,0);
|
|
}
|
|
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnumDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnumDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnumDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
|
|
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 22, RULE_enumDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(413);
|
|
match(ENUM);
|
|
setState(414);
|
|
identifier();
|
|
setState(417);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==IMPLEMENTS) {
|
|
{
|
|
setState(415);
|
|
match(IMPLEMENTS);
|
|
setState(416);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(419);
|
|
match(LBRACE);
|
|
setState(421);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
setState(420);
|
|
enumConstants();
|
|
}
|
|
}
|
|
|
|
setState(424);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(423);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
setState(427);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==SEMI) {
|
|
{
|
|
setState(426);
|
|
enumBodyDeclarations();
|
|
}
|
|
}
|
|
|
|
setState(429);
|
|
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 EnumConstantsContext 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(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public EnumConstantsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstants; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnumConstants(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnumConstants(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnumConstants(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final EnumConstantsContext enumConstants() throws RecognitionException {
|
|
EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());
|
|
enterRule(_localctx, 24, RULE_enumConstants);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(431);
|
|
enumConstant();
|
|
setState(436);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(432);
|
|
match(COMMA);
|
|
setState(433);
|
|
enumConstant();
|
|
}
|
|
}
|
|
}
|
|
setState(438);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,26,_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 IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public ArgumentsContext arguments() {
|
|
return getRuleContext(ArgumentsContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enumConstant; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnumConstant(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnumConstant(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnumConstant(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final EnumConstantContext enumConstant() throws RecognitionException {
|
|
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
|
|
enterRule(_localctx, 26, RULE_enumConstant);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(442);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(439);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(444);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
|
|
}
|
|
setState(445);
|
|
identifier();
|
|
setState(447);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LPAREN) {
|
|
{
|
|
setState(446);
|
|
arguments();
|
|
}
|
|
}
|
|
|
|
setState(450);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LBRACE) {
|
|
{
|
|
setState(449);
|
|
classBody();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
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(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnumBodyDeclarations(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnumBodyDeclarations(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnumBodyDeclarations(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
|
|
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
|
|
enterRule(_localctx, 28, RULE_enumBodyDeclarations);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(452);
|
|
match(SEMI);
|
|
setState(456);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -665791937994347L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660685729789L) != 0)) {
|
|
{
|
|
{
|
|
setState(453);
|
|
classBodyDeclaration();
|
|
}
|
|
}
|
|
setState(458);
|
|
_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 TerminalNode INTERFACE() { return getToken(Java17Parser.INTERFACE, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public InterfaceBodyContext interfaceBody() {
|
|
return getRuleContext(InterfaceBodyContext.class,0);
|
|
}
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public TerminalNode EXTENDS() { return getToken(Java17Parser.EXTENDS, 0); }
|
|
public List<TypeListContext> typeList() {
|
|
return getRuleContexts(TypeListContext.class);
|
|
}
|
|
public TypeListContext typeList(int i) {
|
|
return getRuleContext(TypeListContext.class,i);
|
|
}
|
|
public TerminalNode PERMITS() { return getToken(Java17Parser.PERMITS, 0); }
|
|
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
|
|
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 30, RULE_interfaceDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(459);
|
|
match(INTERFACE);
|
|
setState(460);
|
|
identifier();
|
|
setState(462);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(461);
|
|
genericDeclarationList();
|
|
}
|
|
}
|
|
|
|
setState(466);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==EXTENDS) {
|
|
{
|
|
setState(464);
|
|
match(EXTENDS);
|
|
setState(465);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(470);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==PERMITS) {
|
|
{
|
|
setState(468);
|
|
match(PERMITS);
|
|
setState(469);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(472);
|
|
interfaceBody();
|
|
}
|
|
}
|
|
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(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassBodyContext classBody() throws RecognitionException {
|
|
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 32, RULE_classBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(474);
|
|
match(LBRACE);
|
|
setState(478);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -665791937994347L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660685729789L) != 0)) {
|
|
{
|
|
{
|
|
setState(475);
|
|
classBodyDeclaration();
|
|
}
|
|
}
|
|
setState(480);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(481);
|
|
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 InterfaceBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<InterfaceBodyDeclarationContext> interfaceBodyDeclaration() {
|
|
return getRuleContexts(InterfaceBodyDeclarationContext.class);
|
|
}
|
|
public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) {
|
|
return getRuleContext(InterfaceBodyDeclarationContext.class,i);
|
|
}
|
|
public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceBody; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
|
|
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 34, RULE_interfaceBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(483);
|
|
match(LBRACE);
|
|
setState(487);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -665791937992299L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660685762557L) != 0)) {
|
|
{
|
|
{
|
|
setState(484);
|
|
interfaceBodyDeclaration();
|
|
}
|
|
}
|
|
setState(489);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(490);
|
|
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 ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
|
|
|
|
public ClassBodyDeclarationContext() { }
|
|
public void copyFrom(ClassBodyDeclarationContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EmptyclassbodyContext extends ClassBodyDeclarationContext {
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public EmptyclassbodyContext(ClassBodyDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEmptyclassbody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEmptyclassbody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEmptyclassbody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MemberdeclContext extends ClassBodyDeclarationContext {
|
|
public MemberDeclarationContext memberDeclaration() {
|
|
return getRuleContext(MemberDeclarationContext.class,0);
|
|
}
|
|
public List<ModifierContext> modifier() {
|
|
return getRuleContexts(ModifierContext.class);
|
|
}
|
|
public ModifierContext modifier(int i) {
|
|
return getRuleContext(ModifierContext.class,i);
|
|
}
|
|
public MemberdeclContext(ClassBodyDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMemberdecl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMemberdecl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMemberdecl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassblockContext extends ClassBodyDeclarationContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public TerminalNode STATIC() { return getToken(Java17Parser.STATIC, 0); }
|
|
public ClassblockContext(ClassBodyDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassblock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassblock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassblock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
|
|
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 36, RULE_classBodyDeclaration);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
setState(504);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
|
|
case 1:
|
|
_localctx = new EmptyclassbodyContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(492);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new ClassblockContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(494);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==STATIC) {
|
|
{
|
|
setState(493);
|
|
match(STATIC);
|
|
}
|
|
}
|
|
|
|
setState(496);
|
|
block();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new MemberdeclContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(500);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(497);
|
|
modifier();
|
|
}
|
|
}
|
|
}
|
|
setState(502);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
|
|
}
|
|
setState(503);
|
|
memberDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MemberDeclarationContext extends ParserRuleContext {
|
|
public MemberDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_memberDeclaration; }
|
|
|
|
public MemberDeclarationContext() { }
|
|
public void copyFrom(MemberDeclarationContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MembermethodContext extends MemberDeclarationContext {
|
|
public MethodContext method() {
|
|
return getRuleContext(MethodContext.class,0);
|
|
}
|
|
public MembermethodContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMembermethod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMembermethod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMembermethod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MemberconstructorContext extends MemberDeclarationContext {
|
|
public ConstructorContext constructor() {
|
|
return getRuleContext(ConstructorContext.class,0);
|
|
}
|
|
public MemberconstructorContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMemberconstructor(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMemberconstructor(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMemberconstructor(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MemberclassorinterfaceContext extends MemberDeclarationContext {
|
|
public ClassOrInterfaceContext classOrInterface() {
|
|
return getRuleContext(ClassOrInterfaceContext.class,0);
|
|
}
|
|
public MemberclassorinterfaceContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMemberclassorinterface(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMemberclassorinterface(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMemberclassorinterface(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MemberfieldContext extends MemberDeclarationContext {
|
|
public FieldDeclarationContext fieldDeclaration() {
|
|
return getRuleContext(FieldDeclarationContext.class,0);
|
|
}
|
|
public MemberfieldContext(MemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMemberfield(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMemberfield(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMemberfield(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MemberDeclarationContext memberDeclaration() throws RecognitionException {
|
|
MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 38, RULE_memberDeclaration);
|
|
try {
|
|
setState(510);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
|
|
case 1:
|
|
_localctx = new MemberclassorinterfaceContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(506);
|
|
classOrInterface();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new MemberfieldContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(507);
|
|
fieldDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new MembermethodContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(508);
|
|
method();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new MemberconstructorContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(509);
|
|
constructor();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodContext extends ParserRuleContext {
|
|
public MethodContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_method; }
|
|
|
|
public MethodContext() { }
|
|
public void copyFrom(MethodContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethoddeclContext extends MethodContext {
|
|
public MethodDeclarationContext methodDeclaration() {
|
|
return getRuleContext(MethodDeclarationContext.class,0);
|
|
}
|
|
public MethoddeclContext(MethodContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethoddecl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethoddecl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethoddecl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GenericmethodContext extends MethodContext {
|
|
public GenericMethodDeclarationContext genericMethodDeclaration() {
|
|
return getRuleContext(GenericMethodDeclarationContext.class,0);
|
|
}
|
|
public GenericmethodContext(MethodContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericmethod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericmethod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericmethod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MethodContext method() throws RecognitionException {
|
|
MethodContext _localctx = new MethodContext(_ctx, getState());
|
|
enterRule(_localctx, 40, RULE_method);
|
|
try {
|
|
setState(514);
|
|
_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 MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
_localctx = new MethoddeclContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(512);
|
|
methodDeclaration();
|
|
}
|
|
break;
|
|
case LT:
|
|
_localctx = new GenericmethodContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(513);
|
|
genericMethodDeclaration();
|
|
}
|
|
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 MethodDeclarationContext extends ParserRuleContext {
|
|
public MethodHeaderContext methodHeader() {
|
|
return getRuleContext(MethodHeaderContext.class,0);
|
|
}
|
|
public MethodBodyContext methodBody() {
|
|
return getRuleContext(MethodBodyContext.class,0);
|
|
}
|
|
public TerminalNode THROWS() { return getToken(Java17Parser.THROWS, 0); }
|
|
public ExceptionListContext exceptionList() {
|
|
return getRuleContext(ExceptionListContext.class,0);
|
|
}
|
|
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
|
|
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 42, RULE_methodDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(516);
|
|
methodHeader();
|
|
setState(519);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(517);
|
|
match(THROWS);
|
|
setState(518);
|
|
exceptionList();
|
|
}
|
|
}
|
|
|
|
setState(521);
|
|
methodBody();
|
|
}
|
|
}
|
|
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 IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public FormalParametersContext formalParameters() {
|
|
return getRuleContext(FormalParametersContext.class,0);
|
|
}
|
|
public RefTypeContext refType() {
|
|
return getRuleContext(RefTypeContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodHeader; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodHeader(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodHeader(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodHeader(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MethodHeaderContext methodHeader() throws RecognitionException {
|
|
MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
|
|
enterRule(_localctx, 44, RULE_methodHeader);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(524);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(523);
|
|
refType();
|
|
}
|
|
break;
|
|
}
|
|
setState(526);
|
|
identifier();
|
|
setState(527);
|
|
formalParameters();
|
|
setState(532);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(528);
|
|
match(LBRACK);
|
|
setState(529);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(534);
|
|
_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 MethodBodyContext extends ParserRuleContext {
|
|
public MethodBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodBody; }
|
|
|
|
public MethodBodyContext() { }
|
|
public void copyFrom(MethodBodyContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodblockContext extends MethodBodyContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public MethodblockContext(MethodBodyContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodblock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodblock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodblock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EmptymethodContext extends MethodBodyContext {
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public EmptymethodContext(MethodBodyContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEmptymethod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEmptymethod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEmptymethod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MethodBodyContext methodBody() throws RecognitionException {
|
|
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 46, RULE_methodBody);
|
|
try {
|
|
setState(537);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
_localctx = new MethodblockContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(535);
|
|
block();
|
|
}
|
|
break;
|
|
case SEMI:
|
|
_localctx = new EmptymethodContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(536);
|
|
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 RefTypeContext extends ParserRuleContext {
|
|
public RefTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_refType; }
|
|
|
|
public RefTypeContext() { }
|
|
public void copyFrom(RefTypeContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RefvoidContext extends RefTypeContext {
|
|
public TerminalNode VOID() { return getToken(Java17Parser.VOID, 0); }
|
|
public RefvoidContext(RefTypeContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRefvoid(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRefvoid(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRefvoid(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RefType2Context extends RefTypeContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public RefType2Context(RefTypeContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRefType2(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRefType2(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRefType2(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RefTypeContext refType() throws RecognitionException {
|
|
RefTypeContext _localctx = new RefTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 48, RULE_refType);
|
|
try {
|
|
setState(541);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
_localctx = new RefType2Context(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(539);
|
|
typeType();
|
|
}
|
|
break;
|
|
case VOID:
|
|
_localctx = new RefvoidContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(540);
|
|
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 GenericMethodDeclarationContext extends ParserRuleContext {
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public MethodDeclarationContext methodDeclaration() {
|
|
return getRuleContext(MethodDeclarationContext.class,0);
|
|
}
|
|
public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_genericMethodDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericMethodDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException {
|
|
GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 50, RULE_genericMethodDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(543);
|
|
genericDeclarationList();
|
|
setState(544);
|
|
methodDeclaration();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructorContext extends ParserRuleContext {
|
|
public ConstructorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructor; }
|
|
|
|
public ConstructorContext() { }
|
|
public void copyFrom(ConstructorContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstructordeclContext extends ConstructorContext {
|
|
public ConstructorDeclarationContext constructorDeclaration() {
|
|
return getRuleContext(ConstructorDeclarationContext.class,0);
|
|
}
|
|
public ConstructordeclContext(ConstructorContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConstructordecl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConstructordecl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConstructordecl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GenericconstructorContext extends ConstructorContext {
|
|
public GenericConstructorDeclarationContext genericConstructorDeclaration() {
|
|
return getRuleContext(GenericConstructorDeclarationContext.class,0);
|
|
}
|
|
public GenericconstructorContext(ConstructorContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericconstructor(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericconstructor(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericconstructor(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ConstructorContext constructor() throws RecognitionException {
|
|
ConstructorContext _localctx = new ConstructorContext(_ctx, getState());
|
|
enterRule(_localctx, 52, RULE_constructor);
|
|
try {
|
|
setState(548);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LT:
|
|
_localctx = new GenericconstructorContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(546);
|
|
genericConstructorDeclaration();
|
|
}
|
|
break;
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
_localctx = new ConstructordeclContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(547);
|
|
constructorDeclaration();
|
|
}
|
|
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 GenericConstructorDeclarationContext extends ParserRuleContext {
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public ConstructorDeclarationContext constructorDeclaration() {
|
|
return getRuleContext(ConstructorDeclarationContext.class,0);
|
|
}
|
|
public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericConstructorDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericConstructorDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericConstructorDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException {
|
|
GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 54, RULE_genericConstructorDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(550);
|
|
genericDeclarationList();
|
|
setState(551);
|
|
constructorDeclaration();
|
|
}
|
|
}
|
|
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 BlockContext constructorBody;
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public FormalParametersContext formalParameters() {
|
|
return getRuleContext(FormalParametersContext.class,0);
|
|
}
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public TerminalNode THROWS() { return getToken(Java17Parser.THROWS, 0); }
|
|
public ExceptionListContext exceptionList() {
|
|
return getRuleContext(ExceptionListContext.class,0);
|
|
}
|
|
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConstructorDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConstructorDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConstructorDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
|
|
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 56, RULE_constructorDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(553);
|
|
identifier();
|
|
setState(554);
|
|
formalParameters();
|
|
setState(557);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(555);
|
|
match(THROWS);
|
|
setState(556);
|
|
exceptionList();
|
|
}
|
|
}
|
|
|
|
setState(559);
|
|
((ConstructorDeclarationContext)_localctx).constructorBody = block();
|
|
}
|
|
}
|
|
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 VariableDeclaratorsContext variableDeclarators() {
|
|
return getRuleContext(VariableDeclaratorsContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFieldDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFieldDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFieldDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
|
|
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 58, RULE_fieldDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(562);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(561);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(564);
|
|
variableDeclarators();
|
|
setState(565);
|
|
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 InterfaceBodyDeclarationContext extends ParserRuleContext {
|
|
public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; }
|
|
|
|
public InterfaceBodyDeclarationContext() { }
|
|
public void copyFrom(InterfaceBodyDeclarationContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EmptyinterfaceContext extends InterfaceBodyDeclarationContext {
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public EmptyinterfaceContext(InterfaceBodyDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEmptyinterface(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEmptyinterface(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEmptyinterface(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfacememberContext extends InterfaceBodyDeclarationContext {
|
|
public InterfaceMemberDeclarationContext interfaceMemberDeclaration() {
|
|
return getRuleContext(InterfaceMemberDeclarationContext.class,0);
|
|
}
|
|
public List<ModifierContext> modifier() {
|
|
return getRuleContexts(ModifierContext.class);
|
|
}
|
|
public ModifierContext modifier(int i) {
|
|
return getRuleContext(ModifierContext.class,i);
|
|
}
|
|
public InterfacememberContext(InterfaceBodyDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfacemember(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfacemember(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfacemember(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException {
|
|
InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 60, RULE_interfaceBodyDeclaration);
|
|
try {
|
|
int _alt;
|
|
setState(575);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) {
|
|
case 1:
|
|
_localctx = new InterfacememberContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(570);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(567);
|
|
modifier();
|
|
}
|
|
}
|
|
}
|
|
setState(572);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,49,_ctx);
|
|
}
|
|
setState(573);
|
|
interfaceMemberDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new EmptyinterfaceContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(574);
|
|
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 InterfaceMemberDeclarationContext extends ParserRuleContext {
|
|
public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
|
|
|
|
public InterfaceMemberDeclarationContext() { }
|
|
public void copyFrom(InterfaceMemberDeclarationContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfacemethodContext extends InterfaceMemberDeclarationContext {
|
|
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
|
|
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
|
|
}
|
|
public InterfacemethodContext(InterfaceMemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfacemethod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfacemethod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfacemethod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SubclassorinterfaceContext extends InterfaceMemberDeclarationContext {
|
|
public ClassOrInterfaceContext classOrInterface() {
|
|
return getRuleContext(ClassOrInterfaceContext.class,0);
|
|
}
|
|
public SubclassorinterfaceContext(InterfaceMemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSubclassorinterface(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSubclassorinterface(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSubclassorinterface(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceconstContext extends InterfaceMemberDeclarationContext {
|
|
public ConstDeclarationContext constDeclaration() {
|
|
return getRuleContext(ConstDeclarationContext.class,0);
|
|
}
|
|
public InterfaceconstContext(InterfaceMemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceconst(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceconst(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceconst(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GenericinterfacemethodContext extends InterfaceMemberDeclarationContext {
|
|
public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() {
|
|
return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0);
|
|
}
|
|
public GenericinterfacemethodContext(InterfaceMemberDeclarationContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericinterfacemethod(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericinterfacemethod(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericinterfacemethod(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
|
|
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 62, RULE_interfaceMemberDeclaration);
|
|
try {
|
|
setState(581);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
|
|
case 1:
|
|
_localctx = new InterfaceconstContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(577);
|
|
constDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new InterfacemethodContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(578);
|
|
interfaceMethodDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new GenericinterfacemethodContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(579);
|
|
genericInterfaceMethodDeclaration();
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new SubclassorinterfaceContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(580);
|
|
classOrInterface();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConstDeclarationContext extends ParserRuleContext {
|
|
public List<ConstantDeclaratorContext> constantDeclarator() {
|
|
return getRuleContexts(ConstantDeclaratorContext.class);
|
|
}
|
|
public ConstantDeclaratorContext constantDeclarator(int i) {
|
|
return getRuleContext(ConstantDeclaratorContext.class,i);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public ConstDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConstDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConstDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConstDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ConstDeclarationContext constDeclaration() throws RecognitionException {
|
|
ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 64, RULE_constDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(584);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(583);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(586);
|
|
constantDeclarator();
|
|
setState(591);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(587);
|
|
match(COMMA);
|
|
setState(588);
|
|
constantDeclarator();
|
|
}
|
|
}
|
|
setState(593);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(594);
|
|
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 ConstantDeclaratorContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode ASSIGN() { return getToken(Java17Parser.ASSIGN, 0); }
|
|
public VariableInitializerContext variableInitializer() {
|
|
return getRuleContext(VariableInitializerContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_constantDeclarator; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConstantDeclarator(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConstantDeclarator(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConstantDeclarator(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException {
|
|
ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState());
|
|
enterRule(_localctx, 66, RULE_constantDeclarator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(596);
|
|
identifier();
|
|
setState(601);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(597);
|
|
match(LBRACK);
|
|
setState(598);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(603);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(604);
|
|
match(ASSIGN);
|
|
setState(605);
|
|
variableInitializer();
|
|
}
|
|
}
|
|
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 InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() {
|
|
return getRuleContext(InterfaceCommonBodyDeclarationContext.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceMethodDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
|
|
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 68, RULE_interfaceMethodDeclaration);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(610);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(607);
|
|
interfaceMethodModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(612);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
|
|
}
|
|
setState(613);
|
|
interfaceCommonBodyDeclaration();
|
|
}
|
|
}
|
|
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(Java17Parser.PUBLIC, 0); }
|
|
public TerminalNode ABSTRACT() { return getToken(Java17Parser.ABSTRACT, 0); }
|
|
public TerminalNode DEFAULT() { return getToken(Java17Parser.DEFAULT, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java17Parser.STATIC, 0); }
|
|
public TerminalNode STRICTFP() { return getToken(Java17Parser.STRICTFP, 0); }
|
|
public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceMethodModifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceMethodModifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceMethodModifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
|
|
InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 70, RULE_interfaceMethodModifier);
|
|
try {
|
|
setState(621);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(615);
|
|
annotation();
|
|
}
|
|
break;
|
|
case PUBLIC:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(616);
|
|
match(PUBLIC);
|
|
}
|
|
break;
|
|
case ABSTRACT:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(617);
|
|
match(ABSTRACT);
|
|
}
|
|
break;
|
|
case DEFAULT:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(618);
|
|
match(DEFAULT);
|
|
}
|
|
break;
|
|
case STATIC:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(619);
|
|
match(STATIC);
|
|
}
|
|
break;
|
|
case STRICTFP:
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(620);
|
|
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 GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() {
|
|
return getRuleContext(InterfaceCommonBodyDeclarationContext.class,0);
|
|
}
|
|
public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
|
|
return getRuleContexts(InterfaceMethodModifierContext.class);
|
|
}
|
|
public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
|
|
return getRuleContext(InterfaceMethodModifierContext.class,i);
|
|
}
|
|
public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGenericInterfaceMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGenericInterfaceMethodDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGenericInterfaceMethodDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException {
|
|
GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 72, RULE_genericInterfaceMethodDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(626);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -1125470410110975L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660703064063L) != 0)) {
|
|
{
|
|
{
|
|
setState(623);
|
|
interfaceMethodModifier();
|
|
}
|
|
}
|
|
setState(628);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(629);
|
|
genericDeclarationList();
|
|
setState(630);
|
|
interfaceCommonBodyDeclaration();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InterfaceCommonBodyDeclarationContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public FormalParametersContext formalParameters() {
|
|
return getRuleContext(FormalParametersContext.class,0);
|
|
}
|
|
public MethodBodyContext methodBody() {
|
|
return getRuleContext(MethodBodyContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public RefTypeContext refType() {
|
|
return getRuleContext(RefTypeContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public TerminalNode THROWS() { return getToken(Java17Parser.THROWS, 0); }
|
|
public ExceptionListContext exceptionList() {
|
|
return getRuleContext(ExceptionListContext.class,0);
|
|
}
|
|
public InterfaceCommonBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_interfaceCommonBodyDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInterfaceCommonBodyDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInterfaceCommonBodyDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInterfaceCommonBodyDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() throws RecognitionException {
|
|
InterfaceCommonBodyDeclarationContext _localctx = new InterfaceCommonBodyDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 74, RULE_interfaceCommonBodyDeclaration);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(635);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(632);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(637);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
|
|
}
|
|
setState(639);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(638);
|
|
refType();
|
|
}
|
|
break;
|
|
}
|
|
setState(641);
|
|
identifier();
|
|
setState(642);
|
|
formalParameters();
|
|
setState(647);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(643);
|
|
match(LBRACK);
|
|
setState(644);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(649);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(652);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==THROWS) {
|
|
{
|
|
setState(650);
|
|
match(THROWS);
|
|
setState(651);
|
|
exceptionList();
|
|
}
|
|
}
|
|
|
|
setState(654);
|
|
methodBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class VariableDeclaratorsContext 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(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableDeclarators; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterVariableDeclarators(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitVariableDeclarators(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitVariableDeclarators(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException {
|
|
VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState());
|
|
enterRule(_localctx, 76, RULE_variableDeclarators);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(656);
|
|
variableDeclarator();
|
|
setState(661);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(657);
|
|
match(COMMA);
|
|
setState(658);
|
|
variableDeclarator();
|
|
}
|
|
}
|
|
setState(663);
|
|
_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(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterVariableDeclarator(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitVariableDeclarator(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitVariableDeclarator(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
|
|
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
|
|
enterRule(_localctx, 78, RULE_variableDeclarator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(664);
|
|
variableDeclaratorId();
|
|
setState(667);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==ASSIGN) {
|
|
{
|
|
setState(665);
|
|
match(ASSIGN);
|
|
setState(666);
|
|
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 IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterVariableDeclaratorId(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitVariableDeclaratorId(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitVariableDeclaratorId(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
|
|
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
|
|
enterRule(_localctx, 80, RULE_variableDeclaratorId);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(669);
|
|
identifier();
|
|
setState(674);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(670);
|
|
match(LBRACK);
|
|
setState(671);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(676);
|
|
_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 VariableInitializerContext extends ParserRuleContext {
|
|
public ArrayInitializerContext arrayInitializer() {
|
|
return getRuleContext(ArrayInitializerContext.class,0);
|
|
}
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_variableInitializer; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterVariableInitializer(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitVariableInitializer(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitVariableInitializer(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final VariableInitializerContext variableInitializer() throws RecognitionException {
|
|
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 82, RULE_variableInitializer);
|
|
try {
|
|
setState(679);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(677);
|
|
arrayInitializer();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case NEW:
|
|
case SHORT:
|
|
case SUPER:
|
|
case SWITCH:
|
|
case THIS:
|
|
case VOID:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case DECIMAL_LITERAL:
|
|
case HEX_LITERAL:
|
|
case OCT_LITERAL:
|
|
case BINARY_LITERAL:
|
|
case FLOAT_LITERAL:
|
|
case HEX_FLOAT_LITERAL:
|
|
case BOOL_LITERAL:
|
|
case CHAR_LITERAL:
|
|
case STRING_LITERAL:
|
|
case TEXT_BLOCK:
|
|
case NULL_LITERAL:
|
|
case LPAREN:
|
|
case LT:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(678);
|
|
expression(0);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayInitializerContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<VariableInitializerContext> variableInitializer() {
|
|
return getRuleContexts(VariableInitializerContext.class);
|
|
}
|
|
public VariableInitializerContext variableInitializer(int i) {
|
|
return getRuleContext(VariableInitializerContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayInitializer; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterArrayInitializer(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitArrayInitializer(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitArrayInitializer(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
|
|
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 84, RULE_arrayInitializer);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(681);
|
|
match(LBRACE);
|
|
setState(693);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130013183L) != 0)) {
|
|
{
|
|
setState(682);
|
|
variableInitializer();
|
|
setState(687);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(683);
|
|
match(COMMA);
|
|
setState(684);
|
|
variableInitializer();
|
|
}
|
|
}
|
|
}
|
|
setState(689);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
|
|
}
|
|
setState(691);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(690);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
setState(695);
|
|
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 ClassOrInterfaceTypeContext extends ParserRuleContext {
|
|
public TypeIdentifierContext typeIdentifier() {
|
|
return getRuleContext(TypeIdentifierContext.class,0);
|
|
}
|
|
public List<IdentifierContext> identifier() {
|
|
return getRuleContexts(IdentifierContext.class);
|
|
}
|
|
public IdentifierContext identifier(int i) {
|
|
return getRuleContext(IdentifierContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java17Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java17Parser.DOT, i);
|
|
}
|
|
public List<TypeArgumentsContext> typeArguments() {
|
|
return getRuleContexts(TypeArgumentsContext.class);
|
|
}
|
|
public TypeArgumentsContext typeArguments(int i) {
|
|
return getRuleContext(TypeArgumentsContext.class,i);
|
|
}
|
|
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassOrInterfaceType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassOrInterfaceType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassOrInterfaceType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
|
|
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 86, RULE_classOrInterfaceType);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(705);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(697);
|
|
identifier();
|
|
setState(699);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(698);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(701);
|
|
match(DOT);
|
|
}
|
|
}
|
|
}
|
|
setState(707);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
|
|
}
|
|
setState(708);
|
|
typeIdentifier();
|
|
setState(710);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(709);
|
|
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 TypeArgumentContext extends ParserRuleContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public WildcardTypeContext wildcardType() {
|
|
return getRuleContext(WildcardTypeContext.class,0);
|
|
}
|
|
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArgument; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeArgument(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeArgument(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeArgument(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeArgumentContext typeArgument() throws RecognitionException {
|
|
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
|
|
enterRule(_localctx, 88, RULE_typeArgument);
|
|
try {
|
|
setState(714);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(712);
|
|
typeType();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(713);
|
|
wildcardType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WildcardTypeContext extends ParserRuleContext {
|
|
public TerminalNode QUESTION() { return getToken(Java17Parser.QUESTION, 0); }
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public ExtendsWildcardTypeContext extendsWildcardType() {
|
|
return getRuleContext(ExtendsWildcardTypeContext.class,0);
|
|
}
|
|
public SuperWildcardTypeContext superWildcardType() {
|
|
return getRuleContext(SuperWildcardTypeContext.class,0);
|
|
}
|
|
public WildcardTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_wildcardType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterWildcardType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitWildcardType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitWildcardType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final WildcardTypeContext wildcardType() throws RecognitionException {
|
|
WildcardTypeContext _localctx = new WildcardTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 90, RULE_wildcardType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(719);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(716);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(721);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(722);
|
|
match(QUESTION);
|
|
setState(725);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case EXTENDS:
|
|
{
|
|
setState(723);
|
|
extendsWildcardType();
|
|
}
|
|
break;
|
|
case SUPER:
|
|
{
|
|
setState(724);
|
|
superWildcardType();
|
|
}
|
|
break;
|
|
case COMMA:
|
|
case GT:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExtendsWildcardTypeContext extends ParserRuleContext {
|
|
public TerminalNode EXTENDS() { return getToken(Java17Parser.EXTENDS, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public ExtendsWildcardTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_extendsWildcardType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterExtendsWildcardType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitExtendsWildcardType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitExtendsWildcardType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExtendsWildcardTypeContext extendsWildcardType() throws RecognitionException {
|
|
ExtendsWildcardTypeContext _localctx = new ExtendsWildcardTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 92, RULE_extendsWildcardType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(727);
|
|
match(EXTENDS);
|
|
setState(728);
|
|
typeType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SuperWildcardTypeContext extends ParserRuleContext {
|
|
public TerminalNode SUPER() { return getToken(Java17Parser.SUPER, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public SuperWildcardTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_superWildcardType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSuperWildcardType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSuperWildcardType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSuperWildcardType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SuperWildcardTypeContext superWildcardType() throws RecognitionException {
|
|
SuperWildcardTypeContext _localctx = new SuperWildcardTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 94, RULE_superWildcardType);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(730);
|
|
match(SUPER);
|
|
setState(731);
|
|
typeType();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class QualifiedNameListContext extends ParserRuleContext {
|
|
public List<QualifiedNameContext> qualifiedName() {
|
|
return getRuleContexts(QualifiedNameContext.class);
|
|
}
|
|
public QualifiedNameContext qualifiedName(int i) {
|
|
return getRuleContext(QualifiedNameContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public QualifiedNameListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_qualifiedNameList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterQualifiedNameList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitQualifiedNameList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitQualifiedNameList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
|
|
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState());
|
|
enterRule(_localctx, 96, RULE_qualifiedNameList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(733);
|
|
qualifiedName();
|
|
setState(738);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(734);
|
|
match(COMMA);
|
|
setState(735);
|
|
qualifiedName();
|
|
}
|
|
}
|
|
setState(740);
|
|
_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 ExceptionListContext extends ParserRuleContext {
|
|
public QualifiedNameListContext qualifiedNameList() {
|
|
return getRuleContext(QualifiedNameListContext.class,0);
|
|
}
|
|
public ExceptionListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_exceptionList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterExceptionList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitExceptionList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitExceptionList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExceptionListContext exceptionList() throws RecognitionException {
|
|
ExceptionListContext _localctx = new ExceptionListContext(_ctx, getState());
|
|
enterRule(_localctx, 98, RULE_exceptionList);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(741);
|
|
qualifiedNameList();
|
|
}
|
|
}
|
|
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 TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ReceiverParameterContext receiverParameter() {
|
|
return getRuleContext(ReceiverParameterContext.class,0);
|
|
}
|
|
public TerminalNode COMMA() { return getToken(Java17Parser.COMMA, 0); }
|
|
public FormalParameterListContext formalParameterList() {
|
|
return getRuleContext(FormalParameterListContext.class,0);
|
|
}
|
|
public FormalParametersContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_formalParameters; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFormalParameters(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFormalParameters(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFormalParameters(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FormalParametersContext formalParameters() throws RecognitionException {
|
|
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
|
|
enterRule(_localctx, 100, RULE_formalParameters);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(743);
|
|
match(LPAREN);
|
|
setState(755);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(745);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223091678653581349L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
setState(744);
|
|
receiverParameter();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(747);
|
|
receiverParameter();
|
|
setState(750);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(748);
|
|
match(COMMA);
|
|
setState(749);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
setState(753);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223090579141986341L) != 0) || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 1231453023109121L) != 0)) {
|
|
{
|
|
setState(752);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
setState(757);
|
|
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 ReceiverParameterContext extends ParserRuleContext {
|
|
public TerminalNode THIS() { return getToken(Java17Parser.THIS, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public List<IdentifierContext> identifier() {
|
|
return getRuleContexts(IdentifierContext.class);
|
|
}
|
|
public IdentifierContext identifier(int i) {
|
|
return getRuleContext(IdentifierContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java17Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java17Parser.DOT, i);
|
|
}
|
|
public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_receiverParameter; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterReceiverParameter(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitReceiverParameter(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitReceiverParameter(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ReceiverParameterContext receiverParameter() throws RecognitionException {
|
|
ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 102, RULE_receiverParameter);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(760);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(759);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(767);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(762);
|
|
identifier();
|
|
setState(763);
|
|
match(DOT);
|
|
}
|
|
}
|
|
setState(769);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(770);
|
|
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 FormalParameterListContext 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(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public LastFormalParameterContext lastFormalParameter() {
|
|
return getRuleContext(LastFormalParameterContext.class,0);
|
|
}
|
|
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_formalParameterList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFormalParameterList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFormalParameterList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFormalParameterList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FormalParameterListContext formalParameterList() throws RecognitionException {
|
|
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
|
|
enterRule(_localctx, 104, RULE_formalParameterList);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
setState(785);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(772);
|
|
formalParameter();
|
|
setState(777);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,82,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(773);
|
|
match(COMMA);
|
|
setState(774);
|
|
formalParameter();
|
|
}
|
|
}
|
|
}
|
|
setState(779);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,82,_ctx);
|
|
}
|
|
setState(782);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(780);
|
|
match(COMMA);
|
|
setState(781);
|
|
lastFormalParameter();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(784);
|
|
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 FormalParameterContext extends ParserRuleContext {
|
|
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 TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public FormalParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_formalParameter; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFormalParameter(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFormalParameter(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFormalParameter(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FormalParameterContext formalParameter() throws RecognitionException {
|
|
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 106, RULE_formalParameter);
|
|
try {
|
|
int _alt;
|
|
setState(798);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(790);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(787);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(792);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
|
|
}
|
|
setState(794);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(793);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(796);
|
|
variableDeclaratorId();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(797);
|
|
pattern();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
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 TerminalNode ELLIPSIS() { return getToken(Java17Parser.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 TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLastFormalParameter(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLastFormalParameter(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLastFormalParameter(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
|
|
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 108, RULE_lastFormalParameter);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(803);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,88,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(800);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(805);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,88,_ctx);
|
|
}
|
|
setState(807);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(806);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(812);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(809);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(814);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(815);
|
|
match(ELLIPSIS);
|
|
setState(816);
|
|
variableDeclaratorId();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LambdaLVTIListContext extends ParserRuleContext {
|
|
public List<LambdaLVTIParameterContext> lambdaLVTIParameter() {
|
|
return getRuleContexts(LambdaLVTIParameterContext.class);
|
|
}
|
|
public LambdaLVTIParameterContext lambdaLVTIParameter(int i) {
|
|
return getRuleContext(LambdaLVTIParameterContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public LambdaLVTIListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaLVTIList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaLVTIList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaLVTIList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaLVTIList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LambdaLVTIListContext lambdaLVTIList() throws RecognitionException {
|
|
LambdaLVTIListContext _localctx = new LambdaLVTIListContext(_ctx, getState());
|
|
enterRule(_localctx, 110, RULE_lambdaLVTIList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(818);
|
|
lambdaLVTIParameter();
|
|
setState(823);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(819);
|
|
match(COMMA);
|
|
setState(820);
|
|
lambdaLVTIParameter();
|
|
}
|
|
}
|
|
setState(825);
|
|
_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 LambdaLVTIParameterContext extends ParserRuleContext {
|
|
public TerminalNode VAR() { return getToken(Java17Parser.VAR, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public LambdaLVTIParameterContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaLVTIParameter; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaLVTIParameter(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaLVTIParameter(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaLVTIParameter(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LambdaLVTIParameterContext lambdaLVTIParameter() throws RecognitionException {
|
|
LambdaLVTIParameterContext _localctx = new LambdaLVTIParameterContext(_ctx, getState());
|
|
enterRule(_localctx, 112, RULE_lambdaLVTIParameter);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(829);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(826);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(831);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
|
|
}
|
|
setState(832);
|
|
match(VAR);
|
|
setState(833);
|
|
identifier();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class QualifiedNameContext extends ParserRuleContext {
|
|
public List<IdentifierContext> identifier() {
|
|
return getRuleContexts(IdentifierContext.class);
|
|
}
|
|
public IdentifierContext identifier(int i) {
|
|
return getRuleContext(IdentifierContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java17Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java17Parser.DOT, i);
|
|
}
|
|
public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_qualifiedName; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterQualifiedName(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitQualifiedName(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitQualifiedName(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final QualifiedNameContext qualifiedName() throws RecognitionException {
|
|
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
|
|
enterRule(_localctx, 114, RULE_qualifiedName);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(835);
|
|
identifier();
|
|
setState(840);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(836);
|
|
match(DOT);
|
|
setState(837);
|
|
identifier();
|
|
}
|
|
}
|
|
}
|
|
setState(842);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LiteralContext extends ParserRuleContext {
|
|
public LiteralContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_literal; }
|
|
|
|
public LiteralContext() { }
|
|
public void copyFrom(LiteralContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class FltLiteralContext extends LiteralContext {
|
|
public FloatLiteralContext floatLiteral() {
|
|
return getRuleContext(FloatLiteralContext.class,0);
|
|
}
|
|
public FltLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFltLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFltLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFltLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NullLiteralContext extends LiteralContext {
|
|
public TerminalNode NULL_LITERAL() { return getToken(Java17Parser.NULL_LITERAL, 0); }
|
|
public NullLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterNullLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitNullLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitNullLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StringLiteralContext extends LiteralContext {
|
|
public TerminalNode STRING_LITERAL() { return getToken(Java17Parser.STRING_LITERAL, 0); }
|
|
public StringLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterStringLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitStringLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitStringLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IntLiteralContext extends LiteralContext {
|
|
public IntegerLiteralContext integerLiteral() {
|
|
return getRuleContext(IntegerLiteralContext.class,0);
|
|
}
|
|
public IntLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterIntLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitIntLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitIntLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CharLiteralContext extends LiteralContext {
|
|
public TerminalNode CHAR_LITERAL() { return getToken(Java17Parser.CHAR_LITERAL, 0); }
|
|
public CharLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCharLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCharLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCharLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TextBlockContext extends LiteralContext {
|
|
public TerminalNode TEXT_BLOCK() { return getToken(Java17Parser.TEXT_BLOCK, 0); }
|
|
public TextBlockContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTextBlock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTextBlock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTextBlock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BoolLiteralContext extends LiteralContext {
|
|
public TerminalNode BOOL_LITERAL() { return getToken(Java17Parser.BOOL_LITERAL, 0); }
|
|
public BoolLiteralContext(LiteralContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBoolLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBoolLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBoolLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LiteralContext literal() throws RecognitionException {
|
|
LiteralContext _localctx = new LiteralContext(_ctx, getState());
|
|
enterRule(_localctx, 116, RULE_literal);
|
|
try {
|
|
setState(850);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case DECIMAL_LITERAL:
|
|
case HEX_LITERAL:
|
|
case OCT_LITERAL:
|
|
case BINARY_LITERAL:
|
|
_localctx = new IntLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(843);
|
|
integerLiteral();
|
|
}
|
|
break;
|
|
case FLOAT_LITERAL:
|
|
case HEX_FLOAT_LITERAL:
|
|
_localctx = new FltLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(844);
|
|
floatLiteral();
|
|
}
|
|
break;
|
|
case CHAR_LITERAL:
|
|
_localctx = new CharLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(845);
|
|
match(CHAR_LITERAL);
|
|
}
|
|
break;
|
|
case STRING_LITERAL:
|
|
_localctx = new StringLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(846);
|
|
match(STRING_LITERAL);
|
|
}
|
|
break;
|
|
case BOOL_LITERAL:
|
|
_localctx = new BoolLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(847);
|
|
match(BOOL_LITERAL);
|
|
}
|
|
break;
|
|
case NULL_LITERAL:
|
|
_localctx = new NullLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(848);
|
|
match(NULL_LITERAL);
|
|
}
|
|
break;
|
|
case TEXT_BLOCK:
|
|
_localctx = new TextBlockContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(849);
|
|
match(TEXT_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 IntegerLiteralContext extends ParserRuleContext {
|
|
public TerminalNode DECIMAL_LITERAL() { return getToken(Java17Parser.DECIMAL_LITERAL, 0); }
|
|
public TerminalNode HEX_LITERAL() { return getToken(Java17Parser.HEX_LITERAL, 0); }
|
|
public TerminalNode OCT_LITERAL() { return getToken(Java17Parser.OCT_LITERAL, 0); }
|
|
public TerminalNode BINARY_LITERAL() { return getToken(Java17Parser.BINARY_LITERAL, 0); }
|
|
public IntegerLiteralContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_integerLiteral; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterIntegerLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitIntegerLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitIntegerLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final IntegerLiteralContext integerLiteral() throws RecognitionException {
|
|
IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState());
|
|
enterRule(_localctx, 118, RULE_integerLiteral);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(852);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 15L) != 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 FloatLiteralContext extends ParserRuleContext {
|
|
public TerminalNode FLOAT_LITERAL() { return getToken(Java17Parser.FLOAT_LITERAL, 0); }
|
|
public TerminalNode HEX_FLOAT_LITERAL() { return getToken(Java17Parser.HEX_FLOAT_LITERAL, 0); }
|
|
public FloatLiteralContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_floatLiteral; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFloatLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFloatLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFloatLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FloatLiteralContext floatLiteral() throws RecognitionException {
|
|
FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState());
|
|
enterRule(_localctx, 120, RULE_floatLiteral);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(854);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==FLOAT_LITERAL || _la==HEX_FLOAT_LITERAL) ) {
|
|
_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 AltAnnotationQualifiedNameContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java17Parser.AT, 0); }
|
|
public List<IdentifierContext> identifier() {
|
|
return getRuleContexts(IdentifierContext.class);
|
|
}
|
|
public IdentifierContext identifier(int i) {
|
|
return getRuleContext(IdentifierContext.class,i);
|
|
}
|
|
public List<TerminalNode> DOT() { return getTokens(Java17Parser.DOT); }
|
|
public TerminalNode DOT(int i) {
|
|
return getToken(Java17Parser.DOT, i);
|
|
}
|
|
public AltAnnotationQualifiedNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_altAnnotationQualifiedName; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAltAnnotationQualifiedName(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAltAnnotationQualifiedName(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAltAnnotationQualifiedName(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AltAnnotationQualifiedNameContext altAnnotationQualifiedName() throws RecognitionException {
|
|
AltAnnotationQualifiedNameContext _localctx = new AltAnnotationQualifiedNameContext(_ctx, getState());
|
|
enterRule(_localctx, 122, RULE_altAnnotationQualifiedName);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(861);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(856);
|
|
identifier();
|
|
setState(857);
|
|
match(DOT);
|
|
}
|
|
}
|
|
setState(863);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(864);
|
|
match(AT);
|
|
setState(865);
|
|
identifier();
|
|
}
|
|
}
|
|
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 TerminalNode AT() { return getToken(Java17Parser.AT, 0); }
|
|
public QualifiedNameContext qualifiedName() {
|
|
return getRuleContext(QualifiedNameContext.class,0);
|
|
}
|
|
public AltAnnotationQualifiedNameContext altAnnotationQualifiedName() {
|
|
return getRuleContext(AltAnnotationQualifiedNameContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ElementValuePairsContext elementValuePairs() {
|
|
return getRuleContext(ElementValuePairsContext.class,0);
|
|
}
|
|
public ElementValueContext elementValue() {
|
|
return getRuleContext(ElementValueContext.class,0);
|
|
}
|
|
public AnnotationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotation; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotation(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotation(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotation(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationContext annotation() throws RecognitionException {
|
|
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
|
|
enterRule(_localctx, 124, RULE_annotation);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(870);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(867);
|
|
match(AT);
|
|
setState(868);
|
|
qualifiedName();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(869);
|
|
altAnnotationQualifiedName();
|
|
}
|
|
break;
|
|
}
|
|
setState(878);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LPAREN) {
|
|
{
|
|
setState(872);
|
|
match(LPAREN);
|
|
setState(875);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(873);
|
|
elementValuePairs();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(874);
|
|
elementValue();
|
|
}
|
|
break;
|
|
}
|
|
setState(877);
|
|
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 ElementValuePairsContext 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(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public ElementValuePairsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValuePairs; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterElementValuePairs(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitElementValuePairs(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitElementValuePairs(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ElementValuePairsContext elementValuePairs() throws RecognitionException {
|
|
ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState());
|
|
enterRule(_localctx, 126, RULE_elementValuePairs);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(880);
|
|
elementValuePair();
|
|
setState(885);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(881);
|
|
match(COMMA);
|
|
setState(882);
|
|
elementValuePair();
|
|
}
|
|
}
|
|
setState(887);
|
|
_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 IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode ASSIGN() { return getToken(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterElementValuePair(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitElementValuePair(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitElementValuePair(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ElementValuePairContext elementValuePair() throws RecognitionException {
|
|
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
|
|
enterRule(_localctx, 128, RULE_elementValuePair);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(888);
|
|
identifier();
|
|
setState(889);
|
|
match(ASSIGN);
|
|
setState(890);
|
|
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 ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public AnnotationContext annotation() {
|
|
return getRuleContext(AnnotationContext.class,0);
|
|
}
|
|
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
|
|
return getRuleContext(ElementValueArrayInitializerContext.class,0);
|
|
}
|
|
public ElementValueContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValue; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterElementValue(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitElementValue(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitElementValue(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ElementValueContext elementValue() throws RecognitionException {
|
|
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
|
|
enterRule(_localctx, 130, RULE_elementValue);
|
|
try {
|
|
setState(895);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(892);
|
|
expression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(893);
|
|
annotation();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(894);
|
|
elementValueArrayInitializer();
|
|
}
|
|
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(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<ElementValueContext> elementValue() {
|
|
return getRuleContexts(ElementValueContext.class);
|
|
}
|
|
public ElementValueContext elementValue(int i) {
|
|
return getRuleContext(ElementValueContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterElementValueArrayInitializer(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitElementValueArrayInitializer(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitElementValueArrayInitializer(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
|
|
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
|
|
enterRule(_localctx, 132, RULE_elementValueArrayInitializer);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(897);
|
|
match(LBRACE);
|
|
setState(906);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130013183L) != 0)) {
|
|
{
|
|
setState(898);
|
|
elementValue();
|
|
setState(903);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(899);
|
|
match(COMMA);
|
|
setState(900);
|
|
elementValue();
|
|
}
|
|
}
|
|
}
|
|
setState(905);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
|
|
}
|
|
}
|
|
}
|
|
|
|
setState(909);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COMMA) {
|
|
{
|
|
setState(908);
|
|
match(COMMA);
|
|
}
|
|
}
|
|
|
|
setState(911);
|
|
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 AnnotationTypeDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode AT() { return getToken(Java17Parser.AT, 0); }
|
|
public TerminalNode INTERFACE() { return getToken(Java17Parser.INTERFACE, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public AnnotationTypeBodyContext annotationTypeBody() {
|
|
return getRuleContext(AnnotationTypeBodyContext.class,0);
|
|
}
|
|
public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationTypeDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationTypeDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationTypeDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
|
|
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 134, RULE_annotationTypeDeclaration);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(913);
|
|
match(AT);
|
|
setState(914);
|
|
match(INTERFACE);
|
|
setState(915);
|
|
identifier();
|
|
setState(916);
|
|
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(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<AnnotationTypeElementDeclarationContext> annotationTypeElementDeclaration() {
|
|
return getRuleContexts(AnnotationTypeElementDeclarationContext.class);
|
|
}
|
|
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) {
|
|
return getRuleContext(AnnotationTypeElementDeclarationContext.class,i);
|
|
}
|
|
public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationTypeBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationTypeBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationTypeBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
|
|
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 136, RULE_annotationTypeBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(918);
|
|
match(LBRACE);
|
|
setState(922);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -806529426349675L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660702539773L) != 0)) {
|
|
{
|
|
{
|
|
setState(919);
|
|
annotationTypeElementDeclaration();
|
|
}
|
|
}
|
|
setState(924);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(925);
|
|
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 AnnotationTypeElementDeclarationContext extends ParserRuleContext {
|
|
public AnnotationTypeElementRestContext annotationTypeElementRest() {
|
|
return getRuleContext(AnnotationTypeElementRestContext.class,0);
|
|
}
|
|
public List<ModifierContext> modifier() {
|
|
return getRuleContexts(ModifierContext.class);
|
|
}
|
|
public ModifierContext modifier(int i) {
|
|
return getRuleContext(ModifierContext.class,i);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationTypeElementDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationTypeElementDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationTypeElementDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
|
|
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 138, RULE_annotationTypeElementDeclaration);
|
|
try {
|
|
int _alt;
|
|
setState(935);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(930);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,105,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(927);
|
|
modifier();
|
|
}
|
|
}
|
|
}
|
|
setState(932);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,105,_ctx);
|
|
}
|
|
setState(933);
|
|
annotationTypeElementRest();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(934);
|
|
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 AnnotationTypeElementRestContext extends ParserRuleContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() {
|
|
return getRuleContext(AnnotationMethodOrConstantRestContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public ClassOrInterfaceContext classOrInterface() {
|
|
return getRuleContext(ClassOrInterfaceContext.class,0);
|
|
}
|
|
public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationTypeElementRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationTypeElementRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationTypeElementRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationTypeElementRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException {
|
|
AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState());
|
|
enterRule(_localctx, 140, RULE_annotationTypeElementRest);
|
|
try {
|
|
setState(945);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(937);
|
|
typeType();
|
|
setState(938);
|
|
annotationMethodOrConstantRest();
|
|
setState(939);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(941);
|
|
classOrInterface();
|
|
setState(943);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(942);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext {
|
|
public AnnotationMethodRestContext annotationMethodRest() {
|
|
return getRuleContext(AnnotationMethodRestContext.class,0);
|
|
}
|
|
public AnnotationConstantRestContext annotationConstantRest() {
|
|
return getRuleContext(AnnotationConstantRestContext.class,0);
|
|
}
|
|
public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationMethodOrConstantRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationMethodOrConstantRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationMethodOrConstantRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException {
|
|
AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState());
|
|
enterRule(_localctx, 142, RULE_annotationMethodOrConstantRest);
|
|
try {
|
|
setState(949);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(947);
|
|
annotationMethodRest();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(948);
|
|
annotationConstantRest();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationMethodRestContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public DefaultValueContext defaultValue() {
|
|
return getRuleContext(DefaultValueContext.class,0);
|
|
}
|
|
public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationMethodRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationMethodRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationMethodRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationMethodRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException {
|
|
AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState());
|
|
enterRule(_localctx, 144, RULE_annotationMethodRest);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(951);
|
|
identifier();
|
|
setState(952);
|
|
match(LPAREN);
|
|
setState(953);
|
|
match(RPAREN);
|
|
setState(955);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==DEFAULT) {
|
|
{
|
|
setState(954);
|
|
defaultValue();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AnnotationConstantRestContext extends ParserRuleContext {
|
|
public VariableDeclaratorsContext variableDeclarators() {
|
|
return getRuleContext(VariableDeclaratorsContext.class,0);
|
|
}
|
|
public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_annotationConstantRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAnnotationConstantRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAnnotationConstantRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAnnotationConstantRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException {
|
|
AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState());
|
|
enterRule(_localctx, 146, RULE_annotationConstantRest);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(957);
|
|
variableDeclarators();
|
|
}
|
|
}
|
|
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(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterDefaultValue(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitDefaultValue(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitDefaultValue(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final DefaultValueContext defaultValue() throws RecognitionException {
|
|
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
|
|
enterRule(_localctx, 148, RULE_defaultValue);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(959);
|
|
match(DEFAULT);
|
|
setState(960);
|
|
elementValue();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ModuleDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode MODULE() { return getToken(Java17Parser.MODULE, 0); }
|
|
public QualifiedNameContext qualifiedName() {
|
|
return getRuleContext(QualifiedNameContext.class,0);
|
|
}
|
|
public ModuleBodyContext moduleBody() {
|
|
return getRuleContext(ModuleBodyContext.class,0);
|
|
}
|
|
public TerminalNode OPEN() { return getToken(Java17Parser.OPEN, 0); }
|
|
public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_moduleDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterModuleDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitModuleDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitModuleDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ModuleDeclarationContext moduleDeclaration() throws RecognitionException {
|
|
ModuleDeclarationContext _localctx = new ModuleDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 150, RULE_moduleDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(963);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==OPEN) {
|
|
{
|
|
setState(962);
|
|
match(OPEN);
|
|
}
|
|
}
|
|
|
|
setState(965);
|
|
match(MODULE);
|
|
setState(966);
|
|
qualifiedName();
|
|
setState(967);
|
|
moduleBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ModuleBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<ModuleDirectiveContext> moduleDirective() {
|
|
return getRuleContexts(ModuleDirectiveContext.class);
|
|
}
|
|
public ModuleDirectiveContext moduleDirective(int i) {
|
|
return getRuleContext(ModuleDirectiveContext.class,i);
|
|
}
|
|
public ModuleBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_moduleBody; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterModuleBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitModuleBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitModuleBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ModuleBodyContext moduleBody() throws RecognitionException {
|
|
ModuleBodyContext _localctx = new ModuleBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 152, RULE_moduleBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(969);
|
|
match(LBRACE);
|
|
setState(973);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 495395959010754560L) != 0)) {
|
|
{
|
|
{
|
|
setState(970);
|
|
moduleDirective();
|
|
}
|
|
}
|
|
setState(975);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(976);
|
|
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 ModuleDirectiveContext extends ParserRuleContext {
|
|
public TerminalNode REQUIRES() { return getToken(Java17Parser.REQUIRES, 0); }
|
|
public List<QualifiedNameContext> qualifiedName() {
|
|
return getRuleContexts(QualifiedNameContext.class);
|
|
}
|
|
public QualifiedNameContext qualifiedName(int i) {
|
|
return getRuleContext(QualifiedNameContext.class,i);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public List<RequiresModifierContext> requiresModifier() {
|
|
return getRuleContexts(RequiresModifierContext.class);
|
|
}
|
|
public RequiresModifierContext requiresModifier(int i) {
|
|
return getRuleContext(RequiresModifierContext.class,i);
|
|
}
|
|
public TerminalNode EXPORTS() { return getToken(Java17Parser.EXPORTS, 0); }
|
|
public TerminalNode TO() { return getToken(Java17Parser.TO, 0); }
|
|
public TerminalNode OPENS() { return getToken(Java17Parser.OPENS, 0); }
|
|
public TerminalNode USES() { return getToken(Java17Parser.USES, 0); }
|
|
public TerminalNode PROVIDES() { return getToken(Java17Parser.PROVIDES, 0); }
|
|
public TerminalNode WITH() { return getToken(Java17Parser.WITH, 0); }
|
|
public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_moduleDirective; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterModuleDirective(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitModuleDirective(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitModuleDirective(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ModuleDirectiveContext moduleDirective() throws RecognitionException {
|
|
ModuleDirectiveContext _localctx = new ModuleDirectiveContext(_ctx, getState());
|
|
enterRule(_localctx, 154, RULE_moduleDirective);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
setState(1014);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case REQUIRES:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(978);
|
|
match(REQUIRES);
|
|
setState(982);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,113,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(979);
|
|
requiresModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(984);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,113,_ctx);
|
|
}
|
|
setState(985);
|
|
qualifiedName();
|
|
setState(986);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case EXPORTS:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(988);
|
|
match(EXPORTS);
|
|
setState(989);
|
|
qualifiedName();
|
|
setState(992);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==TO) {
|
|
{
|
|
setState(990);
|
|
match(TO);
|
|
setState(991);
|
|
qualifiedName();
|
|
}
|
|
}
|
|
|
|
setState(994);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case OPENS:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(996);
|
|
match(OPENS);
|
|
setState(997);
|
|
qualifiedName();
|
|
setState(1000);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==TO) {
|
|
{
|
|
setState(998);
|
|
match(TO);
|
|
setState(999);
|
|
qualifiedName();
|
|
}
|
|
}
|
|
|
|
setState(1002);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case USES:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1004);
|
|
match(USES);
|
|
setState(1005);
|
|
qualifiedName();
|
|
setState(1006);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case PROVIDES:
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1008);
|
|
match(PROVIDES);
|
|
setState(1009);
|
|
qualifiedName();
|
|
setState(1010);
|
|
match(WITH);
|
|
setState(1011);
|
|
qualifiedName();
|
|
setState(1012);
|
|
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 RequiresModifierContext extends ParserRuleContext {
|
|
public TerminalNode TRANSITIVE() { return getToken(Java17Parser.TRANSITIVE, 0); }
|
|
public TerminalNode STATIC() { return getToken(Java17Parser.STATIC, 0); }
|
|
public RequiresModifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_requiresModifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRequiresModifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRequiresModifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRequiresModifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RequiresModifierContext requiresModifier() throws RecognitionException {
|
|
RequiresModifierContext _localctx = new RequiresModifierContext(_ctx, getState());
|
|
enterRule(_localctx, 156, RULE_requiresModifier);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1016);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==STATIC || _la==TRANSITIVE) ) {
|
|
_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 RecordDeclarationContext extends ParserRuleContext {
|
|
public TerminalNode RECORD() { return getToken(Java17Parser.RECORD, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public RecordHeaderContext recordHeader() {
|
|
return getRuleContext(RecordHeaderContext.class,0);
|
|
}
|
|
public RecordBodyContext recordBody() {
|
|
return getRuleContext(RecordBodyContext.class,0);
|
|
}
|
|
public GenericDeclarationListContext genericDeclarationList() {
|
|
return getRuleContext(GenericDeclarationListContext.class,0);
|
|
}
|
|
public TerminalNode IMPLEMENTS() { return getToken(Java17Parser.IMPLEMENTS, 0); }
|
|
public TypeListContext typeList() {
|
|
return getRuleContext(TypeListContext.class,0);
|
|
}
|
|
public RecordDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordDeclarationContext recordDeclaration() throws RecognitionException {
|
|
RecordDeclarationContext _localctx = new RecordDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 158, RULE_recordDeclaration);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1018);
|
|
match(RECORD);
|
|
setState(1019);
|
|
identifier();
|
|
setState(1021);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1020);
|
|
genericDeclarationList();
|
|
}
|
|
}
|
|
|
|
setState(1023);
|
|
recordHeader();
|
|
setState(1026);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==IMPLEMENTS) {
|
|
{
|
|
setState(1024);
|
|
match(IMPLEMENTS);
|
|
setState(1025);
|
|
typeList();
|
|
}
|
|
}
|
|
|
|
setState(1028);
|
|
recordBody();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RecordHeaderContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public RecordComponentListContext recordComponentList() {
|
|
return getRuleContext(RecordComponentListContext.class,0);
|
|
}
|
|
public RecordHeaderContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordHeader; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordHeader(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordHeader(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordHeader(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordHeaderContext recordHeader() throws RecognitionException {
|
|
RecordHeaderContext _localctx = new RecordHeaderContext(_ctx, getState());
|
|
enterRule(_localctx, 160, RULE_recordHeader);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1030);
|
|
match(LPAREN);
|
|
setState(1032);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223090579141953573L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
setState(1031);
|
|
recordComponentList();
|
|
}
|
|
}
|
|
|
|
setState(1034);
|
|
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 RecordComponentListContext extends ParserRuleContext {
|
|
public List<RecordComponentContext> recordComponent() {
|
|
return getRuleContexts(RecordComponentContext.class);
|
|
}
|
|
public RecordComponentContext recordComponent(int i) {
|
|
return getRuleContext(RecordComponentContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public RecordComponentListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordComponentList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordComponentList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordComponentList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordComponentList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordComponentListContext recordComponentList() throws RecognitionException {
|
|
RecordComponentListContext _localctx = new RecordComponentListContext(_ctx, getState());
|
|
enterRule(_localctx, 162, RULE_recordComponentList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1036);
|
|
recordComponent();
|
|
setState(1041);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1037);
|
|
match(COMMA);
|
|
setState(1038);
|
|
recordComponent();
|
|
}
|
|
}
|
|
setState(1043);
|
|
_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 RecordComponentContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public RecordComponentContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordComponent; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordComponent(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordComponent(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordComponent(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordComponentContext recordComponent() throws RecognitionException {
|
|
RecordComponentContext _localctx = new RecordComponentContext(_ctx, getState());
|
|
enterRule(_localctx, 164, RULE_recordComponent);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1045);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1044);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(1047);
|
|
identifier();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RecordBodyContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<ClassBodyDeclarationContext> classBodyDeclaration() {
|
|
return getRuleContexts(ClassBodyDeclarationContext.class);
|
|
}
|
|
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
|
|
return getRuleContext(ClassBodyDeclarationContext.class,i);
|
|
}
|
|
public RecordBodyContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordBody; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordBodyContext recordBody() throws RecognitionException {
|
|
RecordBodyContext _localctx = new RecordBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 166, RULE_recordBody);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1049);
|
|
match(LBRACE);
|
|
setState(1053);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -665791937994347L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141660685729789L) != 0)) {
|
|
{
|
|
{
|
|
setState(1050);
|
|
classBodyDeclaration();
|
|
}
|
|
}
|
|
setState(1055);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1056);
|
|
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 BlockContext extends ParserRuleContext {
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<BlockStatementContext> blockStatement() {
|
|
return getRuleContexts(BlockStatementContext.class);
|
|
}
|
|
public BlockStatementContext blockStatement(int i) {
|
|
return getRuleContext(BlockStatementContext.class,i);
|
|
}
|
|
public BlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_block; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBlock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBlock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBlock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final BlockContext block() throws RecognitionException {
|
|
BlockContext _localctx = new BlockContext(_ctx, getState());
|
|
enterRule(_localctx, 168, RULE_block);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1058);
|
|
match(LBRACE);
|
|
setState(1062);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -334254282492513L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141145188974593L) != 0)) {
|
|
{
|
|
{
|
|
setState(1059);
|
|
blockStatement();
|
|
}
|
|
}
|
|
setState(1064);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1065);
|
|
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 BlockStatementContext extends ParserRuleContext {
|
|
public LocalVariableDeclarationContext localVariableDeclaration() {
|
|
return getRuleContext(LocalVariableDeclarationContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public LocalTypeDeclarationContext localTypeDeclaration() {
|
|
return getRuleContext(LocalTypeDeclarationContext.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBlockStatement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBlockStatement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBlockStatement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final BlockStatementContext blockStatement() throws RecognitionException {
|
|
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
|
|
enterRule(_localctx, 170, RULE_blockStatement);
|
|
try {
|
|
setState(1072);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1067);
|
|
localVariableDeclaration();
|
|
setState(1068);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1070);
|
|
localTypeDeclaration();
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1071);
|
|
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 LocalVariableDeclarationContext extends ParserRuleContext {
|
|
public VariableDeclaratorsContext variableDeclarators() {
|
|
return getRuleContext(VariableDeclaratorsContext.class,0);
|
|
}
|
|
public TerminalNode VAR() { return getToken(Java17Parser.VAR, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLocalVariableDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLocalVariableDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLocalVariableDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
|
|
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 172, RULE_localVariableDeclaration);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1077);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1074);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1079);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,125,_ctx);
|
|
}
|
|
setState(1082);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1080);
|
|
match(VAR);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1081);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
setState(1084);
|
|
variableDeclarators();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class IdentifierContext extends ParserRuleContext {
|
|
public TerminalNode IDENTIFIER() { return getToken(Java17Parser.IDENTIFIER, 0); }
|
|
public TerminalNode MODULE() { return getToken(Java17Parser.MODULE, 0); }
|
|
public TerminalNode OPEN() { return getToken(Java17Parser.OPEN, 0); }
|
|
public TerminalNode REQUIRES() { return getToken(Java17Parser.REQUIRES, 0); }
|
|
public TerminalNode EXPORTS() { return getToken(Java17Parser.EXPORTS, 0); }
|
|
public TerminalNode OPENS() { return getToken(Java17Parser.OPENS, 0); }
|
|
public TerminalNode TO() { return getToken(Java17Parser.TO, 0); }
|
|
public TerminalNode USES() { return getToken(Java17Parser.USES, 0); }
|
|
public TerminalNode PROVIDES() { return getToken(Java17Parser.PROVIDES, 0); }
|
|
public TerminalNode WITH() { return getToken(Java17Parser.WITH, 0); }
|
|
public TerminalNode TRANSITIVE() { return getToken(Java17Parser.TRANSITIVE, 0); }
|
|
public TerminalNode YIELD() { return getToken(Java17Parser.YIELD, 0); }
|
|
public TerminalNode SEALED() { return getToken(Java17Parser.SEALED, 0); }
|
|
public TerminalNode PERMITS() { return getToken(Java17Parser.PERMITS, 0); }
|
|
public TerminalNode RECORD() { return getToken(Java17Parser.RECORD, 0); }
|
|
public TerminalNode VAR() { return getToken(Java17Parser.VAR, 0); }
|
|
public IdentifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_identifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterIdentifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitIdentifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitIdentifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final IdentifierContext identifier() throws RecognitionException {
|
|
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
|
|
enterRule(_localctx, 174, RULE_identifier);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1086);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==IDENTIFIER) ) {
|
|
_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 TypeIdentifierContext extends ParserRuleContext {
|
|
public TerminalNode IDENTIFIER() { return getToken(Java17Parser.IDENTIFIER, 0); }
|
|
public TerminalNode MODULE() { return getToken(Java17Parser.MODULE, 0); }
|
|
public TerminalNode OPEN() { return getToken(Java17Parser.OPEN, 0); }
|
|
public TerminalNode REQUIRES() { return getToken(Java17Parser.REQUIRES, 0); }
|
|
public TerminalNode EXPORTS() { return getToken(Java17Parser.EXPORTS, 0); }
|
|
public TerminalNode OPENS() { return getToken(Java17Parser.OPENS, 0); }
|
|
public TerminalNode TO() { return getToken(Java17Parser.TO, 0); }
|
|
public TerminalNode USES() { return getToken(Java17Parser.USES, 0); }
|
|
public TerminalNode PROVIDES() { return getToken(Java17Parser.PROVIDES, 0); }
|
|
public TerminalNode WITH() { return getToken(Java17Parser.WITH, 0); }
|
|
public TerminalNode TRANSITIVE() { return getToken(Java17Parser.TRANSITIVE, 0); }
|
|
public TerminalNode SEALED() { return getToken(Java17Parser.SEALED, 0); }
|
|
public TerminalNode PERMITS() { return getToken(Java17Parser.PERMITS, 0); }
|
|
public TerminalNode RECORD() { return getToken(Java17Parser.RECORD, 0); }
|
|
public TypeIdentifierContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeIdentifier; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeIdentifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeIdentifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeIdentifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeIdentifierContext typeIdentifier() throws RecognitionException {
|
|
TypeIdentifierContext _localctx = new TypeIdentifierContext(_ctx, getState());
|
|
enterRule(_localctx, 176, RULE_typeIdentifier);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1088);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 29695L) != 0) || _la==IDENTIFIER) ) {
|
|
_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 LocalTypeDeclarationContext extends ParserRuleContext {
|
|
public ClassDeclarationContext classDeclaration() {
|
|
return getRuleContext(ClassDeclarationContext.class,0);
|
|
}
|
|
public InterfaceDeclarationContext interfaceDeclaration() {
|
|
return getRuleContext(InterfaceDeclarationContext.class,0);
|
|
}
|
|
public RecordDeclarationContext recordDeclaration() {
|
|
return getRuleContext(RecordDeclarationContext.class,0);
|
|
}
|
|
public List<ClassOrInterfaceModifierContext> classOrInterfaceModifier() {
|
|
return getRuleContexts(ClassOrInterfaceModifierContext.class);
|
|
}
|
|
public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) {
|
|
return getRuleContext(ClassOrInterfaceModifierContext.class,i);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_localTypeDeclaration; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLocalTypeDeclaration(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLocalTypeDeclaration(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLocalTypeDeclaration(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LocalTypeDeclarationContext localTypeDeclaration() throws RecognitionException {
|
|
LocalTypeDeclarationContext _localctx = new LocalTypeDeclarationContext(_ctx, getState());
|
|
enterRule(_localctx, 178, RULE_localTypeDeclaration);
|
|
try {
|
|
int _alt;
|
|
setState(1102);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case ABSTRACT:
|
|
case CLASS:
|
|
case FINAL:
|
|
case INTERFACE:
|
|
case PRIVATE:
|
|
case PROTECTED:
|
|
case PUBLIC:
|
|
case STATIC:
|
|
case STRICTFP:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case NON_SEALED:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1093);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1090);
|
|
classOrInterfaceModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1095);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,127,_ctx);
|
|
}
|
|
setState(1099);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case CLASS:
|
|
{
|
|
setState(1096);
|
|
classDeclaration();
|
|
}
|
|
break;
|
|
case INTERFACE:
|
|
{
|
|
setState(1097);
|
|
interfaceDeclaration();
|
|
}
|
|
break;
|
|
case RECORD:
|
|
{
|
|
setState(1098);
|
|
recordDeclaration();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
case SEMI:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1101);
|
|
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 StatementContext extends ParserRuleContext {
|
|
public StatementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_statement; }
|
|
|
|
public StatementContext() { }
|
|
public void copyFrom(StatementContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class StmtexpressionContext extends StatementContext {
|
|
public ExpressionContext statementExpression;
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public StmtexpressionContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterStmtexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitStmtexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitStmtexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssertstmtContext extends StatementContext {
|
|
public TerminalNode ASSERT() { return getToken(Java17Parser.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(Java17Parser.SEMI, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public AssertstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAssertstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAssertstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAssertstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ThrowstmtContext extends StatementContext {
|
|
public TerminalNode THROW() { return getToken(Java17Parser.THROW, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public ThrowstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterThrowstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitThrowstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitThrowstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TrycatchblockContext extends StatementContext {
|
|
public TerminalNode TRY() { return getToken(Java17Parser.TRY, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public FinallyBlockContext finallyBlock() {
|
|
return getRuleContext(FinallyBlockContext.class,0);
|
|
}
|
|
public List<CatchClauseContext> catchClause() {
|
|
return getRuleContexts(CatchClauseContext.class);
|
|
}
|
|
public CatchClauseContext catchClause(int i) {
|
|
return getRuleContext(CatchClauseContext.class,i);
|
|
}
|
|
public TrycatchblockContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTrycatchblock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTrycatchblock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTrycatchblock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SynchronizedstmtContext extends StatementContext {
|
|
public TerminalNode SYNCHRONIZED() { return getToken(Java17Parser.SYNCHRONIZED, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public SynchronizedstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSynchronizedstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSynchronizedstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSynchronizedstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchstmtContext extends StatementContext {
|
|
public TerminalNode SWITCH() { return getToken(Java17Parser.SWITCH, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.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 SwitchstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BreakstmtContext extends StatementContext {
|
|
public TerminalNode BREAK() { return getToken(Java17Parser.BREAK, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public BreakstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBreakstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBreakstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBreakstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SemistmtContext extends StatementContext {
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public SemistmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSemistmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSemistmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSemistmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ContinuestmtContext extends StatementContext {
|
|
public TerminalNode CONTINUE() { return getToken(Java17Parser.CONTINUE, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public ContinuestmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterContinuestmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitContinuestmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitContinuestmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class WhileloopContext extends StatementContext {
|
|
public TerminalNode WHILE() { return getToken(Java17Parser.WHILE, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public WhileloopContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterWhileloop(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitWhileloop(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitWhileloop(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledstmtContext extends StatementContext {
|
|
public IdentifierContext identifierLabel;
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public LabeledstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLabeledstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLabeledstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLabeledstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ForloopContext extends StatementContext {
|
|
public TerminalNode FOR() { return getToken(Java17Parser.FOR, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public ForControlContext forControl() {
|
|
return getRuleContext(ForControlContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public ForloopContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterForloop(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitForloop(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitForloop(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TrycatchresourceContext extends StatementContext {
|
|
public TerminalNode TRY() { return getToken(Java17Parser.TRY, 0); }
|
|
public ResourceSpecificationContext resourceSpecification() {
|
|
return getRuleContext(ResourceSpecificationContext.class,0);
|
|
}
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public List<CatchClauseContext> catchClause() {
|
|
return getRuleContexts(CatchClauseContext.class);
|
|
}
|
|
public CatchClauseContext catchClause(int i) {
|
|
return getRuleContext(CatchClauseContext.class,i);
|
|
}
|
|
public FinallyBlockContext finallyBlock() {
|
|
return getRuleContext(FinallyBlockContext.class,0);
|
|
}
|
|
public TrycatchresourceContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTrycatchresource(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTrycatchresource(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTrycatchresource(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConditionalstmtContext extends StatementContext {
|
|
public TerminalNode IF() { return getToken(Java17Parser.IF, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public List<StatementContext> statement() {
|
|
return getRuleContexts(StatementContext.class);
|
|
}
|
|
public StatementContext statement(int i) {
|
|
return getRuleContext(StatementContext.class,i);
|
|
}
|
|
public TerminalNode ELSE() { return getToken(Java17Parser.ELSE, 0); }
|
|
public ConditionalstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConditionalstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConditionalstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConditionalstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DowhileloopContext extends StatementContext {
|
|
public TerminalNode DO() { return getToken(Java17Parser.DO, 0); }
|
|
public StatementContext statement() {
|
|
return getRuleContext(StatementContext.class,0);
|
|
}
|
|
public TerminalNode WHILE() { return getToken(Java17Parser.WHILE, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public DowhileloopContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterDowhileloop(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitDowhileloop(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitDowhileloop(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ReturnstmtContext extends StatementContext {
|
|
public TerminalNode RETURN() { return getToken(Java17Parser.RETURN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public ReturnstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterReturnstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitReturnstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitReturnstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BlockstmtContext extends StatementContext {
|
|
public BlockContext blockLabel;
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public BlockstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBlockstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBlockstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBlockstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class YieldstmtContext extends StatementContext {
|
|
public TerminalNode YIELD() { return getToken(Java17Parser.YIELD, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public YieldstmtContext(StatementContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterYieldstmt(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitYieldstmt(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitYieldstmt(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final StatementContext statement() throws RecognitionException {
|
|
StatementContext _localctx = new StatementContext(_ctx, getState());
|
|
enterRule(_localctx, 180, RULE_statement);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
setState(1213);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
|
|
case 1:
|
|
_localctx = new BlockstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1104);
|
|
((BlockstmtContext)_localctx).blockLabel = block();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new AssertstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1105);
|
|
match(ASSERT);
|
|
setState(1106);
|
|
expression(0);
|
|
setState(1109);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==COLON) {
|
|
{
|
|
setState(1107);
|
|
match(COLON);
|
|
setState(1108);
|
|
expression(0);
|
|
}
|
|
}
|
|
|
|
setState(1111);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new ConditionalstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1113);
|
|
match(IF);
|
|
setState(1114);
|
|
parExpression();
|
|
setState(1115);
|
|
statement();
|
|
setState(1118);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1116);
|
|
match(ELSE);
|
|
setState(1117);
|
|
statement();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new ForloopContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1120);
|
|
match(FOR);
|
|
setState(1121);
|
|
match(LPAREN);
|
|
setState(1122);
|
|
forControl();
|
|
setState(1123);
|
|
match(RPAREN);
|
|
setState(1124);
|
|
statement();
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new WhileloopContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1126);
|
|
match(WHILE);
|
|
setState(1127);
|
|
parExpression();
|
|
setState(1128);
|
|
statement();
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new DowhileloopContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1130);
|
|
match(DO);
|
|
setState(1131);
|
|
statement();
|
|
setState(1132);
|
|
match(WHILE);
|
|
setState(1133);
|
|
parExpression();
|
|
setState(1134);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new TrycatchblockContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1136);
|
|
match(TRY);
|
|
setState(1137);
|
|
block();
|
|
setState(1147);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case CATCH:
|
|
{
|
|
setState(1139);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1138);
|
|
catchClause();
|
|
}
|
|
}
|
|
setState(1141);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==CATCH );
|
|
setState(1144);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==FINALLY) {
|
|
{
|
|
setState(1143);
|
|
finallyBlock();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case FINALLY:
|
|
{
|
|
setState(1146);
|
|
finallyBlock();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
case 8:
|
|
_localctx = new TrycatchresourceContext(_localctx);
|
|
enterOuterAlt(_localctx, 8);
|
|
{
|
|
setState(1149);
|
|
match(TRY);
|
|
setState(1150);
|
|
resourceSpecification();
|
|
setState(1151);
|
|
block();
|
|
setState(1155);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CATCH) {
|
|
{
|
|
{
|
|
setState(1152);
|
|
catchClause();
|
|
}
|
|
}
|
|
setState(1157);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1159);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==FINALLY) {
|
|
{
|
|
setState(1158);
|
|
finallyBlock();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case 9:
|
|
_localctx = new SwitchstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 9);
|
|
{
|
|
setState(1161);
|
|
match(SWITCH);
|
|
setState(1162);
|
|
parExpression();
|
|
setState(1163);
|
|
match(LBRACE);
|
|
setState(1167);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1164);
|
|
switchBlockStatementGroup();
|
|
}
|
|
}
|
|
}
|
|
setState(1169);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
|
|
}
|
|
setState(1173);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CASE || _la==DEFAULT) {
|
|
{
|
|
{
|
|
setState(1170);
|
|
switchLabel();
|
|
}
|
|
}
|
|
setState(1175);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1176);
|
|
match(RBRACE);
|
|
}
|
|
break;
|
|
case 10:
|
|
_localctx = new SynchronizedstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 10);
|
|
{
|
|
setState(1178);
|
|
match(SYNCHRONIZED);
|
|
setState(1179);
|
|
parExpression();
|
|
setState(1180);
|
|
block();
|
|
}
|
|
break;
|
|
case 11:
|
|
_localctx = new ReturnstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 11);
|
|
{
|
|
setState(1182);
|
|
match(RETURN);
|
|
setState(1184);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1183);
|
|
expression(0);
|
|
}
|
|
}
|
|
|
|
setState(1186);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 12:
|
|
_localctx = new ThrowstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 12);
|
|
{
|
|
setState(1187);
|
|
match(THROW);
|
|
setState(1188);
|
|
expression(0);
|
|
setState(1189);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 13:
|
|
_localctx = new BreakstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 13);
|
|
{
|
|
setState(1191);
|
|
match(BREAK);
|
|
setState(1193);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==IDENTIFIER) {
|
|
{
|
|
setState(1192);
|
|
identifier();
|
|
}
|
|
}
|
|
|
|
setState(1195);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 14:
|
|
_localctx = new ContinuestmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 14);
|
|
{
|
|
setState(1196);
|
|
match(CONTINUE);
|
|
setState(1198);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==IDENTIFIER) {
|
|
{
|
|
setState(1197);
|
|
identifier();
|
|
}
|
|
}
|
|
|
|
setState(1200);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 15:
|
|
_localctx = new YieldstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 15);
|
|
{
|
|
setState(1201);
|
|
match(YIELD);
|
|
setState(1202);
|
|
expression(0);
|
|
setState(1203);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 16:
|
|
_localctx = new SemistmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 16);
|
|
{
|
|
setState(1205);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 17:
|
|
_localctx = new StmtexpressionContext(_localctx);
|
|
enterOuterAlt(_localctx, 17);
|
|
{
|
|
setState(1206);
|
|
((StmtexpressionContext)_localctx).statementExpression = expression(0);
|
|
setState(1207);
|
|
match(SEMI);
|
|
}
|
|
break;
|
|
case 18:
|
|
_localctx = new LabeledstmtContext(_localctx);
|
|
enterOuterAlt(_localctx, 18);
|
|
{
|
|
setState(1209);
|
|
((LabeledstmtContext)_localctx).identifierLabel = identifier();
|
|
setState(1210);
|
|
match(COLON);
|
|
setState(1211);
|
|
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 CatchClauseContext extends ParserRuleContext {
|
|
public TerminalNode CATCH() { return getToken(Java17Parser.CATCH, 0); }
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public CatchTypeContext catchType() {
|
|
return getRuleContext(CatchTypeContext.class,0);
|
|
}
|
|
public CatchClauseContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catchClause; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCatchClause(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCatchClause(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCatchClause(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final CatchClauseContext catchClause() throws RecognitionException {
|
|
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
|
|
enterRule(_localctx, 182, RULE_catchClause);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1215);
|
|
match(CATCH);
|
|
setState(1216);
|
|
match(LPAREN);
|
|
setState(1220);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1217);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1222);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
|
|
}
|
|
setState(1224);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1223);
|
|
catchType();
|
|
}
|
|
break;
|
|
}
|
|
setState(1226);
|
|
identifier();
|
|
setState(1227);
|
|
match(RPAREN);
|
|
setState(1228);
|
|
block();
|
|
}
|
|
}
|
|
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 List<QualifiedNameContext> qualifiedName() {
|
|
return getRuleContexts(QualifiedNameContext.class);
|
|
}
|
|
public QualifiedNameContext qualifiedName(int i) {
|
|
return getRuleContext(QualifiedNameContext.class,i);
|
|
}
|
|
public List<TerminalNode> BITOR() { return getTokens(Java17Parser.BITOR); }
|
|
public TerminalNode BITOR(int i) {
|
|
return getToken(Java17Parser.BITOR, i);
|
|
}
|
|
public CatchTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_catchType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCatchType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCatchType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCatchType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final CatchTypeContext catchType() throws RecognitionException {
|
|
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 184, RULE_catchType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1230);
|
|
qualifiedName();
|
|
setState(1235);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITOR) {
|
|
{
|
|
{
|
|
setState(1231);
|
|
match(BITOR);
|
|
setState(1232);
|
|
qualifiedName();
|
|
}
|
|
}
|
|
setState(1237);
|
|
_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 FinallyBlockContext extends ParserRuleContext {
|
|
public TerminalNode FINALLY() { return getToken(Java17Parser.FINALLY, 0); }
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public FinallyBlockContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_finallyBlock; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterFinallyBlock(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitFinallyBlock(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitFinallyBlock(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final FinallyBlockContext finallyBlock() throws RecognitionException {
|
|
FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState());
|
|
enterRule(_localctx, 186, RULE_finallyBlock);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1238);
|
|
match(FINALLY);
|
|
setState(1239);
|
|
block();
|
|
}
|
|
}
|
|
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(Java17Parser.LPAREN, 0); }
|
|
public ResourcesContext resources() {
|
|
return getRuleContext(ResourcesContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_resourceSpecification; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterResourceSpecification(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitResourceSpecification(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitResourceSpecification(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
|
|
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
|
|
enterRule(_localctx, 188, RULE_resourceSpecification);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1241);
|
|
match(LPAREN);
|
|
setState(1242);
|
|
resources();
|
|
setState(1244);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==SEMI) {
|
|
{
|
|
setState(1243);
|
|
match(SEMI);
|
|
}
|
|
}
|
|
|
|
setState(1246);
|
|
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 ResourcesContext 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(Java17Parser.SEMI); }
|
|
public TerminalNode SEMI(int i) {
|
|
return getToken(Java17Parser.SEMI, i);
|
|
}
|
|
public ResourcesContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_resources; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterResources(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitResources(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitResources(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ResourcesContext resources() throws RecognitionException {
|
|
ResourcesContext _localctx = new ResourcesContext(_ctx, getState());
|
|
enterRule(_localctx, 190, RULE_resources);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1248);
|
|
resource();
|
|
setState(1253);
|
|
_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(1249);
|
|
match(SEMI);
|
|
setState(1250);
|
|
resource();
|
|
}
|
|
}
|
|
}
|
|
setState(1255);
|
|
_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 ResourceContext extends ParserRuleContext {
|
|
public TerminalNode ASSIGN() { return getToken(Java17Parser.ASSIGN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode VAR() { return getToken(Java17Parser.VAR, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public ResourceContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_resource; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterResource(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitResource(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitResource(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ResourceContext resource() throws RecognitionException {
|
|
ResourceContext _localctx = new ResourceContext(_ctx, getState());
|
|
enterRule(_localctx, 192, RULE_resource);
|
|
try {
|
|
int _alt;
|
|
setState(1274);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1259);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,148,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1256);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1261);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,148,_ctx);
|
|
}
|
|
setState(1268);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1263);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1262);
|
|
classOrInterfaceType();
|
|
}
|
|
break;
|
|
}
|
|
setState(1265);
|
|
variableDeclaratorId();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1266);
|
|
match(VAR);
|
|
setState(1267);
|
|
identifier();
|
|
}
|
|
break;
|
|
}
|
|
setState(1270);
|
|
match(ASSIGN);
|
|
setState(1271);
|
|
expression(0);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1273);
|
|
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 SwitchBlockStatementGroupContext extends ParserRuleContext {
|
|
public List<SwitchLabelContext> switchLabel() {
|
|
return getRuleContexts(SwitchLabelContext.class);
|
|
}
|
|
public SwitchLabelContext switchLabel(int i) {
|
|
return getRuleContext(SwitchLabelContext.class,i);
|
|
}
|
|
public List<BlockStatementContext> blockStatement() {
|
|
return getRuleContexts(BlockStatementContext.class);
|
|
}
|
|
public BlockStatementContext blockStatement(int i) {
|
|
return getRuleContext(BlockStatementContext.class,i);
|
|
}
|
|
public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchBlockStatementGroup(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchBlockStatementGroup(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchBlockStatementGroup(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
|
|
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
|
|
enterRule(_localctx, 194, RULE_switchBlockStatementGroup);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1277);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1276);
|
|
switchLabel();
|
|
}
|
|
}
|
|
setState(1279);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( _la==CASE || _la==DEFAULT );
|
|
setState(1282);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
do {
|
|
{
|
|
{
|
|
setState(1281);
|
|
blockStatement();
|
|
}
|
|
}
|
|
setState(1284);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
} while ( ((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & -334254282492513L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & -8935141145188974593L) != 0) );
|
|
}
|
|
}
|
|
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 SwitchLabelContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchLabel; }
|
|
|
|
public SwitchLabelContext() { }
|
|
public void copyFrom(SwitchLabelContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelPatternContext extends SwitchLabelContext {
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public SwitchLabelPatternContext(SwitchLabelContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchLabelPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchLabelPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchLabelPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelConstContext extends SwitchLabelContext {
|
|
public ExpressionContext constantExpression;
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public SwitchLabelConstContext(SwitchLabelContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchLabelConst(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchLabelConst(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchLabelConst(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelDefaultContext extends SwitchLabelContext {
|
|
public TerminalNode DEFAULT() { return getToken(Java17Parser.DEFAULT, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public SwitchLabelDefaultContext(SwitchLabelContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchLabelDefault(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchLabelDefault(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchLabelDefault(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelEnumContext extends SwitchLabelContext {
|
|
public Token enumConstantName;
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public TerminalNode IDENTIFIER() { return getToken(Java17Parser.IDENTIFIER, 0); }
|
|
public SwitchLabelEnumContext(SwitchLabelContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchLabelEnum(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchLabelEnum(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchLabelEnum(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchLabelContext switchLabel() throws RecognitionException {
|
|
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
|
|
enterRule(_localctx, 196, RULE_switchLabel);
|
|
try {
|
|
setState(1299);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
|
|
case 1:
|
|
_localctx = new SwitchLabelConstContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1286);
|
|
match(CASE);
|
|
setState(1287);
|
|
((SwitchLabelConstContext)_localctx).constantExpression = expression(0);
|
|
setState(1288);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new SwitchLabelEnumContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1290);
|
|
match(CASE);
|
|
setState(1291);
|
|
((SwitchLabelEnumContext)_localctx).enumConstantName = match(IDENTIFIER);
|
|
setState(1292);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new SwitchLabelPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1293);
|
|
match(CASE);
|
|
setState(1294);
|
|
pattern();
|
|
setState(1295);
|
|
match(COLON);
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new SwitchLabelDefaultContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1297);
|
|
match(DEFAULT);
|
|
setState(1298);
|
|
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 ForControlContext extends ParserRuleContext {
|
|
public ExpressionListContext forUpdate;
|
|
public EnhancedForControlContext enhancedForControl() {
|
|
return getRuleContext(EnhancedForControlContext.class,0);
|
|
}
|
|
public List<TerminalNode> SEMI() { return getTokens(Java17Parser.SEMI); }
|
|
public TerminalNode SEMI(int i) {
|
|
return getToken(Java17Parser.SEMI, i);
|
|
}
|
|
public ForInitContext forInit() {
|
|
return getRuleContext(ForInitContext.class,0);
|
|
}
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public ExpressionListContext expressionList() {
|
|
return getRuleContext(ExpressionListContext.class,0);
|
|
}
|
|
public ForControlContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forControl; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterForControl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitForControl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitForControl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ForControlContext forControl() throws RecognitionException {
|
|
ForControlContext _localctx = new ForControlContext(_ctx, getState());
|
|
enterRule(_localctx, 198, RULE_forControl);
|
|
int _la;
|
|
try {
|
|
setState(1313);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1301);
|
|
enhancedForControl();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1303);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610998821L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1302);
|
|
forInit();
|
|
}
|
|
}
|
|
|
|
setState(1305);
|
|
match(SEMI);
|
|
setState(1307);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1306);
|
|
expression(0);
|
|
}
|
|
}
|
|
|
|
setState(1309);
|
|
match(SEMI);
|
|
setState(1311);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1310);
|
|
((ForControlContext)_localctx).forUpdate = expressionList();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
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 LocalVariableDeclarationContext localVariableDeclaration() {
|
|
return getRuleContext(LocalVariableDeclarationContext.class,0);
|
|
}
|
|
public ExpressionListContext expressionList() {
|
|
return getRuleContext(ExpressionListContext.class,0);
|
|
}
|
|
public ForInitContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_forInit; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterForInit(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitForInit(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitForInit(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ForInitContext forInit() throws RecognitionException {
|
|
ForInitContext _localctx = new ForInitContext(_ctx, getState());
|
|
enterRule(_localctx, 200, RULE_forInit);
|
|
try {
|
|
setState(1317);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1315);
|
|
localVariableDeclaration();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1316);
|
|
expressionList();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnhancedForControlContext extends ParserRuleContext {
|
|
public VariableDeclaratorIdContext variableDeclaratorId() {
|
|
return getRuleContext(VariableDeclaratorIdContext.class,0);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode VAR() { return getToken(Java17Parser.VAR, 0); }
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public EnhancedForControlContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_enhancedForControl; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnhancedForControl(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnhancedForControl(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnhancedForControl(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final EnhancedForControlContext enhancedForControl() throws RecognitionException {
|
|
EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState());
|
|
enterRule(_localctx, 202, RULE_enhancedForControl);
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1322);
|
|
_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(1319);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1324);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
|
|
}
|
|
setState(1329);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1326);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1325);
|
|
typeType();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1328);
|
|
match(VAR);
|
|
}
|
|
break;
|
|
}
|
|
setState(1331);
|
|
variableDeclaratorId();
|
|
setState(1332);
|
|
match(COLON);
|
|
setState(1333);
|
|
expression(0);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ParExpressionContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ParExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_parExpression; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterParExpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitParExpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitParExpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ParExpressionContext parExpression() throws RecognitionException {
|
|
ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 204, RULE_parExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1335);
|
|
match(LPAREN);
|
|
setState(1336);
|
|
expression(0);
|
|
setState(1337);
|
|
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 ExpressionListContext 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(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public ExpressionListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expressionList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterExpressionList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitExpressionList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitExpressionList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExpressionListContext expressionList() throws RecognitionException {
|
|
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
|
|
enterRule(_localctx, 206, RULE_expressionList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1339);
|
|
expression(0);
|
|
setState(1344);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1340);
|
|
match(COMMA);
|
|
setState(1341);
|
|
expression(0);
|
|
}
|
|
}
|
|
setState(1346);
|
|
_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 MethodCallContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ExpressionListContext expressionList() {
|
|
return getRuleContext(ExpressionListContext.class,0);
|
|
}
|
|
public TerminalNode THIS() { return getToken(Java17Parser.THIS, 0); }
|
|
public TerminalNode SUPER() { return getToken(Java17Parser.SUPER, 0); }
|
|
public MethodCallContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_methodCall; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodCall(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodCall(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodCall(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final MethodCallContext methodCall() throws RecognitionException {
|
|
MethodCallContext _localctx = new MethodCallContext(_ctx, getState());
|
|
enterRule(_localctx, 208, RULE_methodCall);
|
|
int _la;
|
|
try {
|
|
setState(1366);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1347);
|
|
identifier();
|
|
setState(1348);
|
|
match(LPAREN);
|
|
setState(1350);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1349);
|
|
expressionList();
|
|
}
|
|
}
|
|
|
|
setState(1352);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case THIS:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1354);
|
|
match(THIS);
|
|
setState(1355);
|
|
match(LPAREN);
|
|
setState(1357);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1356);
|
|
expressionList();
|
|
}
|
|
}
|
|
|
|
setState(1359);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case SUPER:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1360);
|
|
match(SUPER);
|
|
setState(1361);
|
|
match(LPAREN);
|
|
setState(1363);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1362);
|
|
expressionList();
|
|
}
|
|
}
|
|
|
|
setState(1365);
|
|
match(RPAREN);
|
|
}
|
|
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 ExpressionContext extends ParserRuleContext {
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expression; }
|
|
|
|
public ExpressionContext() { }
|
|
public void copyFrom(ExpressionContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CastexpressionContext extends ExpressionContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public List<TypeTypeContext> typeType() {
|
|
return getRuleContexts(TypeTypeContext.class);
|
|
}
|
|
public TypeTypeContext typeType(int i) {
|
|
return getRuleContext(TypeTypeContext.class,i);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public List<TerminalNode> BITAND() { return getTokens(Java17Parser.BITAND); }
|
|
public TerminalNode BITAND(int i) {
|
|
return getToken(Java17Parser.BITAND, i);
|
|
}
|
|
public CastexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCastexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCastexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCastexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayaccessexpressionContext extends ExpressionContext {
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode LBRACK() { return getToken(Java17Parser.LBRACK, 0); }
|
|
public TerminalNode RBRACK() { return getToken(Java17Parser.RBRACK, 0); }
|
|
public ArrayaccessexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterArrayaccessexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitArrayaccessexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitArrayaccessexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NewinstanceexpressionContext extends ExpressionContext {
|
|
public TerminalNode NEW() { return getToken(Java17Parser.NEW, 0); }
|
|
public CreatorContext creator() {
|
|
return getRuleContext(CreatorContext.class,0);
|
|
}
|
|
public NewinstanceexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterNewinstanceexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitNewinstanceexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitNewinstanceexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitwiseandexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode BITAND() { return getToken(Java17Parser.BITAND, 0); }
|
|
public BitwiseandexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBitwiseandexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBitwiseandexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBitwiseandexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryExpression2Context extends ExpressionContext {
|
|
public PrimaryContext primary() {
|
|
return getRuleContext(PrimaryContext.class,0);
|
|
}
|
|
public PrimaryExpression2Context(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryExpression2(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryExpression2(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryExpression2(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodcallexpressionContext extends ExpressionContext {
|
|
public MethodCallContext methodCall() {
|
|
return getRuleContext(MethodCallContext.class,0);
|
|
}
|
|
public MethodcallexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodcallexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodcallexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodcallexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ConditionalassignexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public TerminalNode QUESTION() { return getToken(Java17Parser.QUESTION, 0); }
|
|
public ConditionalassignexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterConditionalassignexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitConditionalassignexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitConditionalassignexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodorcreatorreferenceexpressionContext extends ExpressionContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public TerminalNode COLONCOLON() { return getToken(Java17Parser.COLONCOLON, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TerminalNode NEW() { return getToken(Java17Parser.NEW, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public MethodorcreatorreferenceexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodorcreatorreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodorcreatorreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodorcreatorreferenceexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ShiftexpressionContext extends ExpressionContext {
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<TerminalNode> LT() { return getTokens(Java17Parser.LT); }
|
|
public TerminalNode LT(int i) {
|
|
return getToken(Java17Parser.LT, i);
|
|
}
|
|
public List<TerminalNode> GT() { return getTokens(Java17Parser.GT); }
|
|
public TerminalNode GT(int i) {
|
|
return getToken(Java17Parser.GT, i);
|
|
}
|
|
public ShiftexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterShiftexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitShiftexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitShiftexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchExpression2Context extends ExpressionContext {
|
|
public SwitchExpressionContext switchExpression() {
|
|
return getRuleContext(SwitchExpressionContext.class,0);
|
|
}
|
|
public SwitchExpression2Context(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchExpression2(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchExpression2(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchExpression2(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MathaddsubexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode ADD() { return getToken(Java17Parser.ADD, 0); }
|
|
public TerminalNode SUB() { return getToken(Java17Parser.SUB, 0); }
|
|
public MathaddsubexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMathaddsubexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMathaddsubexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMathaddsubexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class DottedexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java17Parser.DOT, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public MethodCallContext methodCall() {
|
|
return getRuleContext(MethodCallContext.class,0);
|
|
}
|
|
public TerminalNode THIS() { return getToken(Java17Parser.THIS, 0); }
|
|
public TerminalNode NEW() { return getToken(Java17Parser.NEW, 0); }
|
|
public InnerCreatorContext innerCreator() {
|
|
return getRuleContext(InnerCreatorContext.class,0);
|
|
}
|
|
public TerminalNode SUPER() { return getToken(Java17Parser.SUPER, 0); }
|
|
public SuperSuffixContext superSuffix() {
|
|
return getRuleContext(SuperSuffixContext.class,0);
|
|
}
|
|
public ExplicitGenericInvocationContext explicitGenericInvocation() {
|
|
return getRuleContext(ExplicitGenericInvocationContext.class,0);
|
|
}
|
|
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
|
|
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
|
|
}
|
|
public DottedexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterDottedexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitDottedexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitDottedexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class OrexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode OR() { return getToken(Java17Parser.OR, 0); }
|
|
public OrexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterOrexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitOrexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitOrexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AndexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode AND() { return getToken(Java17Parser.AND, 0); }
|
|
public AndexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAndexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAndexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAndexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class AssignexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode ASSIGN() { return getToken(Java17Parser.ASSIGN, 0); }
|
|
public TerminalNode ADD_ASSIGN() { return getToken(Java17Parser.ADD_ASSIGN, 0); }
|
|
public TerminalNode SUB_ASSIGN() { return getToken(Java17Parser.SUB_ASSIGN, 0); }
|
|
public TerminalNode MUL_ASSIGN() { return getToken(Java17Parser.MUL_ASSIGN, 0); }
|
|
public TerminalNode DIV_ASSIGN() { return getToken(Java17Parser.DIV_ASSIGN, 0); }
|
|
public TerminalNode AND_ASSIGN() { return getToken(Java17Parser.AND_ASSIGN, 0); }
|
|
public TerminalNode OR_ASSIGN() { return getToken(Java17Parser.OR_ASSIGN, 0); }
|
|
public TerminalNode XOR_ASSIGN() { return getToken(Java17Parser.XOR_ASSIGN, 0); }
|
|
public TerminalNode RSHIFT_ASSIGN() { return getToken(Java17Parser.RSHIFT_ASSIGN, 0); }
|
|
public TerminalNode URSHIFT_ASSIGN() { return getToken(Java17Parser.URSHIFT_ASSIGN, 0); }
|
|
public TerminalNode LSHIFT_ASSIGN() { return getToken(Java17Parser.LSHIFT_ASSIGN, 0); }
|
|
public TerminalNode MOD_ASSIGN() { return getToken(Java17Parser.MOD_ASSIGN, 0); }
|
|
public AssignexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterAssignexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitAssignexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitAssignexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MathmuldivmodexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode MUL() { return getToken(Java17Parser.MUL, 0); }
|
|
public TerminalNode DIV() { return getToken(Java17Parser.DIV, 0); }
|
|
public TerminalNode MOD() { return getToken(Java17Parser.MOD, 0); }
|
|
public MathmuldivmodexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMathmuldivmodexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMathmuldivmodexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMathmuldivmodexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EqualityexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode EQUAL() { return getToken(Java17Parser.EQUAL, 0); }
|
|
public TerminalNode NOTEQUAL() { return getToken(Java17Parser.NOTEQUAL, 0); }
|
|
public EqualityexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEqualityexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEqualityexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEqualityexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PostfixexpressionContext extends ExpressionContext {
|
|
public Token postfix;
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode INC() { return getToken(Java17Parser.INC, 0); }
|
|
public TerminalNode DEC() { return getToken(Java17Parser.DEC, 0); }
|
|
public PostfixexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPostfixexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPostfixexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPostfixexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrefixexpressionContext extends ExpressionContext {
|
|
public Token prefix;
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode ADD() { return getToken(Java17Parser.ADD, 0); }
|
|
public TerminalNode SUB() { return getToken(Java17Parser.SUB, 0); }
|
|
public TerminalNode INC() { return getToken(Java17Parser.INC, 0); }
|
|
public TerminalNode DEC() { return getToken(Java17Parser.DEC, 0); }
|
|
public TerminalNode TILDE() { return getToken(Java17Parser.TILDE, 0); }
|
|
public TerminalNode BANG() { return getToken(Java17Parser.BANG, 0); }
|
|
public PrefixexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrefixexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrefixexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrefixexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitwiseorexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode BITOR() { return getToken(Java17Parser.BITOR, 0); }
|
|
public BitwiseorexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBitwiseorexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBitwiseorexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBitwiseorexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CreatorreferenceexpressionContext extends ExpressionContext {
|
|
public ClassTypeContext classType() {
|
|
return getRuleContext(ClassTypeContext.class,0);
|
|
}
|
|
public TerminalNode COLONCOLON() { return getToken(Java17Parser.COLONCOLON, 0); }
|
|
public TerminalNode NEW() { return getToken(Java17Parser.NEW, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public CreatorreferenceexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCreatorreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCreatorreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCreatorreferenceexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LambdaExpression2Context extends ExpressionContext {
|
|
public LambdaExpressionContext lambdaExpression() {
|
|
return getRuleContext(LambdaExpressionContext.class,0);
|
|
}
|
|
public LambdaExpression2Context(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaExpression2(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaExpression2(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaExpression2(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class BitwisexorexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode CARET() { return getToken(Java17Parser.CARET, 0); }
|
|
public BitwisexorexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterBitwisexorexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitBitwisexorexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitBitwisexorexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RelationalexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode LE() { return getToken(Java17Parser.LE, 0); }
|
|
public TerminalNode GE() { return getToken(Java17Parser.GE, 0); }
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public RelationalexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRelationalexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRelationalexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRelationalexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InstanceofexpressionContext extends ExpressionContext {
|
|
public Token bop;
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode INSTANCEOF() { return getToken(Java17Parser.INSTANCEOF, 0); }
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public InstanceofexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInstanceofexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInstanceofexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInstanceofexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class MethodreferenceexpressionContext extends ExpressionContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode COLONCOLON() { return getToken(Java17Parser.COLONCOLON, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public MethodreferenceexpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterMethodreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitMethodreferenceexpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitMethodreferenceexpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExpressionContext expression() throws RecognitionException {
|
|
return expression(0);
|
|
}
|
|
|
|
private ExpressionContext expression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
|
|
ExpressionContext _prevctx = _localctx;
|
|
int _startState = 210;
|
|
enterRecursionRule(_localctx, 210, RULE_expression, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1411);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new PrimaryExpression2Context(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(1369);
|
|
primary();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new MethodcallexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1370);
|
|
methodCall();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new NewinstanceexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1371);
|
|
match(NEW);
|
|
setState(1372);
|
|
creator();
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new CastexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1373);
|
|
match(LPAREN);
|
|
setState(1377);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1374);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(1379);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
|
|
}
|
|
setState(1380);
|
|
typeType();
|
|
setState(1385);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==BITAND) {
|
|
{
|
|
{
|
|
setState(1381);
|
|
match(BITAND);
|
|
setState(1382);
|
|
typeType();
|
|
}
|
|
}
|
|
setState(1387);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1388);
|
|
match(RPAREN);
|
|
setState(1389);
|
|
expression(21);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new PrefixexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1391);
|
|
((PrefixexpressionContext)_localctx).prefix = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 15363L) != 0)) ) {
|
|
((PrefixexpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1392);
|
|
expression(19);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new LambdaExpression2Context(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1393);
|
|
lambdaExpression();
|
|
}
|
|
break;
|
|
case 7:
|
|
{
|
|
_localctx = new SwitchExpression2Context(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1394);
|
|
switchExpression();
|
|
}
|
|
break;
|
|
case 8:
|
|
{
|
|
_localctx = new MethodorcreatorreferenceexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1395);
|
|
typeType();
|
|
setState(1396);
|
|
match(COLONCOLON);
|
|
setState(1402);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case LT:
|
|
case IDENTIFIER:
|
|
{
|
|
setState(1398);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1397);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1400);
|
|
identifier();
|
|
}
|
|
break;
|
|
case NEW:
|
|
{
|
|
setState(1401);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
case 9:
|
|
{
|
|
_localctx = new CreatorreferenceexpressionContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(1404);
|
|
classType();
|
|
setState(1405);
|
|
match(COLONCOLON);
|
|
setState(1407);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1406);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1409);
|
|
match(NEW);
|
|
}
|
|
break;
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(1496);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,180,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(1494);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new MathmuldivmodexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1413);
|
|
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
|
|
setState(1414);
|
|
((MathmuldivmodexpressionContext)_localctx).bop = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & 35L) != 0)) ) {
|
|
((MathmuldivmodexpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1415);
|
|
expression(19);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new MathaddsubexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1416);
|
|
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
|
|
setState(1417);
|
|
((MathaddsubexpressionContext)_localctx).bop = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==ADD || _la==SUB) ) {
|
|
((MathaddsubexpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1418);
|
|
expression(18);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new ShiftexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1419);
|
|
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
|
|
setState(1427);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1420);
|
|
match(LT);
|
|
setState(1421);
|
|
match(LT);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1422);
|
|
match(GT);
|
|
setState(1423);
|
|
match(GT);
|
|
setState(1424);
|
|
match(GT);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
setState(1425);
|
|
match(GT);
|
|
setState(1426);
|
|
match(GT);
|
|
}
|
|
break;
|
|
}
|
|
setState(1429);
|
|
expression(17);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new RelationalexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1430);
|
|
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
|
|
setState(1431);
|
|
((RelationalexpressionContext)_localctx).bop = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 88)) & ~0x3f) == 0 && ((1L << (_la - 88)) & 387L) != 0)) ) {
|
|
((RelationalexpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1432);
|
|
expression(16);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new EqualityexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1433);
|
|
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
|
|
setState(1434);
|
|
((EqualityexpressionContext)_localctx).bop = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==EQUAL || _la==NOTEQUAL) ) {
|
|
((EqualityexpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1435);
|
|
expression(14);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new BitwiseandexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1436);
|
|
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
|
|
setState(1437);
|
|
((BitwiseandexpressionContext)_localctx).bop = match(BITAND);
|
|
setState(1438);
|
|
expression(13);
|
|
}
|
|
break;
|
|
case 7:
|
|
{
|
|
_localctx = new BitwisexorexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1439);
|
|
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
|
|
setState(1440);
|
|
((BitwisexorexpressionContext)_localctx).bop = match(CARET);
|
|
setState(1441);
|
|
expression(12);
|
|
}
|
|
break;
|
|
case 8:
|
|
{
|
|
_localctx = new BitwiseorexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1442);
|
|
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(1443);
|
|
((BitwiseorexpressionContext)_localctx).bop = match(BITOR);
|
|
setState(1444);
|
|
expression(11);
|
|
}
|
|
break;
|
|
case 9:
|
|
{
|
|
_localctx = new AndexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1445);
|
|
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
|
|
setState(1446);
|
|
((AndexpressionContext)_localctx).bop = match(AND);
|
|
setState(1447);
|
|
expression(10);
|
|
}
|
|
break;
|
|
case 10:
|
|
{
|
|
_localctx = new OrexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1448);
|
|
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
|
|
setState(1449);
|
|
((OrexpressionContext)_localctx).bop = match(OR);
|
|
setState(1450);
|
|
expression(9);
|
|
}
|
|
break;
|
|
case 11:
|
|
{
|
|
_localctx = new ConditionalassignexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1451);
|
|
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(1452);
|
|
((ConditionalassignexpressionContext)_localctx).bop = match(QUESTION);
|
|
setState(1453);
|
|
expression(0);
|
|
setState(1454);
|
|
match(COLON);
|
|
setState(1455);
|
|
expression(7);
|
|
}
|
|
break;
|
|
case 12:
|
|
{
|
|
_localctx = new AssignexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1457);
|
|
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(1458);
|
|
((AssignexpressionContext)_localctx).bop = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & 17171480577L) != 0)) ) {
|
|
((AssignexpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1459);
|
|
expression(6);
|
|
}
|
|
break;
|
|
case 13:
|
|
{
|
|
_localctx = new DottedexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1460);
|
|
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
|
|
setState(1461);
|
|
((DottedexpressionContext)_localctx).bop = match(DOT);
|
|
setState(1473);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1462);
|
|
identifier();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1463);
|
|
methodCall();
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
setState(1464);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
setState(1465);
|
|
match(NEW);
|
|
setState(1467);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1466);
|
|
nonWildcardTypeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1469);
|
|
innerCreator();
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
setState(1470);
|
|
match(SUPER);
|
|
setState(1471);
|
|
superSuffix();
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
setState(1472);
|
|
explicitGenericInvocation();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 14:
|
|
{
|
|
_localctx = new ArrayaccessexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1475);
|
|
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
|
|
setState(1476);
|
|
match(LBRACK);
|
|
setState(1477);
|
|
expression(0);
|
|
setState(1478);
|
|
match(RBRACK);
|
|
}
|
|
break;
|
|
case 15:
|
|
{
|
|
_localctx = new PostfixexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1480);
|
|
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
|
|
setState(1481);
|
|
((PostfixexpressionContext)_localctx).postfix = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==INC || _la==DEC) ) {
|
|
((PostfixexpressionContext)_localctx).postfix = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case 16:
|
|
{
|
|
_localctx = new InstanceofexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1482);
|
|
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
|
|
setState(1483);
|
|
((InstanceofexpressionContext)_localctx).bop = match(INSTANCEOF);
|
|
setState(1486);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1484);
|
|
typeType();
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
setState(1485);
|
|
pattern();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 17:
|
|
{
|
|
_localctx = new MethodreferenceexpressionContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(1488);
|
|
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
|
|
setState(1489);
|
|
match(COLONCOLON);
|
|
setState(1491);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1490);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1493);
|
|
identifier();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(1498);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,180,_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 PatternContext extends ParserRuleContext {
|
|
public PatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_pattern; }
|
|
|
|
public PatternContext() { }
|
|
public void copyFrom(PatternContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GPatternContext extends PatternContext {
|
|
public GuardedPatternContext guardedPattern() {
|
|
return getRuleContext(GuardedPatternContext.class,0);
|
|
}
|
|
public GPatternContext(PatternContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PPatternContext extends PatternContext {
|
|
public PrimaryPatternContext primaryPattern() {
|
|
return getRuleContext(PrimaryPatternContext.class,0);
|
|
}
|
|
public PPatternContext(PatternContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PatternContext pattern() throws RecognitionException {
|
|
PatternContext _localctx = new PatternContext(_ctx, getState());
|
|
enterRule(_localctx, 212, RULE_pattern);
|
|
try {
|
|
setState(1501);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
|
|
case 1:
|
|
_localctx = new PPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1499);
|
|
primaryPattern();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new GPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1500);
|
|
guardedPattern();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryPatternContext extends ParserRuleContext {
|
|
public PrimaryPatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primaryPattern; }
|
|
|
|
public PrimaryPatternContext() { }
|
|
public void copyFrom(PrimaryPatternContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class EnclosedPatternContext extends PrimaryPatternContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public EnclosedPatternContext(PrimaryPatternContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterEnclosedPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitEnclosedPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitEnclosedPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class TPatternContext extends PrimaryPatternContext {
|
|
public TypePatternContext typePattern() {
|
|
return getRuleContext(TypePatternContext.class,0);
|
|
}
|
|
public TPatternContext(PrimaryPatternContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class RPatternContext extends PrimaryPatternContext {
|
|
public RecordPatternContext recordPattern() {
|
|
return getRuleContext(RecordPatternContext.class,0);
|
|
}
|
|
public RPatternContext(PrimaryPatternContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PrimaryPatternContext primaryPattern() throws RecognitionException {
|
|
PrimaryPatternContext _localctx = new PrimaryPatternContext(_ctx, getState());
|
|
enterRule(_localctx, 214, RULE_primaryPattern);
|
|
try {
|
|
setState(1509);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
|
|
case 1:
|
|
_localctx = new TPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1503);
|
|
typePattern();
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new RPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1504);
|
|
recordPattern();
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new EnclosedPatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1505);
|
|
match(LPAREN);
|
|
setState(1506);
|
|
pattern();
|
|
setState(1507);
|
|
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 RecordPatternContext extends ParserRuleContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public RecordStructurePatternContext recordStructurePattern() {
|
|
return getRuleContext(RecordStructurePatternContext.class,0);
|
|
}
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public RecordPatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordPattern; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordPatternContext recordPattern() throws RecognitionException {
|
|
RecordPatternContext _localctx = new RecordPatternContext(_ctx, getState());
|
|
enterRule(_localctx, 216, RULE_recordPattern);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1511);
|
|
typeType();
|
|
setState(1512);
|
|
recordStructurePattern();
|
|
setState(1514);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1513);
|
|
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 TypePatternContext extends ParserRuleContext {
|
|
public TypeTypeContext typeType() {
|
|
return getRuleContext(TypeTypeContext.class,0);
|
|
}
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public List<VariableModifierContext> variableModifier() {
|
|
return getRuleContexts(VariableModifierContext.class);
|
|
}
|
|
public VariableModifierContext variableModifier(int i) {
|
|
return getRuleContext(VariableModifierContext.class,i);
|
|
}
|
|
public TypePatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typePattern; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypePattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypePattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypePattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypePatternContext typePattern() throws RecognitionException {
|
|
TypePatternContext _localctx = new TypePatternContext(_ctx, getState());
|
|
enterRule(_localctx, 218, RULE_typePattern);
|
|
try {
|
|
int _alt;
|
|
setState(1532);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1519);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,184,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1516);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1521);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,184,_ctx);
|
|
}
|
|
setState(1522);
|
|
typeType();
|
|
setState(1523);
|
|
identifier();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1528);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,185,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1525);
|
|
variableModifier();
|
|
}
|
|
}
|
|
}
|
|
setState(1530);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,185,_ctx);
|
|
}
|
|
setState(1531);
|
|
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 RecordStructurePatternContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public RecordComponentPatternListContext recordComponentPatternList() {
|
|
return getRuleContext(RecordComponentPatternListContext.class,0);
|
|
}
|
|
public RecordStructurePatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordStructurePattern; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordStructurePattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordStructurePattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordStructurePattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordStructurePatternContext recordStructurePattern() throws RecognitionException {
|
|
RecordStructurePatternContext _localctx = new RecordStructurePatternContext(_ctx, getState());
|
|
enterRule(_localctx, 220, RULE_recordStructurePattern);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1534);
|
|
match(LPAREN);
|
|
setState(1536);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223090579141986341L) != 0) || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 1161084278931457L) != 0)) {
|
|
{
|
|
setState(1535);
|
|
recordComponentPatternList();
|
|
}
|
|
}
|
|
|
|
setState(1538);
|
|
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 RecordComponentPatternElementContext extends ParserRuleContext {
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public RecordComponentPatternElementContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordComponentPatternElement; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordComponentPatternElement(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordComponentPatternElement(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordComponentPatternElement(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordComponentPatternElementContext recordComponentPatternElement() throws RecognitionException {
|
|
RecordComponentPatternElementContext _localctx = new RecordComponentPatternElementContext(_ctx, getState());
|
|
enterRule(_localctx, 222, RULE_recordComponentPatternElement);
|
|
try {
|
|
setState(1542);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1540);
|
|
pattern();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1541);
|
|
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 RecordComponentPatternListContext extends ParserRuleContext {
|
|
public List<PatternContext> pattern() {
|
|
return getRuleContexts(PatternContext.class);
|
|
}
|
|
public PatternContext pattern(int i) {
|
|
return getRuleContext(PatternContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public RecordComponentPatternListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_recordComponentPatternList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterRecordComponentPatternList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitRecordComponentPatternList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitRecordComponentPatternList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final RecordComponentPatternListContext recordComponentPatternList() throws RecognitionException {
|
|
RecordComponentPatternListContext _localctx = new RecordComponentPatternListContext(_ctx, getState());
|
|
enterRule(_localctx, 224, RULE_recordComponentPatternList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1544);
|
|
pattern();
|
|
setState(1549);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1545);
|
|
match(COMMA);
|
|
setState(1546);
|
|
pattern();
|
|
}
|
|
}
|
|
setState(1551);
|
|
_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 LambdaExpressionContext extends ParserRuleContext {
|
|
public LambdaParametersContext lambdaParameters() {
|
|
return getRuleContext(LambdaParametersContext.class,0);
|
|
}
|
|
public TerminalNode ARROW() { return getToken(Java17Parser.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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaExpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaExpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaExpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
|
|
LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 226, RULE_lambdaExpression);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1552);
|
|
lambdaParameters();
|
|
setState(1553);
|
|
match(ARROW);
|
|
setState(1554);
|
|
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 List<IdentifierContext> identifier() {
|
|
return getRuleContexts(IdentifierContext.class);
|
|
}
|
|
public IdentifierContext identifier(int i) {
|
|
return getRuleContext(IdentifierContext.class,i);
|
|
}
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public FormalParameterListContext formalParameterList() {
|
|
return getRuleContext(FormalParameterListContext.class,0);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public LambdaLVTIListContext lambdaLVTIList() {
|
|
return getRuleContext(LambdaLVTIListContext.class,0);
|
|
}
|
|
public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_lambdaParameters; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaParameters(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaParameters(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaParameters(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LambdaParametersContext lambdaParameters() throws RecognitionException {
|
|
LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
|
|
enterRule(_localctx, 228, RULE_lambdaParameters);
|
|
int _la;
|
|
try {
|
|
setState(1578);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1556);
|
|
identifier();
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1557);
|
|
match(LPAREN);
|
|
setState(1559);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223090579141986341L) != 0) || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 1231453023109121L) != 0)) {
|
|
{
|
|
setState(1558);
|
|
formalParameterList();
|
|
}
|
|
}
|
|
|
|
setState(1561);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 3:
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1562);
|
|
match(LPAREN);
|
|
setState(1563);
|
|
identifier();
|
|
setState(1568);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1564);
|
|
match(COMMA);
|
|
setState(1565);
|
|
identifier();
|
|
}
|
|
}
|
|
setState(1570);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1571);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 4:
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1573);
|
|
match(LPAREN);
|
|
setState(1575);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & 281466386776065L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
setState(1574);
|
|
lambdaLVTIList();
|
|
}
|
|
}
|
|
|
|
setState(1577);
|
|
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 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; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLambdaBody(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLambdaBody(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLambdaBody(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final LambdaBodyContext lambdaBody() throws RecognitionException {
|
|
LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState());
|
|
enterRule(_localctx, 230, RULE_lambdaBody);
|
|
try {
|
|
setState(1582);
|
|
_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 SWITCH:
|
|
case THIS:
|
|
case VOID:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case DECIMAL_LITERAL:
|
|
case HEX_LITERAL:
|
|
case OCT_LITERAL:
|
|
case BINARY_LITERAL:
|
|
case FLOAT_LITERAL:
|
|
case HEX_FLOAT_LITERAL:
|
|
case BOOL_LITERAL:
|
|
case CHAR_LITERAL:
|
|
case STRING_LITERAL:
|
|
case TEXT_BLOCK:
|
|
case NULL_LITERAL:
|
|
case LPAREN:
|
|
case LT:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1580);
|
|
expression(0);
|
|
}
|
|
break;
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1581);
|
|
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 PrimaryContext extends ParserRuleContext {
|
|
public PrimaryContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primary; }
|
|
|
|
public PrimaryContext() { }
|
|
public void copyFrom(PrimaryContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryExpressionContext extends PrimaryContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public PrimaryExpressionContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryExpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryExpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryExpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryInvocationContext extends PrimaryContext {
|
|
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
|
|
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
|
|
}
|
|
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
|
|
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
|
|
}
|
|
public TerminalNode THIS() { return getToken(Java17Parser.THIS, 0); }
|
|
public ArgumentsContext arguments() {
|
|
return getRuleContext(ArgumentsContext.class,0);
|
|
}
|
|
public PrimaryInvocationContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryInvocation(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryInvocation(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryInvocation(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimarySuperContext extends PrimaryContext {
|
|
public TerminalNode SUPER() { return getToken(Java17Parser.SUPER, 0); }
|
|
public PrimarySuperContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimarySuper(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimarySuper(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimarySuper(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryClassrefContext extends PrimaryContext {
|
|
public RefTypeContext refType() {
|
|
return getRuleContext(RefTypeContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java17Parser.DOT, 0); }
|
|
public TerminalNode CLASS() { return getToken(Java17Parser.CLASS, 0); }
|
|
public PrimaryClassrefContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryClassref(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryClassref(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryClassref(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryThisContext extends PrimaryContext {
|
|
public TerminalNode THIS() { return getToken(Java17Parser.THIS, 0); }
|
|
public PrimaryThisContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryThis(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryThis(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryThis(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryIdentifierContext extends PrimaryContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public PrimaryIdentifierContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryIdentifier(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryIdentifier(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryIdentifier(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class PrimaryLiteralContext extends PrimaryContext {
|
|
public LiteralContext literal() {
|
|
return getRuleContext(LiteralContext.class,0);
|
|
}
|
|
public PrimaryLiteralContext(PrimaryContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimaryLiteral(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimaryLiteral(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimaryLiteral(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PrimaryContext primary() throws RecognitionException {
|
|
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
|
|
enterRule(_localctx, 232, RULE_primary);
|
|
try {
|
|
setState(1602);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) {
|
|
case 1:
|
|
_localctx = new PrimaryExpressionContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1584);
|
|
match(LPAREN);
|
|
setState(1585);
|
|
expression(0);
|
|
setState(1586);
|
|
match(RPAREN);
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new PrimaryThisContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1588);
|
|
match(THIS);
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new PrimarySuperContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1589);
|
|
match(SUPER);
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new PrimaryLiteralContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1590);
|
|
literal();
|
|
}
|
|
break;
|
|
case 5:
|
|
_localctx = new PrimaryIdentifierContext(_localctx);
|
|
enterOuterAlt(_localctx, 5);
|
|
{
|
|
setState(1591);
|
|
identifier();
|
|
}
|
|
break;
|
|
case 6:
|
|
_localctx = new PrimaryClassrefContext(_localctx);
|
|
enterOuterAlt(_localctx, 6);
|
|
{
|
|
setState(1592);
|
|
refType();
|
|
setState(1593);
|
|
match(DOT);
|
|
setState(1594);
|
|
match(CLASS);
|
|
}
|
|
break;
|
|
case 7:
|
|
_localctx = new PrimaryInvocationContext(_localctx);
|
|
enterOuterAlt(_localctx, 7);
|
|
{
|
|
setState(1596);
|
|
nonWildcardTypeArguments();
|
|
setState(1600);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SUPER:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
{
|
|
setState(1597);
|
|
explicitGenericInvocationSuffix();
|
|
}
|
|
break;
|
|
case THIS:
|
|
{
|
|
setState(1598);
|
|
match(THIS);
|
|
setState(1599);
|
|
arguments();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchExpressionContext extends ParserRuleContext {
|
|
public TerminalNode SWITCH() { return getToken(Java17Parser.SWITCH, 0); }
|
|
public ParExpressionContext parExpression() {
|
|
return getRuleContext(ParExpressionContext.class,0);
|
|
}
|
|
public TerminalNode LBRACE() { return getToken(Java17Parser.LBRACE, 0); }
|
|
public TerminalNode RBRACE() { return getToken(Java17Parser.RBRACE, 0); }
|
|
public List<SwitchLabeledRuleContext> switchLabeledRule() {
|
|
return getRuleContexts(SwitchLabeledRuleContext.class);
|
|
}
|
|
public SwitchLabeledRuleContext switchLabeledRule(int i) {
|
|
return getRuleContext(SwitchLabeledRuleContext.class,i);
|
|
}
|
|
public SwitchExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchExpression; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchExpression(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchExpression(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchExpression(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchExpressionContext switchExpression() throws RecognitionException {
|
|
SwitchExpressionContext _localctx = new SwitchExpressionContext(_ctx, getState());
|
|
enterRule(_localctx, 234, RULE_switchExpression);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1604);
|
|
match(SWITCH);
|
|
setState(1605);
|
|
parExpression();
|
|
setState(1606);
|
|
match(LBRACE);
|
|
setState(1610);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==CASE || _la==DEFAULT) {
|
|
{
|
|
{
|
|
setState(1607);
|
|
switchLabeledRule();
|
|
}
|
|
}
|
|
setState(1612);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1613);
|
|
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 SwitchLabeledRuleContext extends ParserRuleContext {
|
|
public SwitchLabelCaseContext switchLabelCase() {
|
|
return getRuleContext(SwitchLabelCaseContext.class,0);
|
|
}
|
|
public SwitchRuleOutcomeContext switchRuleOutcome() {
|
|
return getRuleContext(SwitchRuleOutcomeContext.class,0);
|
|
}
|
|
public SwitchLabeledRuleContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchLabeledRule; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchLabeledRule(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchLabeledRule(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchLabeledRule(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchLabeledRuleContext switchLabeledRule() throws RecognitionException {
|
|
SwitchLabeledRuleContext _localctx = new SwitchLabeledRuleContext(_ctx, getState());
|
|
enterRule(_localctx, 236, RULE_switchLabeledRule);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1615);
|
|
switchLabelCase();
|
|
setState(1616);
|
|
switchRuleOutcome();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchLabelCaseContext extends ParserRuleContext {
|
|
public SwitchLabelCaseContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchLabelCase; }
|
|
|
|
public SwitchLabelCaseContext() { }
|
|
public void copyFrom(SwitchLabelCaseContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledRulePatternContext extends SwitchLabelCaseContext {
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public PatternContext pattern() {
|
|
return getRuleContext(PatternContext.class,0);
|
|
}
|
|
public TerminalNode ARROW() { return getToken(Java17Parser.ARROW, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public LabeledRulePatternContext(SwitchLabelCaseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLabeledRulePattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLabeledRulePattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLabeledRulePattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledRuleNullContext extends SwitchLabelCaseContext {
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public TerminalNode NULL_LITERAL() { return getToken(Java17Parser.NULL_LITERAL, 0); }
|
|
public TerminalNode ARROW() { return getToken(Java17Parser.ARROW, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public LabeledRuleNullContext(SwitchLabelCaseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLabeledRuleNull(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLabeledRuleNull(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLabeledRuleNull(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledRuleDefaultContext extends SwitchLabelCaseContext {
|
|
public TerminalNode DEFAULT() { return getToken(Java17Parser.DEFAULT, 0); }
|
|
public TerminalNode ARROW() { return getToken(Java17Parser.ARROW, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public LabeledRuleDefaultContext(SwitchLabelCaseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLabeledRuleDefault(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLabeledRuleDefault(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLabeledRuleDefault(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class LabeledRuleExprListContext extends SwitchLabelCaseContext {
|
|
public TerminalNode CASE() { return getToken(Java17Parser.CASE, 0); }
|
|
public ExpressionListContext expressionList() {
|
|
return getRuleContext(ExpressionListContext.class,0);
|
|
}
|
|
public TerminalNode ARROW() { return getToken(Java17Parser.ARROW, 0); }
|
|
public TerminalNode COLON() { return getToken(Java17Parser.COLON, 0); }
|
|
public LabeledRuleExprListContext(SwitchLabelCaseContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterLabeledRuleExprList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitLabeledRuleExprList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitLabeledRuleExprList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchLabelCaseContext switchLabelCase() throws RecognitionException {
|
|
SwitchLabelCaseContext _localctx = new SwitchLabelCaseContext(_ctx, getState());
|
|
enterRule(_localctx, 238, RULE_switchLabelCase);
|
|
int _la;
|
|
try {
|
|
setState(1631);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
|
|
case 1:
|
|
_localctx = new LabeledRuleNullContext(_localctx);
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1618);
|
|
match(CASE);
|
|
setState(1619);
|
|
match(NULL_LITERAL);
|
|
setState(1620);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==COLON || _la==ARROW) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
_localctx = new LabeledRulePatternContext(_localctx);
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1621);
|
|
match(CASE);
|
|
setState(1622);
|
|
pattern();
|
|
setState(1623);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==COLON || _la==ARROW) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
_localctx = new LabeledRuleDefaultContext(_localctx);
|
|
enterOuterAlt(_localctx, 3);
|
|
{
|
|
setState(1625);
|
|
match(DEFAULT);
|
|
setState(1626);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==COLON || _la==ARROW) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
_localctx = new LabeledRuleExprListContext(_localctx);
|
|
enterOuterAlt(_localctx, 4);
|
|
{
|
|
setState(1627);
|
|
match(CASE);
|
|
setState(1628);
|
|
expressionList();
|
|
setState(1629);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==COLON || _la==ARROW) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
else {
|
|
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
|
|
_errHandler.reportMatch(this);
|
|
consume();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class GuardedPatternContext extends ParserRuleContext {
|
|
public PrimaryPatternContext primaryPattern() {
|
|
return getRuleContext(PrimaryPatternContext.class,0);
|
|
}
|
|
public TerminalNode WITH() { return getToken(Java17Parser.WITH, 0); }
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public GuardedPatternContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_guardedPattern; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterGuardedPattern(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitGuardedPattern(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitGuardedPattern(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final GuardedPatternContext guardedPattern() throws RecognitionException {
|
|
GuardedPatternContext _localctx = new GuardedPatternContext(_ctx, getState());
|
|
enterRule(_localctx, 240, RULE_guardedPattern);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1633);
|
|
primaryPattern();
|
|
setState(1634);
|
|
match(WITH);
|
|
setState(1635);
|
|
expression(0);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class SwitchRuleOutcomeContext extends ParserRuleContext {
|
|
public BlockContext block() {
|
|
return getRuleContext(BlockContext.class,0);
|
|
}
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SEMI() { return getToken(Java17Parser.SEMI, 0); }
|
|
public SwitchRuleOutcomeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_switchRuleOutcome; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSwitchRuleOutcome(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSwitchRuleOutcome(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSwitchRuleOutcome(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SwitchRuleOutcomeContext switchRuleOutcome() throws RecognitionException {
|
|
SwitchRuleOutcomeContext _localctx = new SwitchRuleOutcomeContext(_ctx, getState());
|
|
enterRule(_localctx, 242, RULE_switchRuleOutcome);
|
|
try {
|
|
setState(1641);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACE:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1637);
|
|
block();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case NEW:
|
|
case SHORT:
|
|
case SUPER:
|
|
case SWITCH:
|
|
case THIS:
|
|
case VOID:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case DECIMAL_LITERAL:
|
|
case HEX_LITERAL:
|
|
case OCT_LITERAL:
|
|
case BINARY_LITERAL:
|
|
case FLOAT_LITERAL:
|
|
case HEX_FLOAT_LITERAL:
|
|
case BOOL_LITERAL:
|
|
case CHAR_LITERAL:
|
|
case STRING_LITERAL:
|
|
case TEXT_BLOCK:
|
|
case NULL_LITERAL:
|
|
case LPAREN:
|
|
case LT:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1638);
|
|
expression(0);
|
|
setState(1639);
|
|
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 ClassTypeContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java17Parser.DOT, 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 ClassTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassTypeContext classType() throws RecognitionException {
|
|
ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 244, RULE_classType);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1646);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1643);
|
|
classOrInterfaceType();
|
|
setState(1644);
|
|
match(DOT);
|
|
}
|
|
break;
|
|
}
|
|
setState(1651);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1648);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(1653);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,201,_ctx);
|
|
}
|
|
setState(1654);
|
|
identifier();
|
|
setState(1656);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1655);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CreatorContext extends ParserRuleContext {
|
|
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
|
|
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
|
|
}
|
|
public CreatedNameContext createdName() {
|
|
return getRuleContext(CreatedNameContext.class,0);
|
|
}
|
|
public ClassCreatorRestContext classCreatorRest() {
|
|
return getRuleContext(ClassCreatorRestContext.class,0);
|
|
}
|
|
public ArrayCreatorRestContext arrayCreatorRest() {
|
|
return getRuleContext(ArrayCreatorRestContext.class,0);
|
|
}
|
|
public CreatorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_creator; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCreator(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCreator(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCreator(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final CreatorContext creator() throws RecognitionException {
|
|
CreatorContext _localctx = new CreatorContext(_ctx, getState());
|
|
enterRule(_localctx, 246, RULE_creator);
|
|
try {
|
|
setState(1667);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LT:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1658);
|
|
nonWildcardTypeArguments();
|
|
setState(1659);
|
|
createdName();
|
|
setState(1660);
|
|
classCreatorRest();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1662);
|
|
createdName();
|
|
setState(1665);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LBRACK:
|
|
{
|
|
setState(1663);
|
|
arrayCreatorRest();
|
|
}
|
|
break;
|
|
case LPAREN:
|
|
{
|
|
setState(1664);
|
|
classCreatorRest();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class CreatedNameContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
|
|
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
|
|
}
|
|
public PrimitiveTypeContext primitiveType() {
|
|
return getRuleContext(PrimitiveTypeContext.class,0);
|
|
}
|
|
public CreatedNameContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_createdName; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterCreatedName(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitCreatedName(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitCreatedName(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final CreatedNameContext createdName() throws RecognitionException {
|
|
CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState());
|
|
enterRule(_localctx, 248, RULE_createdName);
|
|
int _la;
|
|
try {
|
|
setState(1674);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1669);
|
|
identifier();
|
|
setState(1671);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1670);
|
|
typeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1673);
|
|
primitiveType();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class InnerCreatorContext extends ParserRuleContext {
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public ClassCreatorRestContext classCreatorRest() {
|
|
return getRuleContext(ClassCreatorRestContext.class,0);
|
|
}
|
|
public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() {
|
|
return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0);
|
|
}
|
|
public InnerCreatorContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_innerCreator; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterInnerCreator(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitInnerCreator(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitInnerCreator(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final InnerCreatorContext innerCreator() throws RecognitionException {
|
|
InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState());
|
|
enterRule(_localctx, 250, RULE_innerCreator);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1676);
|
|
identifier();
|
|
setState(1678);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1677);
|
|
nonWildcardTypeArgumentsOrDiamond();
|
|
}
|
|
}
|
|
|
|
setState(1680);
|
|
classCreatorRest();
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArrayCreatorRestContext extends ParserRuleContext {
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public ArrayInitializerContext arrayInitializer() {
|
|
return getRuleContext(ArrayInitializerContext.class,0);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arrayCreatorRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterArrayCreatorRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitArrayCreatorRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitArrayCreatorRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException {
|
|
ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState());
|
|
enterRule(_localctx, 252, RULE_arrayCreatorRest);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1682);
|
|
match(LBRACK);
|
|
setState(1710);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case RBRACK:
|
|
{
|
|
setState(1683);
|
|
match(RBRACK);
|
|
setState(1688);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==LBRACK) {
|
|
{
|
|
{
|
|
setState(1684);
|
|
match(LBRACK);
|
|
setState(1685);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
setState(1690);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1691);
|
|
arrayInitializer();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case NEW:
|
|
case SHORT:
|
|
case SUPER:
|
|
case SWITCH:
|
|
case THIS:
|
|
case VOID:
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case DECIMAL_LITERAL:
|
|
case HEX_LITERAL:
|
|
case OCT_LITERAL:
|
|
case BINARY_LITERAL:
|
|
case FLOAT_LITERAL:
|
|
case HEX_FLOAT_LITERAL:
|
|
case BOOL_LITERAL:
|
|
case CHAR_LITERAL:
|
|
case STRING_LITERAL:
|
|
case TEXT_BLOCK:
|
|
case NULL_LITERAL:
|
|
case LPAREN:
|
|
case LT:
|
|
case BANG:
|
|
case TILDE:
|
|
case INC:
|
|
case DEC:
|
|
case ADD:
|
|
case SUB:
|
|
case AT:
|
|
case IDENTIFIER:
|
|
{
|
|
setState(1692);
|
|
expression(0);
|
|
setState(1693);
|
|
match(RBRACK);
|
|
setState(1700);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,209,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1694);
|
|
match(LBRACK);
|
|
setState(1695);
|
|
expression(0);
|
|
setState(1696);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(1702);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,209,_ctx);
|
|
}
|
|
setState(1707);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,210,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1703);
|
|
match(LBRACK);
|
|
setState(1704);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(1709);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,210,_ctx);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ClassCreatorRestContext extends ParserRuleContext {
|
|
public ArgumentsContext arguments() {
|
|
return getRuleContext(ArgumentsContext.class,0);
|
|
}
|
|
public ClassBodyContext classBody() {
|
|
return getRuleContext(ClassBodyContext.class,0);
|
|
}
|
|
public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_classCreatorRest; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterClassCreatorRest(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitClassCreatorRest(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitClassCreatorRest(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ClassCreatorRestContext classCreatorRest() throws RecognitionException {
|
|
ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState());
|
|
enterRule(_localctx, 254, RULE_classCreatorRest);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1712);
|
|
arguments();
|
|
setState(1714);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,212,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1713);
|
|
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 ExplicitGenericInvocationContext extends ParserRuleContext {
|
|
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
|
|
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
|
|
}
|
|
public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() {
|
|
return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0);
|
|
}
|
|
public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_explicitGenericInvocation; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterExplicitGenericInvocation(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitExplicitGenericInvocation(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitExplicitGenericInvocation(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException {
|
|
ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState());
|
|
enterRule(_localctx, 256, RULE_explicitGenericInvocation);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1716);
|
|
nonWildcardTypeArguments();
|
|
setState(1717);
|
|
explicitGenericInvocationSuffix();
|
|
}
|
|
}
|
|
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 TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeArgumentsOrDiamond(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeArgumentsOrDiamond(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeArgumentsOrDiamond(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
|
|
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
|
|
enterRule(_localctx, 258, RULE_typeArgumentsOrDiamond);
|
|
try {
|
|
setState(1722);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1719);
|
|
match(LT);
|
|
setState(1720);
|
|
match(GT);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1721);
|
|
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 NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
|
|
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
|
|
}
|
|
public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitNonWildcardTypeArgumentsOrDiamond(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException {
|
|
NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState());
|
|
enterRule(_localctx, 260, RULE_nonWildcardTypeArgumentsOrDiamond);
|
|
try {
|
|
setState(1727);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,214,_ctx) ) {
|
|
case 1:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1724);
|
|
match(LT);
|
|
setState(1725);
|
|
match(GT);
|
|
}
|
|
break;
|
|
case 2:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1726);
|
|
nonWildcardTypeArguments();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class NonWildcardTypeArgumentsContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public TypeListContext typeList() {
|
|
return getRuleContext(TypeListContext.class,0);
|
|
}
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterNonWildcardTypeArguments(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitNonWildcardTypeArguments(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitNonWildcardTypeArguments(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException {
|
|
NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState());
|
|
enterRule(_localctx, 262, RULE_nonWildcardTypeArguments);
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1729);
|
|
match(LT);
|
|
setState(1730);
|
|
typeList();
|
|
setState(1731);
|
|
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 TypeListContext extends ParserRuleContext {
|
|
public List<TypeTypeContext> typeType() {
|
|
return getRuleContexts(TypeTypeContext.class);
|
|
}
|
|
public TypeTypeContext typeType(int i) {
|
|
return getRuleContext(TypeTypeContext.class,i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public TypeListContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeList; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeList(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeList(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeList(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeListContext typeList() throws RecognitionException {
|
|
TypeListContext _localctx = new TypeListContext(_ctx, getState());
|
|
enterRule(_localctx, 264, RULE_typeList);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1733);
|
|
typeType();
|
|
setState(1738);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1734);
|
|
match(COMMA);
|
|
setState(1735);
|
|
typeType();
|
|
}
|
|
}
|
|
setState(1740);
|
|
_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 TypeTypeContext extends ParserRuleContext {
|
|
public ClassOrInterfaceTypeContext classOrInterfaceType() {
|
|
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
|
|
}
|
|
public PrimitiveTypeContext primitiveType() {
|
|
return getRuleContext(PrimitiveTypeContext.class,0);
|
|
}
|
|
public List<AnnotationContext> annotation() {
|
|
return getRuleContexts(AnnotationContext.class);
|
|
}
|
|
public AnnotationContext annotation(int i) {
|
|
return getRuleContext(AnnotationContext.class,i);
|
|
}
|
|
public List<TerminalNode> LBRACK() { return getTokens(Java17Parser.LBRACK); }
|
|
public TerminalNode LBRACK(int i) {
|
|
return getToken(Java17Parser.LBRACK, i);
|
|
}
|
|
public List<TerminalNode> RBRACK() { return getTokens(Java17Parser.RBRACK); }
|
|
public TerminalNode RBRACK(int i) {
|
|
return getToken(Java17Parser.RBRACK, i);
|
|
}
|
|
public TypeTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeTypeContext typeType() throws RecognitionException {
|
|
TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 266, RULE_typeType);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1744);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,216,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1741);
|
|
annotation();
|
|
}
|
|
}
|
|
}
|
|
setState(1746);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,216,_ctx);
|
|
}
|
|
setState(1749);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
{
|
|
setState(1747);
|
|
classOrInterfaceType();
|
|
}
|
|
break;
|
|
case BOOLEAN:
|
|
case BYTE:
|
|
case CHAR:
|
|
case DOUBLE:
|
|
case FLOAT:
|
|
case INT:
|
|
case LONG:
|
|
case SHORT:
|
|
{
|
|
setState(1748);
|
|
primitiveType();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
setState(1761);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,219,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(1754);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & 32767L) != 0) || _la==AT || _la==IDENTIFIER) {
|
|
{
|
|
{
|
|
setState(1751);
|
|
annotation();
|
|
}
|
|
}
|
|
setState(1756);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1757);
|
|
match(LBRACK);
|
|
setState(1758);
|
|
match(RBRACK);
|
|
}
|
|
}
|
|
}
|
|
setState(1763);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,219,_ctx);
|
|
}
|
|
}
|
|
}
|
|
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 TerminalNode BOOLEAN() { return getToken(Java17Parser.BOOLEAN, 0); }
|
|
public TerminalNode CHAR() { return getToken(Java17Parser.CHAR, 0); }
|
|
public TerminalNode BYTE() { return getToken(Java17Parser.BYTE, 0); }
|
|
public TerminalNode SHORT() { return getToken(Java17Parser.SHORT, 0); }
|
|
public TerminalNode INT() { return getToken(Java17Parser.INT, 0); }
|
|
public TerminalNode LONG() { return getToken(Java17Parser.LONG, 0); }
|
|
public TerminalNode FLOAT() { return getToken(Java17Parser.FLOAT, 0); }
|
|
public TerminalNode DOUBLE() { return getToken(Java17Parser.DOUBLE, 0); }
|
|
public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_primitiveType; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterPrimitiveType(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitPrimitiveType(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitPrimitiveType(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
|
|
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
|
|
enterRule(_localctx, 268, RULE_primitiveType);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1764);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 138111107368L) != 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 TypeArgumentsContext extends ParserRuleContext {
|
|
public TerminalNode LT() { return getToken(Java17Parser.LT, 0); }
|
|
public List<TypeArgumentContext> typeArgument() {
|
|
return getRuleContexts(TypeArgumentContext.class);
|
|
}
|
|
public TypeArgumentContext typeArgument(int i) {
|
|
return getRuleContext(TypeArgumentContext.class,i);
|
|
}
|
|
public TerminalNode GT() { return getToken(Java17Parser.GT, 0); }
|
|
public List<TerminalNode> COMMA() { return getTokens(Java17Parser.COMMA); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(Java17Parser.COMMA, i);
|
|
}
|
|
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_typeArguments; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterTypeArguments(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitTypeArguments(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitTypeArguments(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final TypeArgumentsContext typeArguments() throws RecognitionException {
|
|
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
|
|
enterRule(_localctx, 270, RULE_typeArguments);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1766);
|
|
match(LT);
|
|
setState(1767);
|
|
typeArgument();
|
|
setState(1772);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
while (_la==COMMA) {
|
|
{
|
|
{
|
|
setState(1768);
|
|
match(COMMA);
|
|
setState(1769);
|
|
typeArgument();
|
|
}
|
|
}
|
|
setState(1774);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
}
|
|
setState(1775);
|
|
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 SuperSuffixContext extends ParserRuleContext {
|
|
public ArgumentsContext arguments() {
|
|
return getRuleContext(ArgumentsContext.class,0);
|
|
}
|
|
public TerminalNode DOT() { return getToken(Java17Parser.DOT, 0); }
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public TypeArgumentsContext typeArguments() {
|
|
return getRuleContext(TypeArgumentsContext.class,0);
|
|
}
|
|
public SuperSuffixContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_superSuffix; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterSuperSuffix(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitSuperSuffix(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitSuperSuffix(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final SuperSuffixContext superSuffix() throws RecognitionException {
|
|
SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState());
|
|
enterRule(_localctx, 272, RULE_superSuffix);
|
|
int _la;
|
|
try {
|
|
setState(1786);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case LPAREN:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1777);
|
|
arguments();
|
|
}
|
|
break;
|
|
case DOT:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1778);
|
|
match(DOT);
|
|
setState(1780);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (_la==LT) {
|
|
{
|
|
setState(1779);
|
|
typeArguments();
|
|
}
|
|
}
|
|
|
|
setState(1782);
|
|
identifier();
|
|
setState(1784);
|
|
_errHandler.sync(this);
|
|
switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) {
|
|
case 1:
|
|
{
|
|
setState(1783);
|
|
arguments();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ExplicitGenericInvocationSuffixContext extends ParserRuleContext {
|
|
public TerminalNode SUPER() { return getToken(Java17Parser.SUPER, 0); }
|
|
public SuperSuffixContext superSuffix() {
|
|
return getRuleContext(SuperSuffixContext.class,0);
|
|
}
|
|
public IdentifierContext identifier() {
|
|
return getRuleContext(IdentifierContext.class,0);
|
|
}
|
|
public ArgumentsContext arguments() {
|
|
return getRuleContext(ArgumentsContext.class,0);
|
|
}
|
|
public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterExplicitGenericInvocationSuffix(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitExplicitGenericInvocationSuffix(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitExplicitGenericInvocationSuffix(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException {
|
|
ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState());
|
|
enterRule(_localctx, 274, RULE_explicitGenericInvocationSuffix);
|
|
try {
|
|
setState(1793);
|
|
_errHandler.sync(this);
|
|
switch (_input.LA(1)) {
|
|
case SUPER:
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1788);
|
|
match(SUPER);
|
|
setState(1789);
|
|
superSuffix();
|
|
}
|
|
break;
|
|
case MODULE:
|
|
case OPEN:
|
|
case REQUIRES:
|
|
case EXPORTS:
|
|
case OPENS:
|
|
case TO:
|
|
case USES:
|
|
case PROVIDES:
|
|
case WITH:
|
|
case TRANSITIVE:
|
|
case VAR:
|
|
case YIELD:
|
|
case RECORD:
|
|
case SEALED:
|
|
case PERMITS:
|
|
case IDENTIFIER:
|
|
enterOuterAlt(_localctx, 2);
|
|
{
|
|
setState(1790);
|
|
identifier();
|
|
setState(1791);
|
|
arguments();
|
|
}
|
|
break;
|
|
default:
|
|
throw new NoViableAltException(this);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
@SuppressWarnings("CheckReturnValue")
|
|
public static class ArgumentsContext extends ParserRuleContext {
|
|
public TerminalNode LPAREN() { return getToken(Java17Parser.LPAREN, 0); }
|
|
public TerminalNode RPAREN() { return getToken(Java17Parser.RPAREN, 0); }
|
|
public ExpressionListContext expressionList() {
|
|
return getRuleContext(ExpressionListContext.class,0);
|
|
}
|
|
public ArgumentsContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_arguments; }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).enterArguments(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof Java17ParserListener ) ((Java17ParserListener)listener).exitArguments(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof Java17ParserVisitor ) return ((Java17ParserVisitor<? extends T>)visitor).visitArguments(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ArgumentsContext arguments() throws RecognitionException {
|
|
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
|
|
enterRule(_localctx, 276, RULE_arguments);
|
|
int _la;
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(1795);
|
|
match(LPAREN);
|
|
setState(1797);
|
|
_errHandler.sync(this);
|
|
_la = _input.LA(1);
|
|
if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & 9223127275610966053L) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & 2377900732130004991L) != 0)) {
|
|
{
|
|
setState(1796);
|
|
expressionList();
|
|
}
|
|
}
|
|
|
|
setState(1799);
|
|
match(RPAREN);
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
exitRule();
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
|
|
switch (ruleIndex) {
|
|
case 105:
|
|
return expression_sempred((ExpressionContext)_localctx, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 0:
|
|
return precpred(_ctx, 18);
|
|
case 1:
|
|
return precpred(_ctx, 17);
|
|
case 2:
|
|
return precpred(_ctx, 16);
|
|
case 3:
|
|
return precpred(_ctx, 15);
|
|
case 4:
|
|
return precpred(_ctx, 13);
|
|
case 5:
|
|
return precpred(_ctx, 12);
|
|
case 6:
|
|
return precpred(_ctx, 11);
|
|
case 7:
|
|
return precpred(_ctx, 10);
|
|
case 8:
|
|
return precpred(_ctx, 9);
|
|
case 9:
|
|
return precpred(_ctx, 8);
|
|
case 10:
|
|
return precpred(_ctx, 7);
|
|
case 11:
|
|
return precpred(_ctx, 6);
|
|
case 12:
|
|
return precpred(_ctx, 25);
|
|
case 13:
|
|
return precpred(_ctx, 24);
|
|
case 14:
|
|
return precpred(_ctx, 20);
|
|
case 15:
|
|
return precpred(_ctx, 14);
|
|
case 16:
|
|
return precpred(_ctx, 3);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final String _serializedATN =
|
|
"\u0004\u0001\u0080\u070a\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\u0007"+
|
|
"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
|
|
"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
|
|
";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
|
|
"@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+
|
|
"E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+
|
|
"J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+
|
|
"O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+
|
|
"T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+
|
|
"Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+
|
|
"^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+
|
|
"c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+
|
|
"h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+
|
|
"m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+
|
|
"r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+
|
|
"w\u0002x\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\u0001\u0000\u0003\u0000\u0118\b\u0000\u0001"+
|
|
"\u0000\u0005\u0000\u011b\b\u0000\n\u0000\f\u0000\u011e\t\u0000\u0001\u0000"+
|
|
"\u0005\u0000\u0121\b\u0000\n\u0000\f\u0000\u0124\t\u0000\u0001\u0000\u0001"+
|
|
"\u0000\u0001\u0000\u0003\u0000\u0129\b\u0000\u0001\u0001\u0005\u0001\u012c"+
|
|
"\b\u0001\n\u0001\f\u0001\u012f\t\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+
|
|
"\u0001\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u0137\b\u0002\u0001\u0002"+
|
|
"\u0001\u0002\u0001\u0002\u0003\u0002\u013c\b\u0002\u0001\u0002\u0001\u0002"+
|
|
"\u0001\u0003\u0005\u0003\u0141\b\u0003\n\u0003\f\u0003\u0144\t\u0003\u0001"+
|
|
"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u014b"+
|
|
"\b\u0003\u0001\u0003\u0003\u0003\u014e\b\u0003\u0001\u0004\u0001\u0004"+
|
|
"\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0155\b\u0004\u0001\u0005"+
|
|
"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+
|
|
"\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u0161\b\u0005\u0001\u0006"+
|
|
"\u0001\u0006\u0003\u0006\u0165\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+
|
|
"\u0003\u0007\u016a\b\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u016e\b"+
|
|
"\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0172\b\u0007\u0001\u0007\u0001"+
|
|
"\u0007\u0003\u0007\u0176\b\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+
|
|
"\b\u0001\b\u0001\b\u0005\b\u017e\b\b\n\b\f\b\u0181\t\b\u0001\b\u0001\b"+
|
|
"\u0001\t\u0005\t\u0186\b\t\n\t\f\t\u0189\t\t\u0001\t\u0001\t\u0001\t\u0005"+
|
|
"\t\u018e\b\t\n\t\f\t\u0191\t\t\u0001\t\u0003\t\u0194\b\t\u0001\n\u0001"+
|
|
"\n\u0001\n\u0005\n\u0199\b\n\n\n\f\n\u019c\t\n\u0001\u000b\u0001\u000b"+
|
|
"\u0001\u000b\u0001\u000b\u0003\u000b\u01a2\b\u000b\u0001\u000b\u0001\u000b"+
|
|
"\u0003\u000b\u01a6\b\u000b\u0001\u000b\u0003\u000b\u01a9\b\u000b\u0001"+
|
|
"\u000b\u0003\u000b\u01ac\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001"+
|
|
"\f\u0001\f\u0005\f\u01b3\b\f\n\f\f\f\u01b6\t\f\u0001\r\u0005\r\u01b9\b"+
|
|
"\r\n\r\f\r\u01bc\t\r\u0001\r\u0001\r\u0003\r\u01c0\b\r\u0001\r\u0003\r"+
|
|
"\u01c3\b\r\u0001\u000e\u0001\u000e\u0005\u000e\u01c7\b\u000e\n\u000e\f"+
|
|
"\u000e\u01ca\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01cf"+
|
|
"\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u01d3\b\u000f\u0001\u000f"+
|
|
"\u0001\u000f\u0003\u000f\u01d7\b\u000f\u0001\u000f\u0001\u000f\u0001\u0010"+
|
|
"\u0001\u0010\u0005\u0010\u01dd\b\u0010\n\u0010\f\u0010\u01e0\t\u0010\u0001"+
|
|
"\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0005\u0011\u01e6\b\u0011\n"+
|
|
"\u0011\f\u0011\u01e9\t\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001"+
|
|
"\u0012\u0003\u0012\u01ef\b\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u01f3"+
|
|
"\b\u0012\n\u0012\f\u0012\u01f6\t\u0012\u0001\u0012\u0003\u0012\u01f9\b"+
|
|
"\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u01ff"+
|
|
"\b\u0013\u0001\u0014\u0001\u0014\u0003\u0014\u0203\b\u0014\u0001\u0015"+
|
|
"\u0001\u0015\u0001\u0015\u0003\u0015\u0208\b\u0015\u0001\u0015\u0001\u0015"+
|
|
"\u0001\u0016\u0003\u0016\u020d\b\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+
|
|
"\u0001\u0016\u0005\u0016\u0213\b\u0016\n\u0016\f\u0016\u0216\t\u0016\u0001"+
|
|
"\u0017\u0001\u0017\u0003\u0017\u021a\b\u0017\u0001\u0018\u0001\u0018\u0003"+
|
|
"\u0018\u021e\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001"+
|
|
"\u001a\u0003\u001a\u0225\b\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+
|
|
"\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u022e\b\u001c\u0001"+
|
|
"\u001c\u0001\u001c\u0001\u001d\u0003\u001d\u0233\b\u001d\u0001\u001d\u0001"+
|
|
"\u001d\u0001\u001d\u0001\u001e\u0005\u001e\u0239\b\u001e\n\u001e\f\u001e"+
|
|
"\u023c\t\u001e\u0001\u001e\u0001\u001e\u0003\u001e\u0240\b\u001e\u0001"+
|
|
"\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u0246\b\u001f\u0001"+
|
|
" \u0003 \u0249\b \u0001 \u0001 \u0001 \u0005 \u024e\b \n \f \u0251\t "+
|
|
"\u0001 \u0001 \u0001!\u0001!\u0001!\u0005!\u0258\b!\n!\f!\u025b\t!\u0001"+
|
|
"!\u0001!\u0001!\u0001\"\u0005\"\u0261\b\"\n\"\f\"\u0264\t\"\u0001\"\u0001"+
|
|
"\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003#\u026e\b#\u0001$\u0005"+
|
|
"$\u0271\b$\n$\f$\u0274\t$\u0001$\u0001$\u0001$\u0001%\u0005%\u027a\b%"+
|
|
"\n%\f%\u027d\t%\u0001%\u0003%\u0280\b%\u0001%\u0001%\u0001%\u0001%\u0005"+
|
|
"%\u0286\b%\n%\f%\u0289\t%\u0001%\u0001%\u0003%\u028d\b%\u0001%\u0001%"+
|
|
"\u0001&\u0001&\u0001&\u0005&\u0294\b&\n&\f&\u0297\t&\u0001\'\u0001\'\u0001"+
|
|
"\'\u0003\'\u029c\b\'\u0001(\u0001(\u0001(\u0005(\u02a1\b(\n(\f(\u02a4"+
|
|
"\t(\u0001)\u0001)\u0003)\u02a8\b)\u0001*\u0001*\u0001*\u0001*\u0005*\u02ae"+
|
|
"\b*\n*\f*\u02b1\t*\u0001*\u0003*\u02b4\b*\u0003*\u02b6\b*\u0001*\u0001"+
|
|
"*\u0001+\u0001+\u0003+\u02bc\b+\u0001+\u0001+\u0005+\u02c0\b+\n+\f+\u02c3"+
|
|
"\t+\u0001+\u0001+\u0003+\u02c7\b+\u0001,\u0001,\u0003,\u02cb\b,\u0001"+
|
|
"-\u0005-\u02ce\b-\n-\f-\u02d1\t-\u0001-\u0001-\u0001-\u0003-\u02d6\b-"+
|
|
"\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u00010\u00010\u00010\u0005"+
|
|
"0\u02e1\b0\n0\f0\u02e4\t0\u00011\u00011\u00012\u00012\u00032\u02ea\b2"+
|
|
"\u00012\u00012\u00012\u00032\u02ef\b2\u00012\u00032\u02f2\b2\u00032\u02f4"+
|
|
"\b2\u00012\u00012\u00013\u00033\u02f9\b3\u00013\u00013\u00013\u00053\u02fe"+
|
|
"\b3\n3\f3\u0301\t3\u00013\u00013\u00014\u00014\u00014\u00054\u0308\b4"+
|
|
"\n4\f4\u030b\t4\u00014\u00014\u00034\u030f\b4\u00014\u00034\u0312\b4\u0001"+
|
|
"5\u00055\u0315\b5\n5\f5\u0318\t5\u00015\u00035\u031b\b5\u00015\u00015"+
|
|
"\u00035\u031f\b5\u00016\u00056\u0322\b6\n6\f6\u0325\t6\u00016\u00036\u0328"+
|
|
"\b6\u00016\u00056\u032b\b6\n6\f6\u032e\t6\u00016\u00016\u00016\u00017"+
|
|
"\u00017\u00017\u00057\u0336\b7\n7\f7\u0339\t7\u00018\u00058\u033c\b8\n"+
|
|
"8\f8\u033f\t8\u00018\u00018\u00018\u00019\u00019\u00019\u00059\u0347\b"+
|
|
"9\n9\f9\u034a\t9\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0003"+
|
|
":\u0353\b:\u0001;\u0001;\u0001<\u0001<\u0001=\u0001=\u0001=\u0005=\u035c"+
|
|
"\b=\n=\f=\u035f\t=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0003>\u0367"+
|
|
"\b>\u0001>\u0001>\u0001>\u0003>\u036c\b>\u0001>\u0003>\u036f\b>\u0001"+
|
|
"?\u0001?\u0001?\u0005?\u0374\b?\n?\f?\u0377\t?\u0001@\u0001@\u0001@\u0001"+
|
|
"@\u0001A\u0001A\u0001A\u0003A\u0380\bA\u0001B\u0001B\u0001B\u0001B\u0005"+
|
|
"B\u0386\bB\nB\fB\u0389\tB\u0003B\u038b\bB\u0001B\u0003B\u038e\bB\u0001"+
|
|
"B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001D\u0005D\u0399"+
|
|
"\bD\nD\fD\u039c\tD\u0001D\u0001D\u0001E\u0005E\u03a1\bE\nE\fE\u03a4\t"+
|
|
"E\u0001E\u0001E\u0003E\u03a8\bE\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
|
|
"F\u0003F\u03b0\bF\u0003F\u03b2\bF\u0001G\u0001G\u0003G\u03b6\bG\u0001"+
|
|
"H\u0001H\u0001H\u0001H\u0003H\u03bc\bH\u0001I\u0001I\u0001J\u0001J\u0001"+
|
|
"J\u0001K\u0003K\u03c4\bK\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0005"+
|
|
"L\u03cc\bL\nL\fL\u03cf\tL\u0001L\u0001L\u0001M\u0001M\u0005M\u03d5\bM"+
|
|
"\nM\fM\u03d8\tM\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003"+
|
|
"M\u03e1\bM\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003M\u03e9\bM\u0001"+
|
|
"M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+
|
|
"M\u0001M\u0003M\u03f7\bM\u0001N\u0001N\u0001O\u0001O\u0001O\u0003O\u03fe"+
|
|
"\bO\u0001O\u0001O\u0001O\u0003O\u0403\bO\u0001O\u0001O\u0001P\u0001P\u0003"+
|
|
"P\u0409\bP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0005Q\u0410\bQ\nQ\fQ\u0413"+
|
|
"\tQ\u0001R\u0003R\u0416\bR\u0001R\u0001R\u0001S\u0001S\u0005S\u041c\b"+
|
|
"S\nS\fS\u041f\tS\u0001S\u0001S\u0001T\u0001T\u0005T\u0425\bT\nT\fT\u0428"+
|
|
"\tT\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001U\u0003U\u0431\bU\u0001"+
|
|
"V\u0005V\u0434\bV\nV\fV\u0437\tV\u0001V\u0001V\u0003V\u043b\bV\u0001V"+
|
|
"\u0001V\u0001W\u0001W\u0001X\u0001X\u0001Y\u0005Y\u0444\bY\nY\fY\u0447"+
|
|
"\tY\u0001Y\u0001Y\u0001Y\u0003Y\u044c\bY\u0001Y\u0003Y\u044f\bY\u0001"+
|
|
"Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u0456\bZ\u0001Z\u0001Z\u0001Z\u0001"+
|
|
"Z\u0001Z\u0001Z\u0001Z\u0003Z\u045f\bZ\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+
|
|
"Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+
|
|
"Z\u0001Z\u0001Z\u0001Z\u0001Z\u0004Z\u0474\bZ\u000bZ\fZ\u0475\u0001Z\u0003"+
|
|
"Z\u0479\bZ\u0001Z\u0003Z\u047c\bZ\u0001Z\u0001Z\u0001Z\u0001Z\u0005Z\u0482"+
|
|
"\bZ\nZ\fZ\u0485\tZ\u0001Z\u0003Z\u0488\bZ\u0001Z\u0001Z\u0001Z\u0001Z"+
|
|
"\u0005Z\u048e\bZ\nZ\fZ\u0491\tZ\u0001Z\u0005Z\u0494\bZ\nZ\fZ\u0497\tZ"+
|
|
"\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u04a1"+
|
|
"\bZ\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u04aa\bZ\u0001"+
|
|
"Z\u0001Z\u0001Z\u0003Z\u04af\bZ\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+
|
|
"Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0001Z\u0003Z\u04be\bZ\u0001"+
|
|
"[\u0001[\u0001[\u0005[\u04c3\b[\n[\f[\u04c6\t[\u0001[\u0003[\u04c9\b["+
|
|
"\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0005\\\u04d2\b\\"+
|
|
"\n\\\f\\\u04d5\t\\\u0001]\u0001]\u0001]\u0001^\u0001^\u0001^\u0003^\u04dd"+
|
|
"\b^\u0001^\u0001^\u0001_\u0001_\u0001_\u0005_\u04e4\b_\n_\f_\u04e7\t_"+
|
|
"\u0001`\u0005`\u04ea\b`\n`\f`\u04ed\t`\u0001`\u0003`\u04f0\b`\u0001`\u0001"+
|
|
"`\u0001`\u0003`\u04f5\b`\u0001`\u0001`\u0001`\u0001`\u0003`\u04fb\b`\u0001"+
|
|
"a\u0004a\u04fe\ba\u000ba\fa\u04ff\u0001a\u0004a\u0503\ba\u000ba\fa\u0504"+
|
|
"\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001"+
|
|
"b\u0001b\u0001b\u0001b\u0003b\u0514\bb\u0001c\u0001c\u0003c\u0518\bc\u0001"+
|
|
"c\u0001c\u0003c\u051c\bc\u0001c\u0001c\u0003c\u0520\bc\u0003c\u0522\b"+
|
|
"c\u0001d\u0001d\u0003d\u0526\bd\u0001e\u0005e\u0529\be\ne\fe\u052c\te"+
|
|
"\u0001e\u0003e\u052f\be\u0001e\u0003e\u0532\be\u0001e\u0001e\u0001e\u0001"+
|
|
"e\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0005g\u053f\bg\ng"+
|
|
"\fg\u0542\tg\u0001h\u0001h\u0001h\u0003h\u0547\bh\u0001h\u0001h\u0001"+
|
|
"h\u0001h\u0001h\u0003h\u054e\bh\u0001h\u0001h\u0001h\u0001h\u0003h\u0554"+
|
|
"\bh\u0001h\u0003h\u0557\bh\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0005i\u0560\bi\ni\fi\u0563\ti\u0001i\u0001i\u0001i\u0005i\u0568\bi"+
|
|
"\ni\fi\u056b\ti\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0001i\u0003i\u0577\bi\u0001i\u0001i\u0003i\u057b\bi\u0001i\u0001"+
|
|
"i\u0001i\u0003i\u0580\bi\u0001i\u0001i\u0003i\u0584\bi\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0003i\u0594\bi\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0001i\u0003i\u05bc\bi\u0001i\u0001i\u0001i\u0001i\u0003i\u05c2\bi\u0001"+
|
|
"i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
|
|
"i\u0003i\u05cf\bi\u0001i\u0001i\u0001i\u0003i\u05d4\bi\u0001i\u0005i\u05d7"+
|
|
"\bi\ni\fi\u05da\ti\u0001j\u0001j\u0003j\u05de\bj\u0001k\u0001k\u0001k"+
|
|
"\u0001k\u0001k\u0001k\u0003k\u05e6\bk\u0001l\u0001l\u0001l\u0003l\u05eb"+
|
|
"\bl\u0001m\u0005m\u05ee\bm\nm\fm\u05f1\tm\u0001m\u0001m\u0001m\u0001m"+
|
|
"\u0005m\u05f7\bm\nm\fm\u05fa\tm\u0001m\u0003m\u05fd\bm\u0001n\u0001n\u0003"+
|
|
"n\u0601\bn\u0001n\u0001n\u0001o\u0001o\u0003o\u0607\bo\u0001p\u0001p\u0001"+
|
|
"p\u0005p\u060c\bp\np\fp\u060f\tp\u0001q\u0001q\u0001q\u0001q\u0001r\u0001"+
|
|
"r\u0001r\u0003r\u0618\br\u0001r\u0001r\u0001r\u0001r\u0001r\u0005r\u061f"+
|
|
"\br\nr\fr\u0622\tr\u0001r\u0001r\u0001r\u0001r\u0003r\u0628\br\u0001r"+
|
|
"\u0003r\u062b\br\u0001s\u0001s\u0003s\u062f\bs\u0001t\u0001t\u0001t\u0001"+
|
|
"t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001"+
|
|
"t\u0001t\u0001t\u0003t\u0641\bt\u0003t\u0643\bt\u0001u\u0001u\u0001u\u0001"+
|
|
"u\u0005u\u0649\bu\nu\fu\u064c\tu\u0001u\u0001u\u0001v\u0001v\u0001v\u0001"+
|
|
"w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001"+
|
|
"w\u0001w\u0001w\u0003w\u0660\bw\u0001x\u0001x\u0001x\u0001x\u0001y\u0001"+
|
|
"y\u0001y\u0001y\u0003y\u066a\by\u0001z\u0001z\u0001z\u0003z\u066f\bz\u0001"+
|
|
"z\u0005z\u0672\bz\nz\fz\u0675\tz\u0001z\u0001z\u0003z\u0679\bz\u0001{"+
|
|
"\u0001{\u0001{\u0001{\u0001{\u0001{\u0001{\u0003{\u0682\b{\u0003{\u0684"+
|
|
"\b{\u0001|\u0001|\u0003|\u0688\b|\u0001|\u0003|\u068b\b|\u0001}\u0001"+
|
|
"}\u0003}\u068f\b}\u0001}\u0001}\u0001~\u0001~\u0001~\u0001~\u0005~\u0697"+
|
|
"\b~\n~\f~\u069a\t~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0001~\u0005"+
|
|
"~\u06a3\b~\n~\f~\u06a6\t~\u0001~\u0001~\u0005~\u06aa\b~\n~\f~\u06ad\t"+
|
|
"~\u0003~\u06af\b~\u0001\u007f\u0001\u007f\u0003\u007f\u06b3\b\u007f\u0001"+
|
|
"\u0080\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0003"+
|
|
"\u0081\u06bb\b\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0003\u0082\u06c0"+
|
|
"\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0084\u0001"+
|
|
"\u0084\u0001\u0084\u0005\u0084\u06c9\b\u0084\n\u0084\f\u0084\u06cc\t\u0084"+
|
|
"\u0001\u0085\u0005\u0085\u06cf\b\u0085\n\u0085\f\u0085\u06d2\t\u0085\u0001"+
|
|
"\u0085\u0001\u0085\u0003\u0085\u06d6\b\u0085\u0001\u0085\u0005\u0085\u06d9"+
|
|
"\b\u0085\n\u0085\f\u0085\u06dc\t\u0085\u0001\u0085\u0001\u0085\u0005\u0085"+
|
|
"\u06e0\b\u0085\n\u0085\f\u0085\u06e3\t\u0085\u0001\u0086\u0001\u0086\u0001"+
|
|
"\u0087\u0001\u0087\u0001\u0087\u0001\u0087\u0005\u0087\u06eb\b\u0087\n"+
|
|
"\u0087\f\u0087\u06ee\t\u0087\u0001\u0087\u0001\u0087\u0001\u0088\u0001"+
|
|
"\u0088\u0001\u0088\u0003\u0088\u06f5\b\u0088\u0001\u0088\u0001\u0088\u0003"+
|
|
"\u0088\u06f9\b\u0088\u0003\u0088\u06fb\b\u0088\u0001\u0089\u0001\u0089"+
|
|
"\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u0702\b\u0089\u0001\u008a"+
|
|
"\u0001\u008a\u0003\u008a\u0706\b\u008a\u0001\u008a\u0001\u008a\u0001\u008a"+
|
|
"\u0000\u0001\u00d2\u008b\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\u0000\u000f\u0002\u0000\u0011\u0011"+
|
|
"\u0018\u0018\u0001\u0000CF\u0001\u0000GH\u0002\u0000&&<<\u0002\u00003"+
|
|
"A\u0080\u0080\u0003\u00003<?A\u0080\u0080\u0002\u0000Z[dg\u0002\u0000"+
|
|
"himm\u0001\u0000fg\u0002\u0000XY_`\u0002\u0000^^aa\u0002\u0000WWnx\u0001"+
|
|
"\u0000de\u0002\u0000]]yy\b\u0000\u0003\u0003\u0005\u0005\b\b\u000e\u000e"+
|
|
"\u0014\u0014\u001b\u001b\u001d\u001d%%\u07bd\u0000\u0128\u0001\u0000\u0000"+
|
|
"\u0000\u0002\u012d\u0001\u0000\u0000\u0000\u0004\u0134\u0001\u0000\u0000"+
|
|
"\u0000\u0006\u014d\u0001\u0000\u0000\u0000\b\u0154\u0001\u0000\u0000\u0000"+
|
|
"\n\u0160\u0001\u0000\u0000\u0000\f\u0164\u0001\u0000\u0000\u0000\u000e"+
|
|
"\u0166\u0001\u0000\u0000\u0000\u0010\u0179\u0001\u0000\u0000\u0000\u0012"+
|
|
"\u0187\u0001\u0000\u0000\u0000\u0014\u0195\u0001\u0000\u0000\u0000\u0016"+
|
|
"\u019d\u0001\u0000\u0000\u0000\u0018\u01af\u0001\u0000\u0000\u0000\u001a"+
|
|
"\u01ba\u0001\u0000\u0000\u0000\u001c\u01c4\u0001\u0000\u0000\u0000\u001e"+
|
|
"\u01cb\u0001\u0000\u0000\u0000 \u01da\u0001\u0000\u0000\u0000\"\u01e3"+
|
|
"\u0001\u0000\u0000\u0000$\u01f8\u0001\u0000\u0000\u0000&\u01fe\u0001\u0000"+
|
|
"\u0000\u0000(\u0202\u0001\u0000\u0000\u0000*\u0204\u0001\u0000\u0000\u0000"+
|
|
",\u020c\u0001\u0000\u0000\u0000.\u0219\u0001\u0000\u0000\u00000\u021d"+
|
|
"\u0001\u0000\u0000\u00002\u021f\u0001\u0000\u0000\u00004\u0224\u0001\u0000"+
|
|
"\u0000\u00006\u0226\u0001\u0000\u0000\u00008\u0229\u0001\u0000\u0000\u0000"+
|
|
":\u0232\u0001\u0000\u0000\u0000<\u023f\u0001\u0000\u0000\u0000>\u0245"+
|
|
"\u0001\u0000\u0000\u0000@\u0248\u0001\u0000\u0000\u0000B\u0254\u0001\u0000"+
|
|
"\u0000\u0000D\u0262\u0001\u0000\u0000\u0000F\u026d\u0001\u0000\u0000\u0000"+
|
|
"H\u0272\u0001\u0000\u0000\u0000J\u027b\u0001\u0000\u0000\u0000L\u0290"+
|
|
"\u0001\u0000\u0000\u0000N\u0298\u0001\u0000\u0000\u0000P\u029d\u0001\u0000"+
|
|
"\u0000\u0000R\u02a7\u0001\u0000\u0000\u0000T\u02a9\u0001\u0000\u0000\u0000"+
|
|
"V\u02c1\u0001\u0000\u0000\u0000X\u02ca\u0001\u0000\u0000\u0000Z\u02cf"+
|
|
"\u0001\u0000\u0000\u0000\\\u02d7\u0001\u0000\u0000\u0000^\u02da\u0001"+
|
|
"\u0000\u0000\u0000`\u02dd\u0001\u0000\u0000\u0000b\u02e5\u0001\u0000\u0000"+
|
|
"\u0000d\u02e7\u0001\u0000\u0000\u0000f\u02f8\u0001\u0000\u0000\u0000h"+
|
|
"\u0311\u0001\u0000\u0000\u0000j\u031e\u0001\u0000\u0000\u0000l\u0323\u0001"+
|
|
"\u0000\u0000\u0000n\u0332\u0001\u0000\u0000\u0000p\u033d\u0001\u0000\u0000"+
|
|
"\u0000r\u0343\u0001\u0000\u0000\u0000t\u0352\u0001\u0000\u0000\u0000v"+
|
|
"\u0354\u0001\u0000\u0000\u0000x\u0356\u0001\u0000\u0000\u0000z\u035d\u0001"+
|
|
"\u0000\u0000\u0000|\u0366\u0001\u0000\u0000\u0000~\u0370\u0001\u0000\u0000"+
|
|
"\u0000\u0080\u0378\u0001\u0000\u0000\u0000\u0082\u037f\u0001\u0000\u0000"+
|
|
"\u0000\u0084\u0381\u0001\u0000\u0000\u0000\u0086\u0391\u0001\u0000\u0000"+
|
|
"\u0000\u0088\u0396\u0001\u0000\u0000\u0000\u008a\u03a7\u0001\u0000\u0000"+
|
|
"\u0000\u008c\u03b1\u0001\u0000\u0000\u0000\u008e\u03b5\u0001\u0000\u0000"+
|
|
"\u0000\u0090\u03b7\u0001\u0000\u0000\u0000\u0092\u03bd\u0001\u0000\u0000"+
|
|
"\u0000\u0094\u03bf\u0001\u0000\u0000\u0000\u0096\u03c3\u0001\u0000\u0000"+
|
|
"\u0000\u0098\u03c9\u0001\u0000\u0000\u0000\u009a\u03f6\u0001\u0000\u0000"+
|
|
"\u0000\u009c\u03f8\u0001\u0000\u0000\u0000\u009e\u03fa\u0001\u0000\u0000"+
|
|
"\u0000\u00a0\u0406\u0001\u0000\u0000\u0000\u00a2\u040c\u0001\u0000\u0000"+
|
|
"\u0000\u00a4\u0415\u0001\u0000\u0000\u0000\u00a6\u0419\u0001\u0000\u0000"+
|
|
"\u0000\u00a8\u0422\u0001\u0000\u0000\u0000\u00aa\u0430\u0001\u0000\u0000"+
|
|
"\u0000\u00ac\u0435\u0001\u0000\u0000\u0000\u00ae\u043e\u0001\u0000\u0000"+
|
|
"\u0000\u00b0\u0440\u0001\u0000\u0000\u0000\u00b2\u044e\u0001\u0000\u0000"+
|
|
"\u0000\u00b4\u04bd\u0001\u0000\u0000\u0000\u00b6\u04bf\u0001\u0000\u0000"+
|
|
"\u0000\u00b8\u04ce\u0001\u0000\u0000\u0000\u00ba\u04d6\u0001\u0000\u0000"+
|
|
"\u0000\u00bc\u04d9\u0001\u0000\u0000\u0000\u00be\u04e0\u0001\u0000\u0000"+
|
|
"\u0000\u00c0\u04fa\u0001\u0000\u0000\u0000\u00c2\u04fd\u0001\u0000\u0000"+
|
|
"\u0000\u00c4\u0513\u0001\u0000\u0000\u0000\u00c6\u0521\u0001\u0000\u0000"+
|
|
"\u0000\u00c8\u0525\u0001\u0000\u0000\u0000\u00ca\u052a\u0001\u0000\u0000"+
|
|
"\u0000\u00cc\u0537\u0001\u0000\u0000\u0000\u00ce\u053b\u0001\u0000\u0000"+
|
|
"\u0000\u00d0\u0556\u0001\u0000\u0000\u0000\u00d2\u0583\u0001\u0000\u0000"+
|
|
"\u0000\u00d4\u05dd\u0001\u0000\u0000\u0000\u00d6\u05e5\u0001\u0000\u0000"+
|
|
"\u0000\u00d8\u05e7\u0001\u0000\u0000\u0000\u00da\u05fc\u0001\u0000\u0000"+
|
|
"\u0000\u00dc\u05fe\u0001\u0000\u0000\u0000\u00de\u0606\u0001\u0000\u0000"+
|
|
"\u0000\u00e0\u0608\u0001\u0000\u0000\u0000\u00e2\u0610\u0001\u0000\u0000"+
|
|
"\u0000\u00e4\u062a\u0001\u0000\u0000\u0000\u00e6\u062e\u0001\u0000\u0000"+
|
|
"\u0000\u00e8\u0642\u0001\u0000\u0000\u0000\u00ea\u0644\u0001\u0000\u0000"+
|
|
"\u0000\u00ec\u064f\u0001\u0000\u0000\u0000\u00ee\u065f\u0001\u0000\u0000"+
|
|
"\u0000\u00f0\u0661\u0001\u0000\u0000\u0000\u00f2\u0669\u0001\u0000\u0000"+
|
|
"\u0000\u00f4\u066e\u0001\u0000\u0000\u0000\u00f6\u0683\u0001\u0000\u0000"+
|
|
"\u0000\u00f8\u068a\u0001\u0000\u0000\u0000\u00fa\u068c\u0001\u0000\u0000"+
|
|
"\u0000\u00fc\u0692\u0001\u0000\u0000\u0000\u00fe\u06b0\u0001\u0000\u0000"+
|
|
"\u0000\u0100\u06b4\u0001\u0000\u0000\u0000\u0102\u06ba\u0001\u0000\u0000"+
|
|
"\u0000\u0104\u06bf\u0001\u0000\u0000\u0000\u0106\u06c1\u0001\u0000\u0000"+
|
|
"\u0000\u0108\u06c5\u0001\u0000\u0000\u0000\u010a\u06d0\u0001\u0000\u0000"+
|
|
"\u0000\u010c\u06e4\u0001\u0000\u0000\u0000\u010e\u06e6\u0001\u0000\u0000"+
|
|
"\u0000\u0110\u06fa\u0001\u0000\u0000\u0000\u0112\u0701\u0001\u0000\u0000"+
|
|
"\u0000\u0114\u0703\u0001\u0000\u0000\u0000\u0116\u0118\u0003\u0002\u0001"+
|
|
"\u0000\u0117\u0116\u0001\u0000\u0000\u0000\u0117\u0118\u0001\u0000\u0000"+
|
|
"\u0000\u0118\u011c\u0001\u0000\u0000\u0000\u0119\u011b\u0003\u0004\u0002"+
|
|
"\u0000\u011a\u0119\u0001\u0000\u0000\u0000\u011b\u011e\u0001\u0000\u0000"+
|
|
"\u0000\u011c\u011a\u0001\u0000\u0000\u0000\u011c\u011d\u0001\u0000\u0000"+
|
|
"\u0000\u011d\u0122\u0001\u0000\u0000\u0000\u011e\u011c\u0001\u0000\u0000"+
|
|
"\u0000\u011f\u0121\u0003\u0006\u0003\u0000\u0120\u011f\u0001\u0000\u0000"+
|
|
"\u0000\u0121\u0124\u0001\u0000\u0000\u0000\u0122\u0120\u0001\u0000\u0000"+
|
|
"\u0000\u0122\u0123\u0001\u0000\u0000\u0000\u0123\u0129\u0001\u0000\u0000"+
|
|
"\u0000\u0124\u0122\u0001\u0000\u0000\u0000\u0125\u0126\u0003\u0096K\u0000"+
|
|
"\u0126\u0127\u0005\u0000\u0000\u0001\u0127\u0129\u0001\u0000\u0000\u0000"+
|
|
"\u0128\u0117\u0001\u0000\u0000\u0000\u0128\u0125\u0001\u0000\u0000\u0000"+
|
|
"\u0129\u0001\u0001\u0000\u0000\u0000\u012a\u012c\u0003|>\u0000\u012b\u012a"+
|
|
"\u0001\u0000\u0000\u0000\u012c\u012f\u0001\u0000\u0000\u0000\u012d\u012b"+
|
|
"\u0001\u0000\u0000\u0000\u012d\u012e\u0001\u0000\u0000\u0000\u012e\u0130"+
|
|
"\u0001\u0000\u0000\u0000\u012f\u012d\u0001\u0000\u0000\u0000\u0130\u0131"+
|
|
"\u0005 \u0000\u0000\u0131\u0132\u0003r9\u0000\u0132\u0133\u0005T\u0000"+
|
|
"\u0000\u0133\u0003\u0001\u0000\u0000\u0000\u0134\u0136\u0005\u0019\u0000"+
|
|
"\u0000\u0135\u0137\u0005&\u0000\u0000\u0136\u0135\u0001\u0000\u0000\u0000"+
|
|
"\u0136\u0137\u0001\u0000\u0000\u0000\u0137\u0138\u0001\u0000\u0000\u0000"+
|
|
"\u0138\u013b\u0003r9\u0000\u0139\u013a\u0005V\u0000\u0000\u013a\u013c"+
|
|
"\u0005h\u0000\u0000\u013b\u0139\u0001\u0000\u0000\u0000\u013b\u013c\u0001"+
|
|
"\u0000\u0000\u0000\u013c\u013d\u0001\u0000\u0000\u0000\u013d\u013e\u0005"+
|
|
"T\u0000\u0000\u013e\u0005\u0001\u0000\u0000\u0000\u013f\u0141\u0003\n"+
|
|
"\u0005\u0000\u0140\u013f\u0001\u0000\u0000\u0000\u0141\u0144\u0001\u0000"+
|
|
"\u0000\u0000\u0142\u0140\u0001\u0000\u0000\u0000\u0142\u0143\u0001\u0000"+
|
|
"\u0000\u0000\u0143\u014a\u0001\u0000\u0000\u0000\u0144\u0142\u0001\u0000"+
|
|
"\u0000\u0000\u0145\u014b\u0003\u000e\u0007\u0000\u0146\u014b\u0003\u0016"+
|
|
"\u000b\u0000\u0147\u014b\u0003\u001e\u000f\u0000\u0148\u014b\u0003\u0086"+
|
|
"C\u0000\u0149\u014b\u0003\u009eO\u0000\u014a\u0145\u0001\u0000\u0000\u0000"+
|
|
"\u014a\u0146\u0001\u0000\u0000\u0000\u014a\u0147\u0001\u0000\u0000\u0000"+
|
|
"\u014a\u0148\u0001\u0000\u0000\u0000\u014a\u0149\u0001\u0000\u0000\u0000"+
|
|
"\u014b\u014e\u0001\u0000\u0000\u0000\u014c\u014e\u0005T\u0000\u0000\u014d"+
|
|
"\u0142\u0001\u0000\u0000\u0000\u014d\u014c\u0001\u0000\u0000\u0000\u014e"+
|
|
"\u0007\u0001\u0000\u0000\u0000\u014f\u0155\u0003\n\u0005\u0000\u0150\u0155"+
|
|
"\u0005\u001e\u0000\u0000\u0151\u0155\u0005*\u0000\u0000\u0152\u0155\u0005"+
|
|
".\u0000\u0000\u0153\u0155\u00051\u0000\u0000\u0154\u014f\u0001\u0000\u0000"+
|
|
"\u0000\u0154\u0150\u0001\u0000\u0000\u0000\u0154\u0151\u0001\u0000\u0000"+
|
|
"\u0000\u0154\u0152\u0001\u0000\u0000\u0000\u0154\u0153\u0001\u0000\u0000"+
|
|
"\u0000\u0155\t\u0001\u0000\u0000\u0000\u0156\u0161\u0003|>\u0000\u0157"+
|
|
"\u0161\u0005#\u0000\u0000\u0158\u0161\u0005\"\u0000\u0000\u0159\u0161"+
|
|
"\u0005!\u0000\u0000\u015a\u0161\u0005&\u0000\u0000\u015b\u0161\u0005\u0001"+
|
|
"\u0000\u0000\u015c\u0161\u0005\u0012\u0000\u0000\u015d\u0161\u0005\'\u0000"+
|
|
"\u0000\u015e\u0161\u0005@\u0000\u0000\u015f\u0161\u0005B\u0000\u0000\u0160"+
|
|
"\u0156\u0001\u0000\u0000\u0000\u0160\u0157\u0001\u0000\u0000\u0000\u0160"+
|
|
"\u0158\u0001\u0000\u0000\u0000\u0160\u0159\u0001\u0000\u0000\u0000\u0160"+
|
|
"\u015a\u0001\u0000\u0000\u0000\u0160\u015b\u0001\u0000\u0000\u0000\u0160"+
|
|
"\u015c\u0001\u0000\u0000\u0000\u0160\u015d\u0001\u0000\u0000\u0000\u0160"+
|
|
"\u015e\u0001\u0000\u0000\u0000\u0160\u015f\u0001\u0000\u0000\u0000\u0161"+
|
|
"\u000b\u0001\u0000\u0000\u0000\u0162\u0165\u0005\u0012\u0000\u0000\u0163"+
|
|
"\u0165\u0003|>\u0000\u0164\u0162\u0001\u0000\u0000\u0000\u0164\u0163\u0001"+
|
|
"\u0000\u0000\u0000\u0165\r\u0001\u0000\u0000\u0000\u0166\u0167\u0005\t"+
|
|
"\u0000\u0000\u0167\u0169\u0003\u00aeW\u0000\u0168\u016a\u0003\u0010\b"+
|
|
"\u0000\u0169\u0168\u0001\u0000\u0000\u0000\u0169\u016a\u0001\u0000\u0000"+
|
|
"\u0000\u016a\u016d\u0001\u0000\u0000\u0000\u016b\u016c\u0005\u0011\u0000"+
|
|
"\u0000\u016c\u016e\u0003\u010a\u0085\u0000\u016d\u016b\u0001\u0000\u0000"+
|
|
"\u0000\u016d\u016e\u0001\u0000\u0000\u0000\u016e\u0171\u0001\u0000\u0000"+
|
|
"\u0000\u016f\u0170\u0005\u0018\u0000\u0000\u0170\u0172\u0003\u0108\u0084"+
|
|
"\u0000\u0171\u016f\u0001\u0000\u0000\u0000\u0171\u0172\u0001\u0000\u0000"+
|
|
"\u0000\u0172\u0175\u0001\u0000\u0000\u0000\u0173\u0174\u0005A\u0000\u0000"+
|
|
"\u0174\u0176\u0003\u0108\u0084\u0000\u0175\u0173\u0001\u0000\u0000\u0000"+
|
|
"\u0175\u0176\u0001\u0000\u0000\u0000\u0176\u0177\u0001\u0000\u0000\u0000"+
|
|
"\u0177\u0178\u0003 \u0010\u0000\u0178\u000f\u0001\u0000\u0000\u0000\u0179"+
|
|
"\u017a\u0005Y\u0000\u0000\u017a\u017f\u0003\u0012\t\u0000\u017b\u017c"+
|
|
"\u0005U\u0000\u0000\u017c\u017e\u0003\u0012\t\u0000\u017d\u017b\u0001"+
|
|
"\u0000\u0000\u0000\u017e\u0181\u0001\u0000\u0000\u0000\u017f\u017d\u0001"+
|
|
"\u0000\u0000\u0000\u017f\u0180\u0001\u0000\u0000\u0000\u0180\u0182\u0001"+
|
|
"\u0000\u0000\u0000\u0181\u017f\u0001\u0000\u0000\u0000\u0182\u0183\u0005"+
|
|
"X\u0000\u0000\u0183\u0011\u0001\u0000\u0000\u0000\u0184\u0186\u0003|>"+
|
|
"\u0000\u0185\u0184\u0001\u0000\u0000\u0000\u0186\u0189\u0001\u0000\u0000"+
|
|
"\u0000\u0187\u0185\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000\u0000"+
|
|
"\u0000\u0188\u018a\u0001\u0000\u0000\u0000\u0189\u0187\u0001\u0000\u0000"+
|
|
"\u0000\u018a\u0193\u0003\u00aeW\u0000\u018b\u018f\u0007\u0000\u0000\u0000"+
|
|
"\u018c\u018e\u0003|>\u0000\u018d\u018c\u0001\u0000\u0000\u0000\u018e\u0191"+
|
|
"\u0001\u0000\u0000\u0000\u018f\u018d\u0001\u0000\u0000\u0000\u018f\u0190"+
|
|
"\u0001\u0000\u0000\u0000\u0190\u0192\u0001\u0000\u0000\u0000\u0191\u018f"+
|
|
"\u0001\u0000\u0000\u0000\u0192\u0194\u0003\u0014\n\u0000\u0193\u018b\u0001"+
|
|
"\u0000\u0000\u0000\u0193\u0194\u0001\u0000\u0000\u0000\u0194\u0013\u0001"+
|
|
"\u0000\u0000\u0000\u0195\u019a\u0003\u010a\u0085\u0000\u0196\u0197\u0005"+
|
|
"j\u0000\u0000\u0197\u0199\u0003\u010a\u0085\u0000\u0198\u0196\u0001\u0000"+
|
|
"\u0000\u0000\u0199\u019c\u0001\u0000\u0000\u0000\u019a\u0198\u0001\u0000"+
|
|
"\u0000\u0000\u019a\u019b\u0001\u0000\u0000\u0000\u019b\u0015\u0001\u0000"+
|
|
"\u0000\u0000\u019c\u019a\u0001\u0000\u0000\u0000\u019d\u019e\u0005\u0010"+
|
|
"\u0000\u0000\u019e\u01a1\u0003\u00aeW\u0000\u019f\u01a0\u0005\u0018\u0000"+
|
|
"\u0000\u01a0\u01a2\u0003\u0108\u0084\u0000\u01a1\u019f\u0001\u0000\u0000"+
|
|
"\u0000\u01a1\u01a2\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001\u0000\u0000"+
|
|
"\u0000\u01a3\u01a5\u0005P\u0000\u0000\u01a4\u01a6\u0003\u0018\f\u0000"+
|
|
"\u01a5\u01a4\u0001\u0000\u0000\u0000\u01a5\u01a6\u0001\u0000\u0000\u0000"+
|
|
"\u01a6\u01a8\u0001\u0000\u0000\u0000\u01a7\u01a9\u0005U\u0000\u0000\u01a8"+
|
|
"\u01a7\u0001\u0000\u0000\u0000\u01a8\u01a9\u0001\u0000\u0000\u0000\u01a9"+
|
|
"\u01ab\u0001\u0000\u0000\u0000\u01aa\u01ac\u0003\u001c\u000e\u0000\u01ab"+
|
|
"\u01aa\u0001\u0000\u0000\u0000\u01ab\u01ac\u0001\u0000\u0000\u0000\u01ac"+
|
|
"\u01ad\u0001\u0000\u0000\u0000\u01ad\u01ae\u0005Q\u0000\u0000\u01ae\u0017"+
|
|
"\u0001\u0000\u0000\u0000\u01af\u01b4\u0003\u001a\r\u0000\u01b0\u01b1\u0005"+
|
|
"U\u0000\u0000\u01b1\u01b3\u0003\u001a\r\u0000\u01b2\u01b0\u0001\u0000"+
|
|
"\u0000\u0000\u01b3\u01b6\u0001\u0000\u0000\u0000\u01b4\u01b2\u0001\u0000"+
|
|
"\u0000\u0000\u01b4\u01b5\u0001\u0000\u0000\u0000\u01b5\u0019\u0001\u0000"+
|
|
"\u0000\u0000\u01b6\u01b4\u0001\u0000\u0000\u0000\u01b7\u01b9\u0003|>\u0000"+
|
|
"\u01b8\u01b7\u0001\u0000\u0000\u0000\u01b9\u01bc\u0001\u0000\u0000\u0000"+
|
|
"\u01ba\u01b8\u0001\u0000\u0000\u0000\u01ba\u01bb\u0001\u0000\u0000\u0000"+
|
|
"\u01bb\u01bd\u0001\u0000\u0000\u0000\u01bc\u01ba\u0001\u0000\u0000\u0000"+
|
|
"\u01bd\u01bf\u0003\u00aeW\u0000\u01be\u01c0\u0003\u0114\u008a\u0000\u01bf"+
|
|
"\u01be\u0001\u0000\u0000\u0000\u01bf\u01c0\u0001\u0000\u0000\u0000\u01c0"+
|
|
"\u01c2\u0001\u0000\u0000\u0000\u01c1\u01c3\u0003 \u0010\u0000\u01c2\u01c1"+
|
|
"\u0001\u0000\u0000\u0000\u01c2\u01c3\u0001\u0000\u0000\u0000\u01c3\u001b"+
|
|
"\u0001\u0000\u0000\u0000\u01c4\u01c8\u0005T\u0000\u0000\u01c5\u01c7\u0003"+
|
|
"$\u0012\u0000\u01c6\u01c5\u0001\u0000\u0000\u0000\u01c7\u01ca\u0001\u0000"+
|
|
"\u0000\u0000\u01c8\u01c6\u0001\u0000\u0000\u0000\u01c8\u01c9\u0001\u0000"+
|
|
"\u0000\u0000\u01c9\u001d\u0001\u0000\u0000\u0000\u01ca\u01c8\u0001\u0000"+
|
|
"\u0000\u0000\u01cb\u01cc\u0005\u001c\u0000\u0000\u01cc\u01ce\u0003\u00ae"+
|
|
"W\u0000\u01cd\u01cf\u0003\u0010\b\u0000\u01ce\u01cd\u0001\u0000\u0000"+
|
|
"\u0000\u01ce\u01cf\u0001\u0000\u0000\u0000\u01cf\u01d2\u0001\u0000\u0000"+
|
|
"\u0000\u01d0\u01d1\u0005\u0011\u0000\u0000\u01d1\u01d3\u0003\u0108\u0084"+
|
|
"\u0000\u01d2\u01d0\u0001\u0000\u0000\u0000\u01d2\u01d3\u0001\u0000\u0000"+
|
|
"\u0000\u01d3\u01d6\u0001\u0000\u0000\u0000\u01d4\u01d5\u0005A\u0000\u0000"+
|
|
"\u01d5\u01d7\u0003\u0108\u0084\u0000\u01d6\u01d4\u0001\u0000\u0000\u0000"+
|
|
"\u01d6\u01d7\u0001\u0000\u0000\u0000\u01d7\u01d8\u0001\u0000\u0000\u0000"+
|
|
"\u01d8\u01d9\u0003\"\u0011\u0000\u01d9\u001f\u0001\u0000\u0000\u0000\u01da"+
|
|
"\u01de\u0005P\u0000\u0000\u01db\u01dd\u0003$\u0012\u0000\u01dc\u01db\u0001"+
|
|
"\u0000\u0000\u0000\u01dd\u01e0\u0001\u0000\u0000\u0000\u01de\u01dc\u0001"+
|
|
"\u0000\u0000\u0000\u01de\u01df\u0001\u0000\u0000\u0000\u01df\u01e1\u0001"+
|
|
"\u0000\u0000\u0000\u01e0\u01de\u0001\u0000\u0000\u0000\u01e1\u01e2\u0005"+
|
|
"Q\u0000\u0000\u01e2!\u0001\u0000\u0000\u0000\u01e3\u01e7\u0005P\u0000"+
|
|
"\u0000\u01e4\u01e6\u0003<\u001e\u0000\u01e5\u01e4\u0001\u0000\u0000\u0000"+
|
|
"\u01e6\u01e9\u0001\u0000\u0000\u0000\u01e7\u01e5\u0001\u0000\u0000\u0000"+
|
|
"\u01e7\u01e8\u0001\u0000\u0000\u0000\u01e8\u01ea\u0001\u0000\u0000\u0000"+
|
|
"\u01e9\u01e7\u0001\u0000\u0000\u0000\u01ea\u01eb\u0005Q\u0000\u0000\u01eb"+
|
|
"#\u0001\u0000\u0000\u0000\u01ec\u01f9\u0005T\u0000\u0000\u01ed\u01ef\u0005"+
|
|
"&\u0000\u0000\u01ee\u01ed\u0001\u0000\u0000\u0000\u01ee\u01ef\u0001\u0000"+
|
|
"\u0000\u0000\u01ef\u01f0\u0001\u0000\u0000\u0000\u01f0\u01f9\u0003\u00a8"+
|
|
"T\u0000\u01f1\u01f3\u0003\b\u0004\u0000\u01f2\u01f1\u0001\u0000\u0000"+
|
|
"\u0000\u01f3\u01f6\u0001\u0000\u0000\u0000\u01f4\u01f2\u0001\u0000\u0000"+
|
|
"\u0000\u01f4\u01f5\u0001\u0000\u0000\u0000\u01f5\u01f7\u0001\u0000\u0000"+
|
|
"\u0000\u01f6\u01f4\u0001\u0000\u0000\u0000\u01f7\u01f9\u0003&\u0013\u0000"+
|
|
"\u01f8\u01ec\u0001\u0000\u0000\u0000\u01f8\u01ee\u0001\u0000\u0000\u0000"+
|
|
"\u01f8\u01f4\u0001\u0000\u0000\u0000\u01f9%\u0001\u0000\u0000\u0000\u01fa"+
|
|
"\u01ff\u0003\u0006\u0003\u0000\u01fb\u01ff\u0003:\u001d\u0000\u01fc\u01ff"+
|
|
"\u0003(\u0014\u0000\u01fd\u01ff\u00034\u001a\u0000\u01fe\u01fa\u0001\u0000"+
|
|
"\u0000\u0000\u01fe\u01fb\u0001\u0000\u0000\u0000\u01fe\u01fc\u0001\u0000"+
|
|
"\u0000\u0000\u01fe\u01fd\u0001\u0000\u0000\u0000\u01ff\'\u0001\u0000\u0000"+
|
|
"\u0000\u0200\u0203\u0003*\u0015\u0000\u0201\u0203\u00032\u0019\u0000\u0202"+
|
|
"\u0200\u0001\u0000\u0000\u0000\u0202\u0201\u0001\u0000\u0000\u0000\u0203"+
|
|
")\u0001\u0000\u0000\u0000\u0204\u0207\u0003,\u0016\u0000\u0205\u0206\u0005"+
|
|
"-\u0000\u0000\u0206\u0208\u0003b1\u0000\u0207\u0205\u0001\u0000\u0000"+
|
|
"\u0000\u0207\u0208\u0001\u0000\u0000\u0000\u0208\u0209\u0001\u0000\u0000"+
|
|
"\u0000\u0209\u020a\u0003.\u0017\u0000\u020a+\u0001\u0000\u0000\u0000\u020b"+
|
|
"\u020d\u00030\u0018\u0000\u020c\u020b\u0001\u0000\u0000\u0000\u020c\u020d"+
|
|
"\u0001\u0000\u0000\u0000\u020d\u020e\u0001\u0000\u0000\u0000\u020e\u020f"+
|
|
"\u0003\u00aeW\u0000\u020f\u0214\u0003d2\u0000\u0210\u0211\u0005R\u0000"+
|
|
"\u0000\u0211\u0213\u0005S\u0000\u0000\u0212\u0210\u0001\u0000\u0000\u0000"+
|
|
"\u0213\u0216\u0001\u0000\u0000\u0000\u0214\u0212\u0001\u0000\u0000\u0000"+
|
|
"\u0214\u0215\u0001\u0000\u0000\u0000\u0215-\u0001\u0000\u0000\u0000\u0216"+
|
|
"\u0214\u0001\u0000\u0000\u0000\u0217\u021a\u0003\u00a8T\u0000\u0218\u021a"+
|
|
"\u0005T\u0000\u0000\u0219\u0217\u0001\u0000\u0000\u0000\u0219\u0218\u0001"+
|
|
"\u0000\u0000\u0000\u021a/\u0001\u0000\u0000\u0000\u021b\u021e\u0003\u010a"+
|
|
"\u0085\u0000\u021c\u021e\u00050\u0000\u0000\u021d\u021b\u0001\u0000\u0000"+
|
|
"\u0000\u021d\u021c\u0001\u0000\u0000\u0000\u021e1\u0001\u0000\u0000\u0000"+
|
|
"\u021f\u0220\u0003\u0010\b\u0000\u0220\u0221\u0003*\u0015\u0000\u0221"+
|
|
"3\u0001\u0000\u0000\u0000\u0222\u0225\u00036\u001b\u0000\u0223\u0225\u0003"+
|
|
"8\u001c\u0000\u0224\u0222\u0001\u0000\u0000\u0000\u0224\u0223\u0001\u0000"+
|
|
"\u0000\u0000\u02255\u0001\u0000\u0000\u0000\u0226\u0227\u0003\u0010\b"+
|
|
"\u0000\u0227\u0228\u00038\u001c\u0000\u02287\u0001\u0000\u0000\u0000\u0229"+
|
|
"\u022a\u0003\u00aeW\u0000\u022a\u022d\u0003d2\u0000\u022b\u022c\u0005"+
|
|
"-\u0000\u0000\u022c\u022e\u0003b1\u0000\u022d\u022b\u0001\u0000\u0000"+
|
|
"\u0000\u022d\u022e\u0001\u0000\u0000\u0000\u022e\u022f\u0001\u0000\u0000"+
|
|
"\u0000\u022f\u0230\u0003\u00a8T\u0000\u02309\u0001\u0000\u0000\u0000\u0231"+
|
|
"\u0233\u0003\u010a\u0085\u0000\u0232\u0231\u0001\u0000\u0000\u0000\u0232"+
|
|
"\u0233\u0001\u0000\u0000\u0000\u0233\u0234\u0001\u0000\u0000\u0000\u0234"+
|
|
"\u0235\u0003L&\u0000\u0235\u0236\u0005T\u0000\u0000\u0236;\u0001\u0000"+
|
|
"\u0000\u0000\u0237\u0239\u0003\b\u0004\u0000\u0238\u0237\u0001\u0000\u0000"+
|
|
"\u0000\u0239\u023c\u0001\u0000\u0000\u0000\u023a\u0238\u0001\u0000\u0000"+
|
|
"\u0000\u023a\u023b\u0001\u0000\u0000\u0000\u023b\u023d\u0001\u0000\u0000"+
|
|
"\u0000\u023c\u023a\u0001\u0000\u0000\u0000\u023d\u0240\u0003>\u001f\u0000"+
|
|
"\u023e\u0240\u0005T\u0000\u0000\u023f\u023a\u0001\u0000\u0000\u0000\u023f"+
|
|
"\u023e\u0001\u0000\u0000\u0000\u0240=\u0001\u0000\u0000\u0000\u0241\u0246"+
|
|
"\u0003@ \u0000\u0242\u0246\u0003D\"\u0000\u0243\u0246\u0003H$\u0000\u0244"+
|
|
"\u0246\u0003\u0006\u0003\u0000\u0245\u0241\u0001\u0000\u0000\u0000\u0245"+
|
|
"\u0242\u0001\u0000\u0000\u0000\u0245\u0243\u0001\u0000\u0000\u0000\u0245"+
|
|
"\u0244\u0001\u0000\u0000\u0000\u0246?\u0001\u0000\u0000\u0000\u0247\u0249"+
|
|
"\u0003\u010a\u0085\u0000\u0248\u0247\u0001\u0000\u0000\u0000\u0248\u0249"+
|
|
"\u0001\u0000\u0000\u0000\u0249\u024a\u0001\u0000\u0000\u0000\u024a\u024f"+
|
|
"\u0003B!\u0000\u024b\u024c\u0005U\u0000\u0000\u024c\u024e\u0003B!\u0000"+
|
|
"\u024d\u024b\u0001\u0000\u0000\u0000\u024e\u0251\u0001\u0000\u0000\u0000"+
|
|
"\u024f\u024d\u0001\u0000\u0000\u0000\u024f\u0250\u0001\u0000\u0000\u0000"+
|
|
"\u0250\u0252\u0001\u0000\u0000\u0000\u0251\u024f\u0001\u0000\u0000\u0000"+
|
|
"\u0252\u0253\u0005T\u0000\u0000\u0253A\u0001\u0000\u0000\u0000\u0254\u0259"+
|
|
"\u0003\u00aeW\u0000\u0255\u0256\u0005R\u0000\u0000\u0256\u0258\u0005S"+
|
|
"\u0000\u0000\u0257\u0255\u0001\u0000\u0000\u0000\u0258\u025b\u0001\u0000"+
|
|
"\u0000\u0000\u0259\u0257\u0001\u0000\u0000\u0000\u0259\u025a\u0001\u0000"+
|
|
"\u0000\u0000\u025a\u025c\u0001\u0000\u0000\u0000\u025b\u0259\u0001\u0000"+
|
|
"\u0000\u0000\u025c\u025d\u0005W\u0000\u0000\u025d\u025e\u0003R)\u0000"+
|
|
"\u025eC\u0001\u0000\u0000\u0000\u025f\u0261\u0003F#\u0000\u0260\u025f"+
|
|
"\u0001\u0000\u0000\u0000\u0261\u0264\u0001\u0000\u0000\u0000\u0262\u0260"+
|
|
"\u0001\u0000\u0000\u0000\u0262\u0263\u0001\u0000\u0000\u0000\u0263\u0265"+
|
|
"\u0001\u0000\u0000\u0000\u0264\u0262\u0001\u0000\u0000\u0000\u0265\u0266"+
|
|
"\u0003J%\u0000\u0266E\u0001\u0000\u0000\u0000\u0267\u026e\u0003|>\u0000"+
|
|
"\u0268\u026e\u0005#\u0000\u0000\u0269\u026e\u0005\u0001\u0000\u0000\u026a"+
|
|
"\u026e\u0005\f\u0000\u0000\u026b\u026e\u0005&\u0000\u0000\u026c\u026e"+
|
|
"\u0005\'\u0000\u0000\u026d\u0267\u0001\u0000\u0000\u0000\u026d\u0268\u0001"+
|
|
"\u0000\u0000\u0000\u026d\u0269\u0001\u0000\u0000\u0000\u026d\u026a\u0001"+
|
|
"\u0000\u0000\u0000\u026d\u026b\u0001\u0000\u0000\u0000\u026d\u026c\u0001"+
|
|
"\u0000\u0000\u0000\u026eG\u0001\u0000\u0000\u0000\u026f\u0271\u0003F#"+
|
|
"\u0000\u0270\u026f\u0001\u0000\u0000\u0000\u0271\u0274\u0001\u0000\u0000"+
|
|
"\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000\u0000"+
|
|
"\u0000\u0273\u0275\u0001\u0000\u0000\u0000\u0274\u0272\u0001\u0000\u0000"+
|
|
"\u0000\u0275\u0276\u0003\u0010\b\u0000\u0276\u0277\u0003J%\u0000\u0277"+
|
|
"I\u0001\u0000\u0000\u0000\u0278\u027a\u0003|>\u0000\u0279\u0278\u0001"+
|
|
"\u0000\u0000\u0000\u027a\u027d\u0001\u0000\u0000\u0000\u027b\u0279\u0001"+
|
|
"\u0000\u0000\u0000\u027b\u027c\u0001\u0000\u0000\u0000\u027c\u027f\u0001"+
|
|
"\u0000\u0000\u0000\u027d\u027b\u0001\u0000\u0000\u0000\u027e\u0280\u0003"+
|
|
"0\u0018\u0000\u027f\u027e\u0001\u0000\u0000\u0000\u027f\u0280\u0001\u0000"+
|
|
"\u0000\u0000\u0280\u0281\u0001\u0000\u0000\u0000\u0281\u0282\u0003\u00ae"+
|
|
"W\u0000\u0282\u0287\u0003d2\u0000\u0283\u0284\u0005R\u0000\u0000\u0284"+
|
|
"\u0286\u0005S\u0000\u0000\u0285\u0283\u0001\u0000\u0000\u0000\u0286\u0289"+
|
|
"\u0001\u0000\u0000\u0000\u0287\u0285\u0001\u0000\u0000\u0000\u0287\u0288"+
|
|
"\u0001\u0000\u0000\u0000\u0288\u028c\u0001\u0000\u0000\u0000\u0289\u0287"+
|
|
"\u0001\u0000\u0000\u0000\u028a\u028b\u0005-\u0000\u0000\u028b\u028d\u0003"+
|
|
"b1\u0000\u028c\u028a\u0001\u0000\u0000\u0000\u028c\u028d\u0001\u0000\u0000"+
|
|
"\u0000\u028d\u028e\u0001\u0000\u0000\u0000\u028e\u028f\u0003.\u0017\u0000"+
|
|
"\u028fK\u0001\u0000\u0000\u0000\u0290\u0295\u0003N\'\u0000\u0291\u0292"+
|
|
"\u0005U\u0000\u0000\u0292\u0294\u0003N\'\u0000\u0293\u0291\u0001\u0000"+
|
|
"\u0000\u0000\u0294\u0297\u0001\u0000\u0000\u0000\u0295\u0293\u0001\u0000"+
|
|
"\u0000\u0000\u0295\u0296\u0001\u0000\u0000\u0000\u0296M\u0001\u0000\u0000"+
|
|
"\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0298\u029b\u0003P(\u0000\u0299"+
|
|
"\u029a\u0005W\u0000\u0000\u029a\u029c\u0003R)\u0000\u029b\u0299\u0001"+
|
|
"\u0000\u0000\u0000\u029b\u029c\u0001\u0000\u0000\u0000\u029cO\u0001\u0000"+
|
|
"\u0000\u0000\u029d\u02a2\u0003\u00aeW\u0000\u029e\u029f\u0005R\u0000\u0000"+
|
|
"\u029f\u02a1\u0005S\u0000\u0000\u02a0\u029e\u0001\u0000\u0000\u0000\u02a1"+
|
|
"\u02a4\u0001\u0000\u0000\u0000\u02a2\u02a0\u0001\u0000\u0000\u0000\u02a2"+
|
|
"\u02a3\u0001\u0000\u0000\u0000\u02a3Q\u0001\u0000\u0000\u0000\u02a4\u02a2"+
|
|
"\u0001\u0000\u0000\u0000\u02a5\u02a8\u0003T*\u0000\u02a6\u02a8\u0003\u00d2"+
|
|
"i\u0000\u02a7\u02a5\u0001\u0000\u0000\u0000\u02a7\u02a6\u0001\u0000\u0000"+
|
|
"\u0000\u02a8S\u0001\u0000\u0000\u0000\u02a9\u02b5\u0005P\u0000\u0000\u02aa"+
|
|
"\u02af\u0003R)\u0000\u02ab\u02ac\u0005U\u0000\u0000\u02ac\u02ae\u0003"+
|
|
"R)\u0000\u02ad\u02ab\u0001\u0000\u0000\u0000\u02ae\u02b1\u0001\u0000\u0000"+
|
|
"\u0000\u02af\u02ad\u0001\u0000\u0000\u0000\u02af\u02b0\u0001\u0000\u0000"+
|
|
"\u0000\u02b0\u02b3\u0001\u0000\u0000\u0000\u02b1\u02af\u0001\u0000\u0000"+
|
|
"\u0000\u02b2\u02b4\u0005U\u0000\u0000\u02b3\u02b2\u0001\u0000\u0000\u0000"+
|
|
"\u02b3\u02b4\u0001\u0000\u0000\u0000\u02b4\u02b6\u0001\u0000\u0000\u0000"+
|
|
"\u02b5\u02aa\u0001\u0000\u0000\u0000\u02b5\u02b6\u0001\u0000\u0000\u0000"+
|
|
"\u02b6\u02b7\u0001\u0000\u0000\u0000\u02b7\u02b8\u0005Q\u0000\u0000\u02b8"+
|
|
"U\u0001\u0000\u0000\u0000\u02b9\u02bb\u0003\u00aeW\u0000\u02ba\u02bc\u0003"+
|
|
"\u010e\u0087\u0000\u02bb\u02ba\u0001\u0000\u0000\u0000\u02bb\u02bc\u0001"+
|
|
"\u0000\u0000\u0000\u02bc\u02bd\u0001\u0000\u0000\u0000\u02bd\u02be\u0005"+
|
|
"V\u0000\u0000\u02be\u02c0\u0001\u0000\u0000\u0000\u02bf\u02b9\u0001\u0000"+
|
|
"\u0000\u0000\u02c0\u02c3\u0001\u0000\u0000\u0000\u02c1\u02bf\u0001\u0000"+
|
|
"\u0000\u0000\u02c1\u02c2\u0001\u0000\u0000\u0000\u02c2\u02c4\u0001\u0000"+
|
|
"\u0000\u0000\u02c3\u02c1\u0001\u0000\u0000\u0000\u02c4\u02c6\u0003\u00b0"+
|
|
"X\u0000\u02c5\u02c7\u0003\u010e\u0087\u0000\u02c6\u02c5\u0001\u0000\u0000"+
|
|
"\u0000\u02c6\u02c7\u0001\u0000\u0000\u0000\u02c7W\u0001\u0000\u0000\u0000"+
|
|
"\u02c8\u02cb\u0003\u010a\u0085\u0000\u02c9\u02cb\u0003Z-\u0000\u02ca\u02c8"+
|
|
"\u0001\u0000\u0000\u0000\u02ca\u02c9\u0001\u0000\u0000\u0000\u02cbY\u0001"+
|
|
"\u0000\u0000\u0000\u02cc\u02ce\u0003|>\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\u02d2\u0001\u0000\u0000"+
|
|
"\u0000\u02d1\u02cf\u0001\u0000\u0000\u0000\u02d2\u02d5\u0005\\\u0000\u0000"+
|
|
"\u02d3\u02d6\u0003\\.\u0000\u02d4\u02d6\u0003^/\u0000\u02d5\u02d3\u0001"+
|
|
"\u0000\u0000\u0000\u02d5\u02d4\u0001\u0000\u0000\u0000\u02d5\u02d6\u0001"+
|
|
"\u0000\u0000\u0000\u02d6[\u0001\u0000\u0000\u0000\u02d7\u02d8\u0005\u0011"+
|
|
"\u0000\u0000\u02d8\u02d9\u0003\u010a\u0085\u0000\u02d9]\u0001\u0000\u0000"+
|
|
"\u0000\u02da\u02db\u0005(\u0000\u0000\u02db\u02dc\u0003\u010a\u0085\u0000"+
|
|
"\u02dc_\u0001\u0000\u0000\u0000\u02dd\u02e2\u0003r9\u0000\u02de\u02df"+
|
|
"\u0005U\u0000\u0000\u02df\u02e1\u0003r9\u0000\u02e0\u02de\u0001\u0000"+
|
|
"\u0000\u0000\u02e1\u02e4\u0001\u0000\u0000\u0000\u02e2\u02e0\u0001\u0000"+
|
|
"\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000\u0000\u02e3a\u0001\u0000\u0000"+
|
|
"\u0000\u02e4\u02e2\u0001\u0000\u0000\u0000\u02e5\u02e6\u0003`0\u0000\u02e6"+
|
|
"c\u0001\u0000\u0000\u0000\u02e7\u02f3\u0005N\u0000\u0000\u02e8\u02ea\u0003"+
|
|
"f3\u0000\u02e9\u02e8\u0001\u0000\u0000\u0000\u02e9\u02ea\u0001\u0000\u0000"+
|
|
"\u0000\u02ea\u02f4\u0001\u0000\u0000\u0000\u02eb\u02ee\u0003f3\u0000\u02ec"+
|
|
"\u02ed\u0005U\u0000\u0000\u02ed\u02ef\u0003h4\u0000\u02ee\u02ec\u0001"+
|
|
"\u0000\u0000\u0000\u02ee\u02ef\u0001\u0000\u0000\u0000\u02ef\u02f4\u0001"+
|
|
"\u0000\u0000\u0000\u02f0\u02f2\u0003h4\u0000\u02f1\u02f0\u0001\u0000\u0000"+
|
|
"\u0000\u02f1\u02f2\u0001\u0000\u0000\u0000\u02f2\u02f4\u0001\u0000\u0000"+
|
|
"\u0000\u02f3\u02e9\u0001\u0000\u0000\u0000\u02f3\u02eb\u0001\u0000\u0000"+
|
|
"\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f4\u02f5\u0001\u0000\u0000"+
|
|
"\u0000\u02f5\u02f6\u0005O\u0000\u0000\u02f6e\u0001\u0000\u0000\u0000\u02f7"+
|
|
"\u02f9\u0003\u010a\u0085\u0000\u02f8\u02f7\u0001\u0000\u0000\u0000\u02f8"+
|
|
"\u02f9\u0001\u0000\u0000\u0000\u02f9\u02ff\u0001\u0000\u0000\u0000\u02fa"+
|
|
"\u02fb\u0003\u00aeW\u0000\u02fb\u02fc\u0005V\u0000\u0000\u02fc\u02fe\u0001"+
|
|
"\u0000\u0000\u0000\u02fd\u02fa\u0001\u0000\u0000\u0000\u02fe\u0301\u0001"+
|
|
"\u0000\u0000\u0000\u02ff\u02fd\u0001\u0000\u0000\u0000\u02ff\u0300\u0001"+
|
|
"\u0000\u0000\u0000\u0300\u0302\u0001\u0000\u0000\u0000\u0301\u02ff\u0001"+
|
|
"\u0000\u0000\u0000\u0302\u0303\u0005+\u0000\u0000\u0303g\u0001\u0000\u0000"+
|
|
"\u0000\u0304\u0309\u0003j5\u0000\u0305\u0306\u0005U\u0000\u0000\u0306"+
|
|
"\u0308\u0003j5\u0000\u0307\u0305\u0001\u0000\u0000\u0000\u0308\u030b\u0001"+
|
|
"\u0000\u0000\u0000\u0309\u0307\u0001\u0000\u0000\u0000\u0309\u030a\u0001"+
|
|
"\u0000\u0000\u0000\u030a\u030e\u0001\u0000\u0000\u0000\u030b\u0309\u0001"+
|
|
"\u0000\u0000\u0000\u030c\u030d\u0005U\u0000\u0000\u030d\u030f\u0003l6"+
|
|
"\u0000\u030e\u030c\u0001\u0000\u0000\u0000\u030e\u030f\u0001\u0000\u0000"+
|
|
"\u0000\u030f\u0312\u0001\u0000\u0000\u0000\u0310\u0312\u0003l6\u0000\u0311"+
|
|
"\u0304\u0001\u0000\u0000\u0000\u0311\u0310\u0001\u0000\u0000\u0000\u0312"+
|
|
"i\u0001\u0000\u0000\u0000\u0313\u0315\u0003\f\u0006\u0000\u0314\u0313"+
|
|
"\u0001\u0000\u0000\u0000\u0315\u0318\u0001\u0000\u0000\u0000\u0316\u0314"+
|
|
"\u0001\u0000\u0000\u0000\u0316\u0317\u0001\u0000\u0000\u0000\u0317\u031a"+
|
|
"\u0001\u0000\u0000\u0000\u0318\u0316\u0001\u0000\u0000\u0000\u0319\u031b"+
|
|
"\u0003\u010a\u0085\u0000\u031a\u0319\u0001\u0000\u0000\u0000\u031a\u031b"+
|
|
"\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000\u0000\u0000\u031c\u031f"+
|
|
"\u0003P(\u0000\u031d\u031f\u0003\u00d4j\u0000\u031e\u0316\u0001\u0000"+
|
|
"\u0000\u0000\u031e\u031d\u0001\u0000\u0000\u0000\u031fk\u0001\u0000\u0000"+
|
|
"\u0000\u0320\u0322\u0003\f\u0006\u0000\u0321\u0320\u0001\u0000\u0000\u0000"+
|
|
"\u0322\u0325\u0001\u0000\u0000\u0000\u0323\u0321\u0001\u0000\u0000\u0000"+
|
|
"\u0323\u0324\u0001\u0000\u0000\u0000\u0324\u0327\u0001\u0000\u0000\u0000"+
|
|
"\u0325\u0323\u0001\u0000\u0000\u0000\u0326\u0328\u0003\u010a\u0085\u0000"+
|
|
"\u0327\u0326\u0001\u0000\u0000\u0000\u0327\u0328\u0001\u0000\u0000\u0000"+
|
|
"\u0328\u032c\u0001\u0000\u0000\u0000\u0329\u032b\u0003|>\u0000\u032a\u0329"+
|
|
"\u0001\u0000\u0000\u0000\u032b\u032e\u0001\u0000\u0000\u0000\u032c\u032a"+
|
|
"\u0001\u0000\u0000\u0000\u032c\u032d\u0001\u0000\u0000\u0000\u032d\u032f"+
|
|
"\u0001\u0000\u0000\u0000\u032e\u032c\u0001\u0000\u0000\u0000\u032f\u0330"+
|
|
"\u0005|\u0000\u0000\u0330\u0331\u0003P(\u0000\u0331m\u0001\u0000\u0000"+
|
|
"\u0000\u0332\u0337\u0003p8\u0000\u0333\u0334\u0005U\u0000\u0000\u0334"+
|
|
"\u0336\u0003p8\u0000\u0335\u0333\u0001\u0000\u0000\u0000\u0336\u0339\u0001"+
|
|
"\u0000\u0000\u0000\u0337\u0335\u0001\u0000\u0000\u0000\u0337\u0338\u0001"+
|
|
"\u0000\u0000\u0000\u0338o\u0001\u0000\u0000\u0000\u0339\u0337\u0001\u0000"+
|
|
"\u0000\u0000\u033a\u033c\u0003\f\u0006\u0000\u033b\u033a\u0001\u0000\u0000"+
|
|
"\u0000\u033c\u033f\u0001\u0000\u0000\u0000\u033d\u033b\u0001\u0000\u0000"+
|
|
"\u0000\u033d\u033e\u0001\u0000\u0000\u0000\u033e\u0340\u0001\u0000\u0000"+
|
|
"\u0000\u033f\u033d\u0001\u0000\u0000\u0000\u0340\u0341\u0005=\u0000\u0000"+
|
|
"\u0341\u0342\u0003\u00aeW\u0000\u0342q\u0001\u0000\u0000\u0000\u0343\u0348"+
|
|
"\u0003\u00aeW\u0000\u0344\u0345\u0005V\u0000\u0000\u0345\u0347\u0003\u00ae"+
|
|
"W\u0000\u0346\u0344\u0001\u0000\u0000\u0000\u0347\u034a\u0001\u0000\u0000"+
|
|
"\u0000\u0348\u0346\u0001\u0000\u0000\u0000\u0348\u0349\u0001\u0000\u0000"+
|
|
"\u0000\u0349s\u0001\u0000\u0000\u0000\u034a\u0348\u0001\u0000\u0000\u0000"+
|
|
"\u034b\u0353\u0003v;\u0000\u034c\u0353\u0003x<\u0000\u034d\u0353\u0005"+
|
|
"J\u0000\u0000\u034e\u0353\u0005K\u0000\u0000\u034f\u0353\u0005I\u0000"+
|
|
"\u0000\u0350\u0353\u0005M\u0000\u0000\u0351\u0353\u0005L\u0000\u0000\u0352"+
|
|
"\u034b\u0001\u0000\u0000\u0000\u0352\u034c\u0001\u0000\u0000\u0000\u0352"+
|
|
"\u034d\u0001\u0000\u0000\u0000\u0352\u034e\u0001\u0000\u0000\u0000\u0352"+
|
|
"\u034f\u0001\u0000\u0000\u0000\u0352\u0350\u0001\u0000\u0000\u0000\u0352"+
|
|
"\u0351\u0001\u0000\u0000\u0000\u0353u\u0001\u0000\u0000\u0000\u0354\u0355"+
|
|
"\u0007\u0001\u0000\u0000\u0355w\u0001\u0000\u0000\u0000\u0356\u0357\u0007"+
|
|
"\u0002\u0000\u0000\u0357y\u0001\u0000\u0000\u0000\u0358\u0359\u0003\u00ae"+
|
|
"W\u0000\u0359\u035a\u0005V\u0000\u0000\u035a\u035c\u0001\u0000\u0000\u0000"+
|
|
"\u035b\u0358\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\u0005{\u0000\u0000\u0361\u0362\u0003\u00aeW\u0000\u0362{"+
|
|
"\u0001\u0000\u0000\u0000\u0363\u0364\u0005{\u0000\u0000\u0364\u0367\u0003"+
|
|
"r9\u0000\u0365\u0367\u0003z=\u0000\u0366\u0363\u0001\u0000\u0000\u0000"+
|
|
"\u0366\u0365\u0001\u0000\u0000\u0000\u0367\u036e\u0001\u0000\u0000\u0000"+
|
|
"\u0368\u036b\u0005N\u0000\u0000\u0369\u036c\u0003~?\u0000\u036a\u036c"+
|
|
"\u0003\u0082A\u0000\u036b\u0369\u0001\u0000\u0000\u0000\u036b\u036a\u0001"+
|
|
"\u0000\u0000\u0000\u036b\u036c\u0001\u0000\u0000\u0000\u036c\u036d\u0001"+
|
|
"\u0000\u0000\u0000\u036d\u036f\u0005O\u0000\u0000\u036e\u0368\u0001\u0000"+
|
|
"\u0000\u0000\u036e\u036f\u0001\u0000\u0000\u0000\u036f}\u0001\u0000\u0000"+
|
|
"\u0000\u0370\u0375\u0003\u0080@\u0000\u0371\u0372\u0005U\u0000\u0000\u0372"+
|
|
"\u0374\u0003\u0080@\u0000\u0373\u0371\u0001\u0000\u0000\u0000\u0374\u0377"+
|
|
"\u0001\u0000\u0000\u0000\u0375\u0373\u0001\u0000\u0000\u0000\u0375\u0376"+
|
|
"\u0001\u0000\u0000\u0000\u0376\u007f\u0001\u0000\u0000\u0000\u0377\u0375"+
|
|
"\u0001\u0000\u0000\u0000\u0378\u0379\u0003\u00aeW\u0000\u0379\u037a\u0005"+
|
|
"W\u0000\u0000\u037a\u037b\u0003\u0082A\u0000\u037b\u0081\u0001\u0000\u0000"+
|
|
"\u0000\u037c\u0380\u0003\u00d2i\u0000\u037d\u0380\u0003|>\u0000\u037e"+
|
|
"\u0380\u0003\u0084B\u0000\u037f\u037c\u0001\u0000\u0000\u0000\u037f\u037d"+
|
|
"\u0001\u0000\u0000\u0000\u037f\u037e\u0001\u0000\u0000\u0000\u0380\u0083"+
|
|
"\u0001\u0000\u0000\u0000\u0381\u038a\u0005P\u0000\u0000\u0382\u0387\u0003"+
|
|
"\u0082A\u0000\u0383\u0384\u0005U\u0000\u0000\u0384\u0386\u0003\u0082A"+
|
|
"\u0000\u0385\u0383\u0001\u0000\u0000\u0000\u0386\u0389\u0001\u0000\u0000"+
|
|
"\u0000\u0387\u0385\u0001\u0000\u0000\u0000\u0387\u0388\u0001\u0000\u0000"+
|
|
"\u0000\u0388\u038b\u0001\u0000\u0000\u0000\u0389\u0387\u0001\u0000\u0000"+
|
|
"\u0000\u038a\u0382\u0001\u0000\u0000\u0000\u038a\u038b\u0001\u0000\u0000"+
|
|
"\u0000\u038b\u038d\u0001\u0000\u0000\u0000\u038c\u038e\u0005U\u0000\u0000"+
|
|
"\u038d\u038c\u0001\u0000\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000"+
|
|
"\u038e\u038f\u0001\u0000\u0000\u0000\u038f\u0390\u0005Q\u0000\u0000\u0390"+
|
|
"\u0085\u0001\u0000\u0000\u0000\u0391\u0392\u0005{\u0000\u0000\u0392\u0393"+
|
|
"\u0005\u001c\u0000\u0000\u0393\u0394\u0003\u00aeW\u0000\u0394\u0395\u0003"+
|
|
"\u0088D\u0000\u0395\u0087\u0001\u0000\u0000\u0000\u0396\u039a\u0005P\u0000"+
|
|
"\u0000\u0397\u0399\u0003\u008aE\u0000\u0398\u0397\u0001\u0000\u0000\u0000"+
|
|
"\u0399\u039c\u0001\u0000\u0000\u0000\u039a\u0398\u0001\u0000\u0000\u0000"+
|
|
"\u039a\u039b\u0001\u0000\u0000\u0000\u039b\u039d\u0001\u0000\u0000\u0000"+
|
|
"\u039c\u039a\u0001\u0000\u0000\u0000\u039d\u039e\u0005Q\u0000\u0000\u039e"+
|
|
"\u0089\u0001\u0000\u0000\u0000\u039f\u03a1\u0003\b\u0004\u0000\u03a0\u039f"+
|
|
"\u0001\u0000\u0000\u0000\u03a1\u03a4\u0001\u0000\u0000\u0000\u03a2\u03a0"+
|
|
"\u0001\u0000\u0000\u0000\u03a2\u03a3\u0001\u0000\u0000\u0000\u03a3\u03a5"+
|
|
"\u0001\u0000\u0000\u0000\u03a4\u03a2\u0001\u0000\u0000\u0000\u03a5\u03a8"+
|
|
"\u0003\u008cF\u0000\u03a6\u03a8\u0005T\u0000\u0000\u03a7\u03a2\u0001\u0000"+
|
|
"\u0000\u0000\u03a7\u03a6\u0001\u0000\u0000\u0000\u03a8\u008b\u0001\u0000"+
|
|
"\u0000\u0000\u03a9\u03aa\u0003\u010a\u0085\u0000\u03aa\u03ab\u0003\u008e"+
|
|
"G\u0000\u03ab\u03ac\u0005T\u0000\u0000\u03ac\u03b2\u0001\u0000\u0000\u0000"+
|
|
"\u03ad\u03af\u0003\u0006\u0003\u0000\u03ae\u03b0\u0005T\u0000\u0000\u03af"+
|
|
"\u03ae\u0001\u0000\u0000\u0000\u03af\u03b0\u0001\u0000\u0000\u0000\u03b0"+
|
|
"\u03b2\u0001\u0000\u0000\u0000\u03b1\u03a9\u0001\u0000\u0000\u0000\u03b1"+
|
|
"\u03ad\u0001\u0000\u0000\u0000\u03b2\u008d\u0001\u0000\u0000\u0000\u03b3"+
|
|
"\u03b6\u0003\u0090H\u0000\u03b4\u03b6\u0003\u0092I\u0000\u03b5\u03b3\u0001"+
|
|
"\u0000\u0000\u0000\u03b5\u03b4\u0001\u0000\u0000\u0000\u03b6\u008f\u0001"+
|
|
"\u0000\u0000\u0000\u03b7\u03b8\u0003\u00aeW\u0000\u03b8\u03b9\u0005N\u0000"+
|
|
"\u0000\u03b9\u03bb\u0005O\u0000\u0000\u03ba\u03bc\u0003\u0094J\u0000\u03bb"+
|
|
"\u03ba\u0001\u0000\u0000\u0000\u03bb\u03bc\u0001\u0000\u0000\u0000\u03bc"+
|
|
"\u0091\u0001\u0000\u0000\u0000\u03bd\u03be\u0003L&\u0000\u03be\u0093\u0001"+
|
|
"\u0000\u0000\u0000\u03bf\u03c0\u0005\f\u0000\u0000\u03c0\u03c1\u0003\u0082"+
|
|
"A\u0000\u03c1\u0095\u0001\u0000\u0000\u0000\u03c2\u03c4\u00054\u0000\u0000"+
|
|
"\u03c3\u03c2\u0001\u0000\u0000\u0000\u03c3\u03c4\u0001\u0000\u0000\u0000"+
|
|
"\u03c4\u03c5\u0001\u0000\u0000\u0000\u03c5\u03c6\u00053\u0000\u0000\u03c6"+
|
|
"\u03c7\u0003r9\u0000\u03c7\u03c8\u0003\u0098L\u0000\u03c8\u0097\u0001"+
|
|
"\u0000\u0000\u0000\u03c9\u03cd\u0005P\u0000\u0000\u03ca\u03cc\u0003\u009a"+
|
|
"M\u0000\u03cb\u03ca\u0001\u0000\u0000\u0000\u03cc\u03cf\u0001\u0000\u0000"+
|
|
"\u0000\u03cd\u03cb\u0001\u0000\u0000\u0000\u03cd\u03ce\u0001\u0000\u0000"+
|
|
"\u0000\u03ce\u03d0\u0001\u0000\u0000\u0000\u03cf\u03cd\u0001\u0000\u0000"+
|
|
"\u0000\u03d0\u03d1\u0005Q\u0000\u0000\u03d1\u0099\u0001\u0000\u0000\u0000"+
|
|
"\u03d2\u03d6\u00055\u0000\u0000\u03d3\u03d5\u0003\u009cN\u0000\u03d4\u03d3"+
|
|
"\u0001\u0000\u0000\u0000\u03d5\u03d8\u0001\u0000\u0000\u0000\u03d6\u03d4"+
|
|
"\u0001\u0000\u0000\u0000\u03d6\u03d7\u0001\u0000\u0000\u0000\u03d7\u03d9"+
|
|
"\u0001\u0000\u0000\u0000\u03d8\u03d6\u0001\u0000\u0000\u0000\u03d9\u03da"+
|
|
"\u0003r9\u0000\u03da\u03db\u0005T\u0000\u0000\u03db\u03f7\u0001\u0000"+
|
|
"\u0000\u0000\u03dc\u03dd\u00056\u0000\u0000\u03dd\u03e0\u0003r9\u0000"+
|
|
"\u03de\u03df\u00058\u0000\u0000\u03df\u03e1\u0003r9\u0000\u03e0\u03de"+
|
|
"\u0001\u0000\u0000\u0000\u03e0\u03e1\u0001\u0000\u0000\u0000\u03e1\u03e2"+
|
|
"\u0001\u0000\u0000\u0000\u03e2\u03e3\u0005T\u0000\u0000\u03e3\u03f7\u0001"+
|
|
"\u0000\u0000\u0000\u03e4\u03e5\u00057\u0000\u0000\u03e5\u03e8\u0003r9"+
|
|
"\u0000\u03e6\u03e7\u00058\u0000\u0000\u03e7\u03e9\u0003r9\u0000\u03e8"+
|
|
"\u03e6\u0001\u0000\u0000\u0000\u03e8\u03e9\u0001\u0000\u0000\u0000\u03e9"+
|
|
"\u03ea\u0001\u0000\u0000\u0000\u03ea\u03eb\u0005T\u0000\u0000\u03eb\u03f7"+
|
|
"\u0001\u0000\u0000\u0000\u03ec\u03ed\u00059\u0000\u0000\u03ed\u03ee\u0003"+
|
|
"r9\u0000\u03ee\u03ef\u0005T\u0000\u0000\u03ef\u03f7\u0001\u0000\u0000"+
|
|
"\u0000\u03f0\u03f1\u0005:\u0000\u0000\u03f1\u03f2\u0003r9\u0000\u03f2"+
|
|
"\u03f3\u0005;\u0000\u0000\u03f3\u03f4\u0003r9\u0000\u03f4\u03f5\u0005"+
|
|
"T\u0000\u0000\u03f5\u03f7\u0001\u0000\u0000\u0000\u03f6\u03d2\u0001\u0000"+
|
|
"\u0000\u0000\u03f6\u03dc\u0001\u0000\u0000\u0000\u03f6\u03e4\u0001\u0000"+
|
|
"\u0000\u0000\u03f6\u03ec\u0001\u0000\u0000\u0000\u03f6\u03f0\u0001\u0000"+
|
|
"\u0000\u0000\u03f7\u009b\u0001\u0000\u0000\u0000\u03f8\u03f9\u0007\u0003"+
|
|
"\u0000\u0000\u03f9\u009d\u0001\u0000\u0000\u0000\u03fa\u03fb\u0005?\u0000"+
|
|
"\u0000\u03fb\u03fd\u0003\u00aeW\u0000\u03fc\u03fe\u0003\u0010\b\u0000"+
|
|
"\u03fd\u03fc\u0001\u0000\u0000\u0000\u03fd\u03fe\u0001\u0000\u0000\u0000"+
|
|
"\u03fe\u03ff\u0001\u0000\u0000\u0000\u03ff\u0402\u0003\u00a0P\u0000\u0400"+
|
|
"\u0401\u0005\u0018\u0000\u0000\u0401\u0403\u0003\u0108\u0084\u0000\u0402"+
|
|
"\u0400\u0001\u0000\u0000\u0000\u0402\u0403\u0001\u0000\u0000\u0000\u0403"+
|
|
"\u0404\u0001\u0000\u0000\u0000\u0404\u0405\u0003\u00a6S\u0000\u0405\u009f"+
|
|
"\u0001\u0000\u0000\u0000\u0406\u0408\u0005N\u0000\u0000\u0407\u0409\u0003"+
|
|
"\u00a2Q\u0000\u0408\u0407\u0001\u0000\u0000\u0000\u0408\u0409\u0001\u0000"+
|
|
"\u0000\u0000\u0409\u040a\u0001\u0000\u0000\u0000\u040a\u040b\u0005O\u0000"+
|
|
"\u0000\u040b\u00a1\u0001\u0000\u0000\u0000\u040c\u0411\u0003\u00a4R\u0000"+
|
|
"\u040d\u040e\u0005U\u0000\u0000\u040e\u0410\u0003\u00a4R\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\u00a3"+
|
|
"\u0001\u0000\u0000\u0000\u0413\u0411\u0001\u0000\u0000\u0000\u0414\u0416"+
|
|
"\u0003\u010a\u0085\u0000\u0415\u0414\u0001\u0000\u0000\u0000\u0415\u0416"+
|
|
"\u0001\u0000\u0000\u0000\u0416\u0417\u0001\u0000\u0000\u0000\u0417\u0418"+
|
|
"\u0003\u00aeW\u0000\u0418\u00a5\u0001\u0000\u0000\u0000\u0419\u041d\u0005"+
|
|
"P\u0000\u0000\u041a\u041c\u0003$\u0012\u0000\u041b\u041a\u0001\u0000\u0000"+
|
|
"\u0000\u041c\u041f\u0001\u0000\u0000\u0000\u041d\u041b\u0001\u0000\u0000"+
|
|
"\u0000\u041d\u041e\u0001\u0000\u0000\u0000\u041e\u0420\u0001\u0000\u0000"+
|
|
"\u0000\u041f\u041d\u0001\u0000\u0000\u0000\u0420\u0421\u0005Q\u0000\u0000"+
|
|
"\u0421\u00a7\u0001\u0000\u0000\u0000\u0422\u0426\u0005P\u0000\u0000\u0423"+
|
|
"\u0425\u0003\u00aaU\u0000\u0424\u0423\u0001\u0000\u0000\u0000\u0425\u0428"+
|
|
"\u0001\u0000\u0000\u0000\u0426\u0424\u0001\u0000\u0000\u0000\u0426\u0427"+
|
|
"\u0001\u0000\u0000\u0000\u0427\u0429\u0001\u0000\u0000\u0000\u0428\u0426"+
|
|
"\u0001\u0000\u0000\u0000\u0429\u042a\u0005Q\u0000\u0000\u042a\u00a9\u0001"+
|
|
"\u0000\u0000\u0000\u042b\u042c\u0003\u00acV\u0000\u042c\u042d\u0005T\u0000"+
|
|
"\u0000\u042d\u0431\u0001\u0000\u0000\u0000\u042e\u0431\u0003\u00b2Y\u0000"+
|
|
"\u042f\u0431\u0003\u00b4Z\u0000\u0430\u042b\u0001\u0000\u0000\u0000\u0430"+
|
|
"\u042e\u0001\u0000\u0000\u0000\u0430\u042f\u0001\u0000\u0000\u0000\u0431"+
|
|
"\u00ab\u0001\u0000\u0000\u0000\u0432\u0434\u0003\f\u0006\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\u043a"+
|
|
"\u0001\u0000\u0000\u0000\u0437\u0435\u0001\u0000\u0000\u0000\u0438\u043b"+
|
|
"\u0005=\u0000\u0000\u0439\u043b\u0003\u010a\u0085\u0000\u043a\u0438\u0001"+
|
|
"\u0000\u0000\u0000\u043a\u0439\u0001\u0000\u0000\u0000\u043b\u043c\u0001"+
|
|
"\u0000\u0000\u0000\u043c\u043d\u0003L&\u0000\u043d\u00ad\u0001\u0000\u0000"+
|
|
"\u0000\u043e\u043f\u0007\u0004\u0000\u0000\u043f\u00af\u0001\u0000\u0000"+
|
|
"\u0000\u0440\u0441\u0007\u0005\u0000\u0000\u0441\u00b1\u0001\u0000\u0000"+
|
|
"\u0000\u0442\u0444\u0003\n\u0005\u0000\u0443\u0442\u0001\u0000\u0000\u0000"+
|
|
"\u0444\u0447\u0001\u0000\u0000\u0000\u0445\u0443\u0001\u0000\u0000\u0000"+
|
|
"\u0445\u0446\u0001\u0000\u0000\u0000\u0446\u044b\u0001\u0000\u0000\u0000"+
|
|
"\u0447\u0445\u0001\u0000\u0000\u0000\u0448\u044c\u0003\u000e\u0007\u0000"+
|
|
"\u0449\u044c\u0003\u001e\u000f\u0000\u044a\u044c\u0003\u009eO\u0000\u044b"+
|
|
"\u0448\u0001\u0000\u0000\u0000\u044b\u0449\u0001\u0000\u0000\u0000\u044b"+
|
|
"\u044a\u0001\u0000\u0000\u0000\u044c\u044f\u0001\u0000\u0000\u0000\u044d"+
|
|
"\u044f\u0005T\u0000\u0000\u044e\u0445\u0001\u0000\u0000\u0000\u044e\u044d"+
|
|
"\u0001\u0000\u0000\u0000\u044f\u00b3\u0001\u0000\u0000\u0000\u0450\u04be"+
|
|
"\u0003\u00a8T\u0000\u0451\u0452\u0005\u0002\u0000\u0000\u0452\u0455\u0003"+
|
|
"\u00d2i\u0000\u0453\u0454\u0005]\u0000\u0000\u0454\u0456\u0003\u00d2i"+
|
|
"\u0000\u0455\u0453\u0001\u0000\u0000\u0000\u0455\u0456\u0001\u0000\u0000"+
|
|
"\u0000\u0456\u0457\u0001\u0000\u0000\u0000\u0457\u0458\u0005T\u0000\u0000"+
|
|
"\u0458\u04be\u0001\u0000\u0000\u0000\u0459\u045a\u0005\u0016\u0000\u0000"+
|
|
"\u045a\u045b\u0003\u00ccf\u0000\u045b\u045e\u0003\u00b4Z\u0000\u045c\u045d"+
|
|
"\u0005\u000f\u0000\u0000\u045d\u045f\u0003\u00b4Z\u0000\u045e\u045c\u0001"+
|
|
"\u0000\u0000\u0000\u045e\u045f\u0001\u0000\u0000\u0000\u045f\u04be\u0001"+
|
|
"\u0000\u0000\u0000\u0460\u0461\u0005\u0015\u0000\u0000\u0461\u0462\u0005"+
|
|
"N\u0000\u0000\u0462\u0463\u0003\u00c6c\u0000\u0463\u0464\u0005O\u0000"+
|
|
"\u0000\u0464\u0465\u0003\u00b4Z\u0000\u0465\u04be\u0001\u0000\u0000\u0000"+
|
|
"\u0466\u0467\u00052\u0000\u0000\u0467\u0468\u0003\u00ccf\u0000\u0468\u0469"+
|
|
"\u0003\u00b4Z\u0000\u0469\u04be\u0001\u0000\u0000\u0000\u046a\u046b\u0005"+
|
|
"\r\u0000\u0000\u046b\u046c\u0003\u00b4Z\u0000\u046c\u046d\u00052\u0000"+
|
|
"\u0000\u046d\u046e\u0003\u00ccf\u0000\u046e\u046f\u0005T\u0000\u0000\u046f"+
|
|
"\u04be\u0001\u0000\u0000\u0000\u0470\u0471\u0005/\u0000\u0000\u0471\u047b"+
|
|
"\u0003\u00a8T\u0000\u0472\u0474\u0003\u00b6[\u0000\u0473\u0472\u0001\u0000"+
|
|
"\u0000\u0000\u0474\u0475\u0001\u0000\u0000\u0000\u0475\u0473\u0001\u0000"+
|
|
"\u0000\u0000\u0475\u0476\u0001\u0000\u0000\u0000\u0476\u0478\u0001\u0000"+
|
|
"\u0000\u0000\u0477\u0479\u0003\u00ba]\u0000\u0478\u0477\u0001\u0000\u0000"+
|
|
"\u0000\u0478\u0479\u0001\u0000\u0000\u0000\u0479\u047c\u0001\u0000\u0000"+
|
|
"\u0000\u047a\u047c\u0003\u00ba]\u0000\u047b\u0473\u0001\u0000\u0000\u0000"+
|
|
"\u047b\u047a\u0001\u0000\u0000\u0000\u047c\u04be\u0001\u0000\u0000\u0000"+
|
|
"\u047d\u047e\u0005/\u0000\u0000\u047e\u047f\u0003\u00bc^\u0000\u047f\u0483"+
|
|
"\u0003\u00a8T\u0000\u0480\u0482\u0003\u00b6[\u0000\u0481\u0480\u0001\u0000"+
|
|
"\u0000\u0000\u0482\u0485\u0001\u0000\u0000\u0000\u0483\u0481\u0001\u0000"+
|
|
"\u0000\u0000\u0483\u0484\u0001\u0000\u0000\u0000\u0484\u0487\u0001\u0000"+
|
|
"\u0000\u0000\u0485\u0483\u0001\u0000\u0000\u0000\u0486\u0488\u0003\u00ba"+
|
|
"]\u0000\u0487\u0486\u0001\u0000\u0000\u0000\u0487\u0488\u0001\u0000\u0000"+
|
|
"\u0000\u0488\u04be\u0001\u0000\u0000\u0000\u0489\u048a\u0005)\u0000\u0000"+
|
|
"\u048a\u048b\u0003\u00ccf\u0000\u048b\u048f\u0005P\u0000\u0000\u048c\u048e"+
|
|
"\u0003\u00c2a\u0000\u048d\u048c\u0001\u0000\u0000\u0000\u048e\u0491\u0001"+
|
|
"\u0000\u0000\u0000\u048f\u048d\u0001\u0000\u0000\u0000\u048f\u0490\u0001"+
|
|
"\u0000\u0000\u0000\u0490\u0495\u0001\u0000\u0000\u0000\u0491\u048f\u0001"+
|
|
"\u0000\u0000\u0000\u0492\u0494\u0003\u00c4b\u0000\u0493\u0492\u0001\u0000"+
|
|
"\u0000\u0000\u0494\u0497\u0001\u0000\u0000\u0000\u0495\u0493\u0001\u0000"+
|
|
"\u0000\u0000\u0495\u0496\u0001\u0000\u0000\u0000\u0496\u0498\u0001\u0000"+
|
|
"\u0000\u0000\u0497\u0495\u0001\u0000\u0000\u0000\u0498\u0499\u0005Q\u0000"+
|
|
"\u0000\u0499\u04be\u0001\u0000\u0000\u0000\u049a\u049b\u0005*\u0000\u0000"+
|
|
"\u049b\u049c\u0003\u00ccf\u0000\u049c\u049d\u0003\u00a8T\u0000\u049d\u04be"+
|
|
"\u0001\u0000\u0000\u0000\u049e\u04a0\u0005$\u0000\u0000\u049f\u04a1\u0003"+
|
|
"\u00d2i\u0000\u04a0\u049f\u0001\u0000\u0000\u0000\u04a0\u04a1\u0001\u0000"+
|
|
"\u0000\u0000\u04a1\u04a2\u0001\u0000\u0000\u0000\u04a2\u04be\u0005T\u0000"+
|
|
"\u0000\u04a3\u04a4\u0005,\u0000\u0000\u04a4\u04a5\u0003\u00d2i\u0000\u04a5"+
|
|
"\u04a6\u0005T\u0000\u0000\u04a6\u04be\u0001\u0000\u0000\u0000\u04a7\u04a9"+
|
|
"\u0005\u0004\u0000\u0000\u04a8\u04aa\u0003\u00aeW\u0000\u04a9\u04a8\u0001"+
|
|
"\u0000\u0000\u0000\u04a9\u04aa\u0001\u0000\u0000\u0000\u04aa\u04ab\u0001"+
|
|
"\u0000\u0000\u0000\u04ab\u04be\u0005T\u0000\u0000\u04ac\u04ae\u0005\u000b"+
|
|
"\u0000\u0000\u04ad\u04af\u0003\u00aeW\u0000\u04ae\u04ad\u0001\u0000\u0000"+
|
|
"\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af\u04b0\u0001\u0000\u0000"+
|
|
"\u0000\u04b0\u04be\u0005T\u0000\u0000\u04b1\u04b2\u0005>\u0000\u0000\u04b2"+
|
|
"\u04b3\u0003\u00d2i\u0000\u04b3\u04b4\u0005T\u0000\u0000\u04b4\u04be\u0001"+
|
|
"\u0000\u0000\u0000\u04b5\u04be\u0005T\u0000\u0000\u04b6\u04b7\u0003\u00d2"+
|
|
"i\u0000\u04b7\u04b8\u0005T\u0000\u0000\u04b8\u04be\u0001\u0000\u0000\u0000"+
|
|
"\u04b9\u04ba\u0003\u00aeW\u0000\u04ba\u04bb\u0005]\u0000\u0000\u04bb\u04bc"+
|
|
"\u0003\u00b4Z\u0000\u04bc\u04be\u0001\u0000\u0000\u0000\u04bd\u0450\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u0451\u0001\u0000\u0000\u0000\u04bd\u0459\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u0460\u0001\u0000\u0000\u0000\u04bd\u0466\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u046a\u0001\u0000\u0000\u0000\u04bd\u0470\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u047d\u0001\u0000\u0000\u0000\u04bd\u0489\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u049a\u0001\u0000\u0000\u0000\u04bd\u049e\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u04a3\u0001\u0000\u0000\u0000\u04bd\u04a7\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u04ac\u0001\u0000\u0000\u0000\u04bd\u04b1\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u04b5\u0001\u0000\u0000\u0000\u04bd\u04b6\u0001"+
|
|
"\u0000\u0000\u0000\u04bd\u04b9\u0001\u0000\u0000\u0000\u04be\u00b5\u0001"+
|
|
"\u0000\u0000\u0000\u04bf\u04c0\u0005\u0007\u0000\u0000\u04c0\u04c4\u0005"+
|
|
"N\u0000\u0000\u04c1\u04c3\u0003\f\u0006\u0000\u04c2\u04c1\u0001\u0000"+
|
|
"\u0000\u0000\u04c3\u04c6\u0001\u0000\u0000\u0000\u04c4\u04c2\u0001\u0000"+
|
|
"\u0000\u0000\u04c4\u04c5\u0001\u0000\u0000\u0000\u04c5\u04c8\u0001\u0000"+
|
|
"\u0000\u0000\u04c6\u04c4\u0001\u0000\u0000\u0000\u04c7\u04c9\u0003\u00b8"+
|
|
"\\\u0000\u04c8\u04c7\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000"+
|
|
"\u0000\u04c9\u04ca\u0001\u0000\u0000\u0000\u04ca\u04cb\u0003\u00aeW\u0000"+
|
|
"\u04cb\u04cc\u0005O\u0000\u0000\u04cc\u04cd\u0003\u00a8T\u0000\u04cd\u00b7"+
|
|
"\u0001\u0000\u0000\u0000\u04ce\u04d3\u0003r9\u0000\u04cf\u04d0\u0005k"+
|
|
"\u0000\u0000\u04d0\u04d2\u0003r9\u0000\u04d1\u04cf\u0001\u0000\u0000\u0000"+
|
|
"\u04d2\u04d5\u0001\u0000\u0000\u0000\u04d3\u04d1\u0001\u0000\u0000\u0000"+
|
|
"\u04d3\u04d4\u0001\u0000\u0000\u0000\u04d4\u00b9\u0001\u0000\u0000\u0000"+
|
|
"\u04d5\u04d3\u0001\u0000\u0000\u0000\u04d6\u04d7\u0005\u0013\u0000\u0000"+
|
|
"\u04d7\u04d8\u0003\u00a8T\u0000\u04d8\u00bb\u0001\u0000\u0000\u0000\u04d9"+
|
|
"\u04da\u0005N\u0000\u0000\u04da\u04dc\u0003\u00be_\u0000\u04db\u04dd\u0005"+
|
|
"T\u0000\u0000\u04dc\u04db\u0001\u0000\u0000\u0000\u04dc\u04dd\u0001\u0000"+
|
|
"\u0000\u0000\u04dd\u04de\u0001\u0000\u0000\u0000\u04de\u04df\u0005O\u0000"+
|
|
"\u0000\u04df\u00bd\u0001\u0000\u0000\u0000\u04e0\u04e5\u0003\u00c0`\u0000"+
|
|
"\u04e1\u04e2\u0005T\u0000\u0000\u04e2\u04e4\u0003\u00c0`\u0000\u04e3\u04e1"+
|
|
"\u0001\u0000\u0000\u0000\u04e4\u04e7\u0001\u0000\u0000\u0000\u04e5\u04e3"+
|
|
"\u0001\u0000\u0000\u0000\u04e5\u04e6\u0001\u0000\u0000\u0000\u04e6\u00bf"+
|
|
"\u0001\u0000\u0000\u0000\u04e7\u04e5\u0001\u0000\u0000\u0000\u04e8\u04ea"+
|
|
"\u0003\f\u0006\u0000\u04e9\u04e8\u0001\u0000\u0000\u0000\u04ea\u04ed\u0001"+
|
|
"\u0000\u0000\u0000\u04eb\u04e9\u0001\u0000\u0000\u0000\u04eb\u04ec\u0001"+
|
|
"\u0000\u0000\u0000\u04ec\u04f4\u0001\u0000\u0000\u0000\u04ed\u04eb\u0001"+
|
|
"\u0000\u0000\u0000\u04ee\u04f0\u0003V+\u0000\u04ef\u04ee\u0001\u0000\u0000"+
|
|
"\u0000\u04ef\u04f0\u0001\u0000\u0000\u0000\u04f0\u04f1\u0001\u0000\u0000"+
|
|
"\u0000\u04f1\u04f5\u0003P(\u0000\u04f2\u04f3\u0005=\u0000\u0000\u04f3"+
|
|
"\u04f5\u0003\u00aeW\u0000\u04f4\u04ef\u0001\u0000\u0000\u0000\u04f4\u04f2"+
|
|
"\u0001\u0000\u0000\u0000\u04f5\u04f6\u0001\u0000\u0000\u0000\u04f6\u04f7"+
|
|
"\u0005W\u0000\u0000\u04f7\u04f8\u0003\u00d2i\u0000\u04f8\u04fb\u0001\u0000"+
|
|
"\u0000\u0000\u04f9\u04fb\u0003\u00aeW\u0000\u04fa\u04eb\u0001\u0000\u0000"+
|
|
"\u0000\u04fa\u04f9\u0001\u0000\u0000\u0000\u04fb\u00c1\u0001\u0000\u0000"+
|
|
"\u0000\u04fc\u04fe\u0003\u00c4b\u0000\u04fd\u04fc\u0001\u0000\u0000\u0000"+
|
|
"\u04fe\u04ff\u0001\u0000\u0000\u0000\u04ff\u04fd\u0001\u0000\u0000\u0000"+
|
|
"\u04ff\u0500\u0001\u0000\u0000\u0000\u0500\u0502\u0001\u0000\u0000\u0000"+
|
|
"\u0501\u0503\u0003\u00aaU\u0000\u0502\u0501\u0001\u0000\u0000\u0000\u0503"+
|
|
"\u0504\u0001\u0000\u0000\u0000\u0504\u0502\u0001\u0000\u0000\u0000\u0504"+
|
|
"\u0505\u0001\u0000\u0000\u0000\u0505\u00c3\u0001\u0000\u0000\u0000\u0506"+
|
|
"\u0507\u0005\u0006\u0000\u0000\u0507\u0508\u0003\u00d2i\u0000\u0508\u0509"+
|
|
"\u0005]\u0000\u0000\u0509\u0514\u0001\u0000\u0000\u0000\u050a\u050b\u0005"+
|
|
"\u0006\u0000\u0000\u050b\u050c\u0005\u0080\u0000\u0000\u050c\u0514\u0005"+
|
|
"]\u0000\u0000\u050d\u050e\u0005\u0006\u0000\u0000\u050e\u050f\u0003\u00d4"+
|
|
"j\u0000\u050f\u0510\u0005]\u0000\u0000\u0510\u0514\u0001\u0000\u0000\u0000"+
|
|
"\u0511\u0512\u0005\f\u0000\u0000\u0512\u0514\u0005]\u0000\u0000\u0513"+
|
|
"\u0506\u0001\u0000\u0000\u0000\u0513\u050a\u0001\u0000\u0000\u0000\u0513"+
|
|
"\u050d\u0001\u0000\u0000\u0000\u0513\u0511\u0001\u0000\u0000\u0000\u0514"+
|
|
"\u00c5\u0001\u0000\u0000\u0000\u0515\u0522\u0003\u00cae\u0000\u0516\u0518"+
|
|
"\u0003\u00c8d\u0000\u0517\u0516\u0001\u0000\u0000\u0000\u0517\u0518\u0001"+
|
|
"\u0000\u0000\u0000\u0518\u0519\u0001\u0000\u0000\u0000\u0519\u051b\u0005"+
|
|
"T\u0000\u0000\u051a\u051c\u0003\u00d2i\u0000\u051b\u051a\u0001\u0000\u0000"+
|
|
"\u0000\u051b\u051c\u0001\u0000\u0000\u0000\u051c\u051d\u0001\u0000\u0000"+
|
|
"\u0000\u051d\u051f\u0005T\u0000\u0000\u051e\u0520\u0003\u00ceg\u0000\u051f"+
|
|
"\u051e\u0001\u0000\u0000\u0000\u051f\u0520\u0001\u0000\u0000\u0000\u0520"+
|
|
"\u0522\u0001\u0000\u0000\u0000\u0521\u0515\u0001\u0000\u0000\u0000\u0521"+
|
|
"\u0517\u0001\u0000\u0000\u0000\u0522\u00c7\u0001\u0000\u0000\u0000\u0523"+
|
|
"\u0526\u0003\u00acV\u0000\u0524\u0526\u0003\u00ceg\u0000\u0525\u0523\u0001"+
|
|
"\u0000\u0000\u0000\u0525\u0524\u0001\u0000\u0000\u0000\u0526\u00c9\u0001"+
|
|
"\u0000\u0000\u0000\u0527\u0529\u0003\f\u0006\u0000\u0528\u0527\u0001\u0000"+
|
|
"\u0000\u0000\u0529\u052c\u0001\u0000\u0000\u0000\u052a\u0528\u0001\u0000"+
|
|
"\u0000\u0000\u052a\u052b\u0001\u0000\u0000\u0000\u052b\u0531\u0001\u0000"+
|
|
"\u0000\u0000\u052c\u052a\u0001\u0000\u0000\u0000\u052d\u052f\u0003\u010a"+
|
|
"\u0085\u0000\u052e\u052d\u0001\u0000\u0000\u0000\u052e\u052f\u0001\u0000"+
|
|
"\u0000\u0000\u052f\u0532\u0001\u0000\u0000\u0000\u0530\u0532\u0005=\u0000"+
|
|
"\u0000\u0531\u052e\u0001\u0000\u0000\u0000\u0531\u0530\u0001\u0000\u0000"+
|
|
"\u0000\u0532\u0533\u0001\u0000\u0000\u0000\u0533\u0534\u0003P(\u0000\u0534"+
|
|
"\u0535\u0005]\u0000\u0000\u0535\u0536\u0003\u00d2i\u0000\u0536\u00cb\u0001"+
|
|
"\u0000\u0000\u0000\u0537\u0538\u0005N\u0000\u0000\u0538\u0539\u0003\u00d2"+
|
|
"i\u0000\u0539\u053a\u0005O\u0000\u0000\u053a\u00cd\u0001\u0000\u0000\u0000"+
|
|
"\u053b\u0540\u0003\u00d2i\u0000\u053c\u053d\u0005U\u0000\u0000\u053d\u053f"+
|
|
"\u0003\u00d2i\u0000\u053e\u053c\u0001\u0000\u0000\u0000\u053f\u0542\u0001"+
|
|
"\u0000\u0000\u0000\u0540\u053e\u0001\u0000\u0000\u0000\u0540\u0541\u0001"+
|
|
"\u0000\u0000\u0000\u0541\u00cf\u0001\u0000\u0000\u0000\u0542\u0540\u0001"+
|
|
"\u0000\u0000\u0000\u0543\u0544\u0003\u00aeW\u0000\u0544\u0546\u0005N\u0000"+
|
|
"\u0000\u0545\u0547\u0003\u00ceg\u0000\u0546\u0545\u0001\u0000\u0000\u0000"+
|
|
"\u0546\u0547\u0001\u0000\u0000\u0000\u0547\u0548\u0001\u0000\u0000\u0000"+
|
|
"\u0548\u0549\u0005O\u0000\u0000\u0549\u0557\u0001\u0000\u0000\u0000\u054a"+
|
|
"\u054b\u0005+\u0000\u0000\u054b\u054d\u0005N\u0000\u0000\u054c\u054e\u0003"+
|
|
"\u00ceg\u0000\u054d\u054c\u0001\u0000\u0000\u0000\u054d\u054e\u0001\u0000"+
|
|
"\u0000\u0000\u054e\u054f\u0001\u0000\u0000\u0000\u054f\u0557\u0005O\u0000"+
|
|
"\u0000\u0550\u0551\u0005(\u0000\u0000\u0551\u0553\u0005N\u0000\u0000\u0552"+
|
|
"\u0554\u0003\u00ceg\u0000\u0553\u0552\u0001\u0000\u0000\u0000\u0553\u0554"+
|
|
"\u0001\u0000\u0000\u0000\u0554\u0555\u0001\u0000\u0000\u0000\u0555\u0557"+
|
|
"\u0005O\u0000\u0000\u0556\u0543\u0001\u0000\u0000\u0000\u0556\u054a\u0001"+
|
|
"\u0000\u0000\u0000\u0556\u0550\u0001\u0000\u0000\u0000\u0557\u00d1\u0001"+
|
|
"\u0000\u0000\u0000\u0558\u0559\u0006i\uffff\uffff\u0000\u0559\u0584\u0003"+
|
|
"\u00e8t\u0000\u055a\u0584\u0003\u00d0h\u0000\u055b\u055c\u0005\u001f\u0000"+
|
|
"\u0000\u055c\u0584\u0003\u00f6{\u0000\u055d\u0561\u0005N\u0000\u0000\u055e"+
|
|
"\u0560\u0003|>\u0000\u055f\u055e\u0001\u0000\u0000\u0000\u0560\u0563\u0001"+
|
|
"\u0000\u0000\u0000\u0561\u055f\u0001\u0000\u0000\u0000\u0561\u0562\u0001"+
|
|
"\u0000\u0000\u0000\u0562\u0564\u0001\u0000\u0000\u0000\u0563\u0561\u0001"+
|
|
"\u0000\u0000\u0000\u0564\u0569\u0003\u010a\u0085\u0000\u0565\u0566\u0005"+
|
|
"j\u0000\u0000\u0566\u0568\u0003\u010a\u0085\u0000\u0567\u0565\u0001\u0000"+
|
|
"\u0000\u0000\u0568\u056b\u0001\u0000\u0000\u0000\u0569\u0567\u0001\u0000"+
|
|
"\u0000\u0000\u0569\u056a\u0001\u0000\u0000\u0000\u056a\u056c\u0001\u0000"+
|
|
"\u0000\u0000\u056b\u0569\u0001\u0000\u0000\u0000\u056c\u056d\u0005O\u0000"+
|
|
"\u0000\u056d\u056e\u0003\u00d2i\u0015\u056e\u0584\u0001\u0000\u0000\u0000"+
|
|
"\u056f\u0570\u0007\u0006\u0000\u0000\u0570\u0584\u0003\u00d2i\u0013\u0571"+
|
|
"\u0584\u0003\u00e2q\u0000\u0572\u0584\u0003\u00eau\u0000\u0573\u0574\u0003"+
|
|
"\u010a\u0085\u0000\u0574\u057a\u0005z\u0000\u0000\u0575\u0577\u0003\u010e"+
|
|
"\u0087\u0000\u0576\u0575\u0001\u0000\u0000\u0000\u0576\u0577\u0001\u0000"+
|
|
"\u0000\u0000\u0577\u0578\u0001\u0000\u0000\u0000\u0578\u057b\u0003\u00ae"+
|
|
"W\u0000\u0579\u057b\u0005\u001f\u0000\u0000\u057a\u0576\u0001\u0000\u0000"+
|
|
"\u0000\u057a\u0579\u0001\u0000\u0000\u0000\u057b\u0584\u0001\u0000\u0000"+
|
|
"\u0000\u057c\u057d\u0003\u00f4z\u0000\u057d\u057f\u0005z\u0000\u0000\u057e"+
|
|
"\u0580\u0003\u010e\u0087\u0000\u057f\u057e\u0001\u0000\u0000\u0000\u057f"+
|
|
"\u0580\u0001\u0000\u0000\u0000\u0580\u0581\u0001\u0000\u0000\u0000\u0581"+
|
|
"\u0582\u0005\u001f\u0000\u0000\u0582\u0584\u0001\u0000\u0000\u0000\u0583"+
|
|
"\u0558\u0001\u0000\u0000\u0000\u0583\u055a\u0001\u0000\u0000\u0000\u0583"+
|
|
"\u055b\u0001\u0000\u0000\u0000\u0583\u055d\u0001\u0000\u0000\u0000\u0583"+
|
|
"\u056f\u0001\u0000\u0000\u0000\u0583\u0571\u0001\u0000\u0000\u0000\u0583"+
|
|
"\u0572\u0001\u0000\u0000\u0000\u0583\u0573\u0001\u0000\u0000\u0000\u0583"+
|
|
"\u057c\u0001\u0000\u0000\u0000\u0584\u05d8\u0001\u0000\u0000\u0000\u0585"+
|
|
"\u0586\n\u0012\u0000\u0000\u0586\u0587\u0007\u0007\u0000\u0000\u0587\u05d7"+
|
|
"\u0003\u00d2i\u0013\u0588\u0589\n\u0011\u0000\u0000\u0589\u058a\u0007"+
|
|
"\b\u0000\u0000\u058a\u05d7\u0003\u00d2i\u0012\u058b\u0593\n\u0010\u0000"+
|
|
"\u0000\u058c\u058d\u0005Y\u0000\u0000\u058d\u0594\u0005Y\u0000\u0000\u058e"+
|
|
"\u058f\u0005X\u0000\u0000\u058f\u0590\u0005X\u0000\u0000\u0590\u0594\u0005"+
|
|
"X\u0000\u0000\u0591\u0592\u0005X\u0000\u0000\u0592\u0594\u0005X\u0000"+
|
|
"\u0000\u0593\u058c\u0001\u0000\u0000\u0000\u0593\u058e\u0001\u0000\u0000"+
|
|
"\u0000\u0593\u0591\u0001\u0000\u0000\u0000\u0594\u0595\u0001\u0000\u0000"+
|
|
"\u0000\u0595\u05d7\u0003\u00d2i\u0011\u0596\u0597\n\u000f\u0000\u0000"+
|
|
"\u0597\u0598\u0007\t\u0000\u0000\u0598\u05d7\u0003\u00d2i\u0010\u0599"+
|
|
"\u059a\n\r\u0000\u0000\u059a\u059b\u0007\n\u0000\u0000\u059b\u05d7\u0003"+
|
|
"\u00d2i\u000e\u059c\u059d\n\f\u0000\u0000\u059d\u059e\u0005j\u0000\u0000"+
|
|
"\u059e\u05d7\u0003\u00d2i\r\u059f\u05a0\n\u000b\u0000\u0000\u05a0\u05a1"+
|
|
"\u0005l\u0000\u0000\u05a1\u05d7\u0003\u00d2i\f\u05a2\u05a3\n\n\u0000\u0000"+
|
|
"\u05a3\u05a4\u0005k\u0000\u0000\u05a4\u05d7\u0003\u00d2i\u000b\u05a5\u05a6"+
|
|
"\n\t\u0000\u0000\u05a6\u05a7\u0005b\u0000\u0000\u05a7\u05d7\u0003\u00d2"+
|
|
"i\n\u05a8\u05a9\n\b\u0000\u0000\u05a9\u05aa\u0005c\u0000\u0000\u05aa\u05d7"+
|
|
"\u0003\u00d2i\t\u05ab\u05ac\n\u0007\u0000\u0000\u05ac\u05ad\u0005\\\u0000"+
|
|
"\u0000\u05ad\u05ae\u0003\u00d2i\u0000\u05ae\u05af\u0005]\u0000\u0000\u05af"+
|
|
"\u05b0\u0003\u00d2i\u0007\u05b0\u05d7\u0001\u0000\u0000\u0000\u05b1\u05b2"+
|
|
"\n\u0006\u0000\u0000\u05b2\u05b3\u0007\u000b\u0000\u0000\u05b3\u05d7\u0003"+
|
|
"\u00d2i\u0006\u05b4\u05b5\n\u0019\u0000\u0000\u05b5\u05c1\u0005V\u0000"+
|
|
"\u0000\u05b6\u05c2\u0003\u00aeW\u0000\u05b7\u05c2\u0003\u00d0h\u0000\u05b8"+
|
|
"\u05c2\u0005+\u0000\u0000\u05b9\u05bb\u0005\u001f\u0000\u0000\u05ba\u05bc"+
|
|
"\u0003\u0106\u0083\u0000\u05bb\u05ba\u0001\u0000\u0000\u0000\u05bb\u05bc"+
|
|
"\u0001\u0000\u0000\u0000\u05bc\u05bd\u0001\u0000\u0000\u0000\u05bd\u05c2"+
|
|
"\u0003\u00fa}\u0000\u05be\u05bf\u0005(\u0000\u0000\u05bf\u05c2\u0003\u0110"+
|
|
"\u0088\u0000\u05c0\u05c2\u0003\u0100\u0080\u0000\u05c1\u05b6\u0001\u0000"+
|
|
"\u0000\u0000\u05c1\u05b7\u0001\u0000\u0000\u0000\u05c1\u05b8\u0001\u0000"+
|
|
"\u0000\u0000\u05c1\u05b9\u0001\u0000\u0000\u0000\u05c1\u05be\u0001\u0000"+
|
|
"\u0000\u0000\u05c1\u05c0\u0001\u0000\u0000\u0000\u05c2\u05d7\u0001\u0000"+
|
|
"\u0000\u0000\u05c3\u05c4\n\u0018\u0000\u0000\u05c4\u05c5\u0005R\u0000"+
|
|
"\u0000\u05c5\u05c6\u0003\u00d2i\u0000\u05c6\u05c7\u0005S\u0000\u0000\u05c7"+
|
|
"\u05d7\u0001\u0000\u0000\u0000\u05c8\u05c9\n\u0014\u0000\u0000\u05c9\u05d7"+
|
|
"\u0007\f\u0000\u0000\u05ca\u05cb\n\u000e\u0000\u0000\u05cb\u05ce\u0005"+
|
|
"\u001a\u0000\u0000\u05cc\u05cf\u0003\u010a\u0085\u0000\u05cd\u05cf\u0003"+
|
|
"\u00d4j\u0000\u05ce\u05cc\u0001\u0000\u0000\u0000\u05ce\u05cd\u0001\u0000"+
|
|
"\u0000\u0000\u05cf\u05d7\u0001\u0000\u0000\u0000\u05d0\u05d1\n\u0003\u0000"+
|
|
"\u0000\u05d1\u05d3\u0005z\u0000\u0000\u05d2\u05d4\u0003\u010e\u0087\u0000"+
|
|
"\u05d3\u05d2\u0001\u0000\u0000\u0000\u05d3\u05d4\u0001\u0000\u0000\u0000"+
|
|
"\u05d4\u05d5\u0001\u0000\u0000\u0000\u05d5\u05d7\u0003\u00aeW\u0000\u05d6"+
|
|
"\u0585\u0001\u0000\u0000\u0000\u05d6\u0588\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u058b\u0001\u0000\u0000\u0000\u05d6\u0596\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u0599\u0001\u0000\u0000\u0000\u05d6\u059c\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u059f\u0001\u0000\u0000\u0000\u05d6\u05a2\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u05a5\u0001\u0000\u0000\u0000\u05d6\u05a8\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u05ab\u0001\u0000\u0000\u0000\u05d6\u05b1\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u05b4\u0001\u0000\u0000\u0000\u05d6\u05c3\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u05c8\u0001\u0000\u0000\u0000\u05d6\u05ca\u0001\u0000\u0000\u0000\u05d6"+
|
|
"\u05d0\u0001\u0000\u0000\u0000\u05d7\u05da\u0001\u0000\u0000\u0000\u05d8"+
|
|
"\u05d6\u0001\u0000\u0000\u0000\u05d8\u05d9\u0001\u0000\u0000\u0000\u05d9"+
|
|
"\u00d3\u0001\u0000\u0000\u0000\u05da\u05d8\u0001\u0000\u0000\u0000\u05db"+
|
|
"\u05de\u0003\u00d6k\u0000\u05dc\u05de\u0003\u00f0x\u0000\u05dd\u05db\u0001"+
|
|
"\u0000\u0000\u0000\u05dd\u05dc\u0001\u0000\u0000\u0000\u05de\u00d5\u0001"+
|
|
"\u0000\u0000\u0000\u05df\u05e6\u0003\u00dam\u0000\u05e0\u05e6\u0003\u00d8"+
|
|
"l\u0000\u05e1\u05e2\u0005N\u0000\u0000\u05e2\u05e3\u0003\u00d4j\u0000"+
|
|
"\u05e3\u05e4\u0005O\u0000\u0000\u05e4\u05e6\u0001\u0000\u0000\u0000\u05e5"+
|
|
"\u05df\u0001\u0000\u0000\u0000\u05e5\u05e0\u0001\u0000\u0000\u0000\u05e5"+
|
|
"\u05e1\u0001\u0000\u0000\u0000\u05e6\u00d7\u0001\u0000\u0000\u0000\u05e7"+
|
|
"\u05e8\u0003\u010a\u0085\u0000\u05e8\u05ea\u0003\u00dcn\u0000\u05e9\u05eb"+
|
|
"\u0003\u00aeW\u0000\u05ea\u05e9\u0001\u0000\u0000\u0000\u05ea\u05eb\u0001"+
|
|
"\u0000\u0000\u0000\u05eb\u00d9\u0001\u0000\u0000\u0000\u05ec\u05ee\u0003"+
|
|
"\f\u0006\u0000\u05ed\u05ec\u0001\u0000\u0000\u0000\u05ee\u05f1\u0001\u0000"+
|
|
"\u0000\u0000\u05ef\u05ed\u0001\u0000\u0000\u0000\u05ef\u05f0\u0001\u0000"+
|
|
"\u0000\u0000\u05f0\u05f2\u0001\u0000\u0000\u0000\u05f1\u05ef\u0001\u0000"+
|
|
"\u0000\u0000\u05f2\u05f3\u0003\u010a\u0085\u0000\u05f3\u05f4\u0003\u00ae"+
|
|
"W\u0000\u05f4\u05fd\u0001\u0000\u0000\u0000\u05f5\u05f7\u0003\f\u0006"+
|
|
"\u0000\u05f6\u05f5\u0001\u0000\u0000\u0000\u05f7\u05fa\u0001\u0000\u0000"+
|
|
"\u0000\u05f8\u05f6\u0001\u0000\u0000\u0000\u05f8\u05f9\u0001\u0000\u0000"+
|
|
"\u0000\u05f9\u05fb\u0001\u0000\u0000\u0000\u05fa\u05f8\u0001\u0000\u0000"+
|
|
"\u0000\u05fb\u05fd\u0003\u00aeW\u0000\u05fc\u05ef\u0001\u0000\u0000\u0000"+
|
|
"\u05fc\u05f8\u0001\u0000\u0000\u0000\u05fd\u00db\u0001\u0000\u0000\u0000"+
|
|
"\u05fe\u0600\u0005N\u0000\u0000\u05ff\u0601\u0003\u00e0p\u0000\u0600\u05ff"+
|
|
"\u0001\u0000\u0000\u0000\u0600\u0601\u0001\u0000\u0000\u0000\u0601\u0602"+
|
|
"\u0001\u0000\u0000\u0000\u0602\u0603\u0005O\u0000\u0000\u0603\u00dd\u0001"+
|
|
"\u0000\u0000\u0000\u0604\u0607\u0003\u00d4j\u0000\u0605\u0607\u0003\u00ae"+
|
|
"W\u0000\u0606\u0604\u0001\u0000\u0000\u0000\u0606\u0605\u0001\u0000\u0000"+
|
|
"\u0000\u0607\u00df\u0001\u0000\u0000\u0000\u0608\u060d\u0003\u00d4j\u0000"+
|
|
"\u0609\u060a\u0005U\u0000\u0000\u060a\u060c\u0003\u00d4j\u0000\u060b\u0609"+
|
|
"\u0001\u0000\u0000\u0000\u060c\u060f\u0001\u0000\u0000\u0000\u060d\u060b"+
|
|
"\u0001\u0000\u0000\u0000\u060d\u060e\u0001\u0000\u0000\u0000\u060e\u00e1"+
|
|
"\u0001\u0000\u0000\u0000\u060f\u060d\u0001\u0000\u0000\u0000\u0610\u0611"+
|
|
"\u0003\u00e4r\u0000\u0611\u0612\u0005y\u0000\u0000\u0612\u0613\u0003\u00e6"+
|
|
"s\u0000\u0613\u00e3\u0001\u0000\u0000\u0000\u0614\u062b\u0003\u00aeW\u0000"+
|
|
"\u0615\u0617\u0005N\u0000\u0000\u0616\u0618\u0003h4\u0000\u0617\u0616"+
|
|
"\u0001\u0000\u0000\u0000\u0617\u0618\u0001\u0000\u0000\u0000\u0618\u0619"+
|
|
"\u0001\u0000\u0000\u0000\u0619\u062b\u0005O\u0000\u0000\u061a\u061b\u0005"+
|
|
"N\u0000\u0000\u061b\u0620\u0003\u00aeW\u0000\u061c\u061d\u0005U\u0000"+
|
|
"\u0000\u061d\u061f\u0003\u00aeW\u0000\u061e\u061c\u0001\u0000\u0000\u0000"+
|
|
"\u061f\u0622\u0001\u0000\u0000\u0000\u0620\u061e\u0001\u0000\u0000\u0000"+
|
|
"\u0620\u0621\u0001\u0000\u0000\u0000\u0621\u0623\u0001\u0000\u0000\u0000"+
|
|
"\u0622\u0620\u0001\u0000\u0000\u0000\u0623\u0624\u0005O\u0000\u0000\u0624"+
|
|
"\u062b\u0001\u0000\u0000\u0000\u0625\u0627\u0005N\u0000\u0000\u0626\u0628"+
|
|
"\u0003n7\u0000\u0627\u0626\u0001\u0000\u0000\u0000\u0627\u0628\u0001\u0000"+
|
|
"\u0000\u0000\u0628\u0629\u0001\u0000\u0000\u0000\u0629\u062b\u0005O\u0000"+
|
|
"\u0000\u062a\u0614\u0001\u0000\u0000\u0000\u062a\u0615\u0001\u0000\u0000"+
|
|
"\u0000\u062a\u061a\u0001\u0000\u0000\u0000\u062a\u0625\u0001\u0000\u0000"+
|
|
"\u0000\u062b\u00e5\u0001\u0000\u0000\u0000\u062c\u062f\u0003\u00d2i\u0000"+
|
|
"\u062d\u062f\u0003\u00a8T\u0000\u062e\u062c\u0001\u0000\u0000\u0000\u062e"+
|
|
"\u062d\u0001\u0000\u0000\u0000\u062f\u00e7\u0001\u0000\u0000\u0000\u0630"+
|
|
"\u0631\u0005N\u0000\u0000\u0631\u0632\u0003\u00d2i\u0000\u0632\u0633\u0005"+
|
|
"O\u0000\u0000\u0633\u0643\u0001\u0000\u0000\u0000\u0634\u0643\u0005+\u0000"+
|
|
"\u0000\u0635\u0643\u0005(\u0000\u0000\u0636\u0643\u0003t:\u0000\u0637"+
|
|
"\u0643\u0003\u00aeW\u0000\u0638\u0639\u00030\u0018\u0000\u0639\u063a\u0005"+
|
|
"V\u0000\u0000\u063a\u063b\u0005\t\u0000\u0000\u063b\u0643\u0001\u0000"+
|
|
"\u0000\u0000\u063c\u0640\u0003\u0106\u0083\u0000\u063d\u0641\u0003\u0112"+
|
|
"\u0089\u0000\u063e\u063f\u0005+\u0000\u0000\u063f\u0641\u0003\u0114\u008a"+
|
|
"\u0000\u0640\u063d\u0001\u0000\u0000\u0000\u0640\u063e\u0001\u0000\u0000"+
|
|
"\u0000\u0641\u0643\u0001\u0000\u0000\u0000\u0642\u0630\u0001\u0000\u0000"+
|
|
"\u0000\u0642\u0634\u0001\u0000\u0000\u0000\u0642\u0635\u0001\u0000\u0000"+
|
|
"\u0000\u0642\u0636\u0001\u0000\u0000\u0000\u0642\u0637\u0001\u0000\u0000"+
|
|
"\u0000\u0642\u0638\u0001\u0000\u0000\u0000\u0642\u063c\u0001\u0000\u0000"+
|
|
"\u0000\u0643\u00e9\u0001\u0000\u0000\u0000\u0644\u0645\u0005)\u0000\u0000"+
|
|
"\u0645\u0646\u0003\u00ccf\u0000\u0646\u064a\u0005P\u0000\u0000\u0647\u0649"+
|
|
"\u0003\u00ecv\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u064c\u0001"+
|
|
"\u0000\u0000\u0000\u064a\u0648\u0001\u0000\u0000\u0000\u064a\u064b\u0001"+
|
|
"\u0000\u0000\u0000\u064b\u064d\u0001\u0000\u0000\u0000\u064c\u064a\u0001"+
|
|
"\u0000\u0000\u0000\u064d\u064e\u0005Q\u0000\u0000\u064e\u00eb\u0001\u0000"+
|
|
"\u0000\u0000\u064f\u0650\u0003\u00eew\u0000\u0650\u0651\u0003\u00f2y\u0000"+
|
|
"\u0651\u00ed\u0001\u0000\u0000\u0000\u0652\u0653\u0005\u0006\u0000\u0000"+
|
|
"\u0653\u0654\u0005M\u0000\u0000\u0654\u0660\u0007\r\u0000\u0000\u0655"+
|
|
"\u0656\u0005\u0006\u0000\u0000\u0656\u0657\u0003\u00d4j\u0000\u0657\u0658"+
|
|
"\u0007\r\u0000\u0000\u0658\u0660\u0001\u0000\u0000\u0000\u0659\u065a\u0005"+
|
|
"\f\u0000\u0000\u065a\u0660\u0007\r\u0000\u0000\u065b\u065c\u0005\u0006"+
|
|
"\u0000\u0000\u065c\u065d\u0003\u00ceg\u0000\u065d\u065e\u0007\r\u0000"+
|
|
"\u0000\u065e\u0660\u0001\u0000\u0000\u0000\u065f\u0652\u0001\u0000\u0000"+
|
|
"\u0000\u065f\u0655\u0001\u0000\u0000\u0000\u065f\u0659\u0001\u0000\u0000"+
|
|
"\u0000\u065f\u065b\u0001\u0000\u0000\u0000\u0660\u00ef\u0001\u0000\u0000"+
|
|
"\u0000\u0661\u0662\u0003\u00d6k\u0000\u0662\u0663\u0005;\u0000\u0000\u0663"+
|
|
"\u0664\u0003\u00d2i\u0000\u0664\u00f1\u0001\u0000\u0000\u0000\u0665\u066a"+
|
|
"\u0003\u00a8T\u0000\u0666\u0667\u0003\u00d2i\u0000\u0667\u0668\u0005T"+
|
|
"\u0000\u0000\u0668\u066a\u0001\u0000\u0000\u0000\u0669\u0665\u0001\u0000"+
|
|
"\u0000\u0000\u0669\u0666\u0001\u0000\u0000\u0000\u066a\u00f3\u0001\u0000"+
|
|
"\u0000\u0000\u066b\u066c\u0003V+\u0000\u066c\u066d\u0005V\u0000\u0000"+
|
|
"\u066d\u066f\u0001\u0000\u0000\u0000\u066e\u066b\u0001\u0000\u0000\u0000"+
|
|
"\u066e\u066f\u0001\u0000\u0000\u0000\u066f\u0673\u0001\u0000\u0000\u0000"+
|
|
"\u0670\u0672\u0003|>\u0000\u0671\u0670\u0001\u0000\u0000\u0000\u0672\u0675"+
|
|
"\u0001\u0000\u0000\u0000\u0673\u0671\u0001\u0000\u0000\u0000\u0673\u0674"+
|
|
"\u0001\u0000\u0000\u0000\u0674\u0676\u0001\u0000\u0000\u0000\u0675\u0673"+
|
|
"\u0001\u0000\u0000\u0000\u0676\u0678\u0003\u00aeW\u0000\u0677\u0679\u0003"+
|
|
"\u010e\u0087\u0000\u0678\u0677\u0001\u0000\u0000\u0000\u0678\u0679\u0001"+
|
|
"\u0000\u0000\u0000\u0679\u00f5\u0001\u0000\u0000\u0000\u067a\u067b\u0003"+
|
|
"\u0106\u0083\u0000\u067b\u067c\u0003\u00f8|\u0000\u067c\u067d\u0003\u00fe"+
|
|
"\u007f\u0000\u067d\u0684\u0001\u0000\u0000\u0000\u067e\u0681\u0003\u00f8"+
|
|
"|\u0000\u067f\u0682\u0003\u00fc~\u0000\u0680\u0682\u0003\u00fe\u007f\u0000"+
|
|
"\u0681\u067f\u0001\u0000\u0000\u0000\u0681\u0680\u0001\u0000\u0000\u0000"+
|
|
"\u0682\u0684\u0001\u0000\u0000\u0000\u0683\u067a\u0001\u0000\u0000\u0000"+
|
|
"\u0683\u067e\u0001\u0000\u0000\u0000\u0684\u00f7\u0001\u0000\u0000\u0000"+
|
|
"\u0685\u0687\u0003\u00aeW\u0000\u0686\u0688\u0003\u0102\u0081\u0000\u0687"+
|
|
"\u0686\u0001\u0000\u0000\u0000\u0687\u0688\u0001\u0000\u0000\u0000\u0688"+
|
|
"\u068b\u0001\u0000\u0000\u0000\u0689\u068b\u0003\u010c\u0086\u0000\u068a"+
|
|
"\u0685\u0001\u0000\u0000\u0000\u068a\u0689\u0001\u0000\u0000\u0000\u068b"+
|
|
"\u00f9\u0001\u0000\u0000\u0000\u068c\u068e\u0003\u00aeW\u0000\u068d\u068f"+
|
|
"\u0003\u0104\u0082\u0000\u068e\u068d\u0001\u0000\u0000\u0000\u068e\u068f"+
|
|
"\u0001\u0000\u0000\u0000\u068f\u0690\u0001\u0000\u0000\u0000\u0690\u0691"+
|
|
"\u0003\u00fe\u007f\u0000\u0691\u00fb\u0001\u0000\u0000\u0000\u0692\u06ae"+
|
|
"\u0005R\u0000\u0000\u0693\u0698\u0005S\u0000\u0000\u0694\u0695\u0005R"+
|
|
"\u0000\u0000\u0695\u0697\u0005S\u0000\u0000\u0696\u0694\u0001\u0000\u0000"+
|
|
"\u0000\u0697\u069a\u0001\u0000\u0000\u0000\u0698\u0696\u0001\u0000\u0000"+
|
|
"\u0000\u0698\u0699\u0001\u0000\u0000\u0000\u0699\u069b\u0001\u0000\u0000"+
|
|
"\u0000\u069a\u0698\u0001\u0000\u0000\u0000\u069b\u06af\u0003T*\u0000\u069c"+
|
|
"\u069d\u0003\u00d2i\u0000\u069d\u06a4\u0005S\u0000\u0000\u069e\u069f\u0005"+
|
|
"R\u0000\u0000\u069f\u06a0\u0003\u00d2i\u0000\u06a0\u06a1\u0005S\u0000"+
|
|
"\u0000\u06a1\u06a3\u0001\u0000\u0000\u0000\u06a2\u069e\u0001\u0000\u0000"+
|
|
"\u0000\u06a3\u06a6\u0001\u0000\u0000\u0000\u06a4\u06a2\u0001\u0000\u0000"+
|
|
"\u0000\u06a4\u06a5\u0001\u0000\u0000\u0000\u06a5\u06ab\u0001\u0000\u0000"+
|
|
"\u0000\u06a6\u06a4\u0001\u0000\u0000\u0000\u06a7\u06a8\u0005R\u0000\u0000"+
|
|
"\u06a8\u06aa\u0005S\u0000\u0000\u06a9\u06a7\u0001\u0000\u0000\u0000\u06aa"+
|
|
"\u06ad\u0001\u0000\u0000\u0000\u06ab\u06a9\u0001\u0000\u0000\u0000\u06ab"+
|
|
"\u06ac\u0001\u0000\u0000\u0000\u06ac\u06af\u0001\u0000\u0000\u0000\u06ad"+
|
|
"\u06ab\u0001\u0000\u0000\u0000\u06ae\u0693\u0001\u0000\u0000\u0000\u06ae"+
|
|
"\u069c\u0001\u0000\u0000\u0000\u06af\u00fd\u0001\u0000\u0000\u0000\u06b0"+
|
|
"\u06b2\u0003\u0114\u008a\u0000\u06b1\u06b3\u0003 \u0010\u0000\u06b2\u06b1"+
|
|
"\u0001\u0000\u0000\u0000\u06b2\u06b3\u0001\u0000\u0000\u0000\u06b3\u00ff"+
|
|
"\u0001\u0000\u0000\u0000\u06b4\u06b5\u0003\u0106\u0083\u0000\u06b5\u06b6"+
|
|
"\u0003\u0112\u0089\u0000\u06b6\u0101\u0001\u0000\u0000\u0000\u06b7\u06b8"+
|
|
"\u0005Y\u0000\u0000\u06b8\u06bb\u0005X\u0000\u0000\u06b9\u06bb\u0003\u010e"+
|
|
"\u0087\u0000\u06ba\u06b7\u0001\u0000\u0000\u0000\u06ba\u06b9\u0001\u0000"+
|
|
"\u0000\u0000\u06bb\u0103\u0001\u0000\u0000\u0000\u06bc\u06bd\u0005Y\u0000"+
|
|
"\u0000\u06bd\u06c0\u0005X\u0000\u0000\u06be\u06c0\u0003\u0106\u0083\u0000"+
|
|
"\u06bf\u06bc\u0001\u0000\u0000\u0000\u06bf\u06be\u0001\u0000\u0000\u0000"+
|
|
"\u06c0\u0105\u0001\u0000\u0000\u0000\u06c1\u06c2\u0005Y\u0000\u0000\u06c2"+
|
|
"\u06c3\u0003\u0108\u0084\u0000\u06c3\u06c4\u0005X\u0000\u0000\u06c4\u0107"+
|
|
"\u0001\u0000\u0000\u0000\u06c5\u06ca\u0003\u010a\u0085\u0000\u06c6\u06c7"+
|
|
"\u0005U\u0000\u0000\u06c7\u06c9\u0003\u010a\u0085\u0000\u06c8\u06c6\u0001"+
|
|
"\u0000\u0000\u0000\u06c9\u06cc\u0001\u0000\u0000\u0000\u06ca\u06c8\u0001"+
|
|
"\u0000\u0000\u0000\u06ca\u06cb\u0001\u0000\u0000\u0000\u06cb\u0109\u0001"+
|
|
"\u0000\u0000\u0000\u06cc\u06ca\u0001\u0000\u0000\u0000\u06cd\u06cf\u0003"+
|
|
"|>\u0000\u06ce\u06cd\u0001\u0000\u0000\u0000\u06cf\u06d2\u0001\u0000\u0000"+
|
|
"\u0000\u06d0\u06ce\u0001\u0000\u0000\u0000\u06d0\u06d1\u0001\u0000\u0000"+
|
|
"\u0000\u06d1\u06d5\u0001\u0000\u0000\u0000\u06d2\u06d0\u0001\u0000\u0000"+
|
|
"\u0000\u06d3\u06d6\u0003V+\u0000\u06d4\u06d6\u0003\u010c\u0086\u0000\u06d5"+
|
|
"\u06d3\u0001\u0000\u0000\u0000\u06d5\u06d4\u0001\u0000\u0000\u0000\u06d6"+
|
|
"\u06e1\u0001\u0000\u0000\u0000\u06d7\u06d9\u0003|>\u0000\u06d8\u06d7\u0001"+
|
|
"\u0000\u0000\u0000\u06d9\u06dc\u0001\u0000\u0000\u0000\u06da\u06d8\u0001"+
|
|
"\u0000\u0000\u0000\u06da\u06db\u0001\u0000\u0000\u0000\u06db\u06dd\u0001"+
|
|
"\u0000\u0000\u0000\u06dc\u06da\u0001\u0000\u0000\u0000\u06dd\u06de\u0005"+
|
|
"R\u0000\u0000\u06de\u06e0\u0005S\u0000\u0000\u06df\u06da\u0001\u0000\u0000"+
|
|
"\u0000\u06e0\u06e3\u0001\u0000\u0000\u0000\u06e1\u06df\u0001\u0000\u0000"+
|
|
"\u0000\u06e1\u06e2\u0001\u0000\u0000\u0000\u06e2\u010b\u0001\u0000\u0000"+
|
|
"\u0000\u06e3\u06e1\u0001\u0000\u0000\u0000\u06e4\u06e5\u0007\u000e\u0000"+
|
|
"\u0000\u06e5\u010d\u0001\u0000\u0000\u0000\u06e6\u06e7\u0005Y\u0000\u0000"+
|
|
"\u06e7\u06ec\u0003X,\u0000\u06e8\u06e9\u0005U\u0000\u0000\u06e9\u06eb"+
|
|
"\u0003X,\u0000\u06ea\u06e8\u0001\u0000\u0000\u0000\u06eb\u06ee\u0001\u0000"+
|
|
"\u0000\u0000\u06ec\u06ea\u0001\u0000\u0000\u0000\u06ec\u06ed\u0001\u0000"+
|
|
"\u0000\u0000\u06ed\u06ef\u0001\u0000\u0000\u0000\u06ee\u06ec\u0001\u0000"+
|
|
"\u0000\u0000\u06ef\u06f0\u0005X\u0000\u0000\u06f0\u010f\u0001\u0000\u0000"+
|
|
"\u0000\u06f1\u06fb\u0003\u0114\u008a\u0000\u06f2\u06f4\u0005V\u0000\u0000"+
|
|
"\u06f3\u06f5\u0003\u010e\u0087\u0000\u06f4\u06f3\u0001\u0000\u0000\u0000"+
|
|
"\u06f4\u06f5\u0001\u0000\u0000\u0000\u06f5\u06f6\u0001\u0000\u0000\u0000"+
|
|
"\u06f6\u06f8\u0003\u00aeW\u0000\u06f7\u06f9\u0003\u0114\u008a\u0000\u06f8"+
|
|
"\u06f7\u0001\u0000\u0000\u0000\u06f8\u06f9\u0001\u0000\u0000\u0000\u06f9"+
|
|
"\u06fb\u0001\u0000\u0000\u0000\u06fa\u06f1\u0001\u0000\u0000\u0000\u06fa"+
|
|
"\u06f2\u0001\u0000\u0000\u0000\u06fb\u0111\u0001\u0000\u0000\u0000\u06fc"+
|
|
"\u06fd\u0005(\u0000\u0000\u06fd\u0702\u0003\u0110\u0088\u0000\u06fe\u06ff"+
|
|
"\u0003\u00aeW\u0000\u06ff\u0700\u0003\u0114\u008a\u0000\u0700\u0702\u0001"+
|
|
"\u0000\u0000\u0000\u0701\u06fc\u0001\u0000\u0000\u0000\u0701\u06fe\u0001"+
|
|
"\u0000\u0000\u0000\u0702\u0113\u0001\u0000\u0000\u0000\u0703\u0705\u0005"+
|
|
"N\u0000\u0000\u0704\u0706\u0003\u00ceg\u0000\u0705\u0704\u0001\u0000\u0000"+
|
|
"\u0000\u0705\u0706\u0001\u0000\u0000\u0000\u0706\u0707\u0001\u0000\u0000"+
|
|
"\u0000\u0707\u0708\u0005O\u0000\u0000\u0708\u0115\u0001\u0000\u0000\u0000"+
|
|
"\u00e2\u0117\u011c\u0122\u0128\u012d\u0136\u013b\u0142\u014a\u014d\u0154"+
|
|
"\u0160\u0164\u0169\u016d\u0171\u0175\u017f\u0187\u018f\u0193\u019a\u01a1"+
|
|
"\u01a5\u01a8\u01ab\u01b4\u01ba\u01bf\u01c2\u01c8\u01ce\u01d2\u01d6\u01de"+
|
|
"\u01e7\u01ee\u01f4\u01f8\u01fe\u0202\u0207\u020c\u0214\u0219\u021d\u0224"+
|
|
"\u022d\u0232\u023a\u023f\u0245\u0248\u024f\u0259\u0262\u026d\u0272\u027b"+
|
|
"\u027f\u0287\u028c\u0295\u029b\u02a2\u02a7\u02af\u02b3\u02b5\u02bb\u02c1"+
|
|
"\u02c6\u02ca\u02cf\u02d5\u02e2\u02e9\u02ee\u02f1\u02f3\u02f8\u02ff\u0309"+
|
|
"\u030e\u0311\u0316\u031a\u031e\u0323\u0327\u032c\u0337\u033d\u0348\u0352"+
|
|
"\u035d\u0366\u036b\u036e\u0375\u037f\u0387\u038a\u038d\u039a\u03a2\u03a7"+
|
|
"\u03af\u03b1\u03b5\u03bb\u03c3\u03cd\u03d6\u03e0\u03e8\u03f6\u03fd\u0402"+
|
|
"\u0408\u0411\u0415\u041d\u0426\u0430\u0435\u043a\u0445\u044b\u044e\u0455"+
|
|
"\u045e\u0475\u0478\u047b\u0483\u0487\u048f\u0495\u04a0\u04a9\u04ae\u04bd"+
|
|
"\u04c4\u04c8\u04d3\u04dc\u04e5\u04eb\u04ef\u04f4\u04fa\u04ff\u0504\u0513"+
|
|
"\u0517\u051b\u051f\u0521\u0525\u052a\u052e\u0531\u0540\u0546\u054d\u0553"+
|
|
"\u0556\u0561\u0569\u0576\u057a\u057f\u0583\u0593\u05bb\u05c1\u05ce\u05d3"+
|
|
"\u05d6\u05d8\u05dd\u05e5\u05ea\u05ef\u05f8\u05fc\u0600\u0606\u060d\u0617"+
|
|
"\u0620\u0627\u062a\u062e\u0640\u0642\u064a\u065f\u0669\u066e\u0673\u0678"+
|
|
"\u0681\u0683\u0687\u068a\u068e\u0698\u06a4\u06ab\u06ae\u06b2\u06ba\u06bf"+
|
|
"\u06ca\u06d0\u06d5\u06da\u06e1\u06ec\u06f4\u06f8\u06fa\u0701\u0705";
|
|
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);
|
|
}
|
|
}
|
|
} |