branch feature/3880-java8-api-scan created (now d5b55db)
This is an automated email from the git hooks/post-receive script. New change to branch feature/3880-java8-api-scan in repository i18n. See http://git.nuiton.org/i18n.git at d5b55db fixes #3880: Use java 8 API to scan code fixes #3449: Fail to extract t( t( "string") ) This branch includes the following new commits: new d5b55db fixes #3880: Use java 8 API to scan code fixes #3449: Fail to extract t( t( "string") ) The 1 revisions listed above as "new" are entirely new to this repository and will be described in separate emails. The revisions listed as "adds" were already present in the repository and have only been added to this reference. Detailed log of new commits: commit d5b55db14a1da191e0d8c1b588e0484870abfb50 Author: Eric Chatellier <chatellier@codelutin.com> Date: Fri Feb 19 16:02:18 2016 +0100 fixes #3880: Use java 8 API to scan code fixes #3449: Fail to extract t( t( "string") ) -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
This is an automated email from the git hooks/post-receive script. New commit to branch feature/3880-java8-api-scan in repository i18n. See http://git.nuiton.org/i18n.git commit d5b55db14a1da191e0d8c1b588e0484870abfb50 Author: Eric Chatellier <chatellier@codelutin.com> Date: Fri Feb 19 16:02:18 2016 +0100 fixes #3880: Use java 8 API to scan code fixes #3449: Fail to extract t( t( "string") ) --- i18n-maven-plugin/pom.xml | 4 +- i18n-maven-plugin/src/main/antlr4/Java.g4 | 1020 -- i18n-maven-plugin/src/main/antlr4/Java8.g4 | 1779 ++ .../java/Java.tokens => antlr4/Java8.tokens} | 334 +- .../src/main/antlr4/Java8BaseVisitor.java | 1672 ++ i18n-maven-plugin/src/main/antlr4/Java8Lexer.java | 583 + .../JavaLexer.tokens => antlr4/Java8Lexer.tokens} | 334 +- i18n-maven-plugin/src/main/antlr4/Java8Parser.java | 17844 ++++++++++++++++++ .../src/main/antlr4/Java8Visitor.java | 1434 ++ .../i18n/plugin/parser/impl/ParserGWTJavaMojo.java | 19 +- .../i18n/plugin/parser/impl/ParserJavaMojo.java | 104 +- .../parser/java/{Java.tokens => Java8.tokens} | 334 +- .../i18n/plugin/parser/java/Java8BaseVisitor.java | 1698 ++ .../nuiton/i18n/plugin/parser/java/Java8Lexer.java | 609 + .../parser/java/{Java.tokens => Java8Lexer.tokens} | 334 +- .../i18n/plugin/parser/java/Java8Parser.java | 17870 +++++++++++++++++++ .../i18n/plugin/parser/java/Java8Visitor.java | 1460 ++ .../i18n/plugin/parser/java/JavaBaseListener.java | 1376 -- .../i18n/plugin/parser/java/JavaBaseVisitor.java | 846 - .../nuiton/i18n/plugin/parser/java/JavaLexer.java | 570 - .../i18n/plugin/parser/java/JavaListener.java | 1145 -- .../nuiton/i18n/plugin/parser/java/JavaParser.java | 8384 --------- .../i18n/plugin/parser/java/JavaVisitor.java | 744 - .../plugin/parser/impl/JavaFileParserTest.java | 56 +- nuiton-i18n-editor/pom.xml | 8 +- pom.xml | 6 +- 26 files changed, 45773 insertions(+), 14794 deletions(-) diff --git a/i18n-maven-plugin/pom.xml b/i18n-maven-plugin/pom.xml index 8c62c88..1669367 100644 --- a/i18n-maven-plugin/pom.xml +++ b/i18n-maven-plugin/pom.xml @@ -65,10 +65,10 @@ <groupId>org.antlr</groupId> <artifactId>antlr4-runtime</artifactId> </dependency> - <dependency> + <!-- <dependency> <groupId>org.antlr</groupId> <artifactId>antlr4-annotations</artifactId> - </dependency> + </dependency> --> <dependency> <groupId>org.nuiton.processor</groupId> diff --git a/i18n-maven-plugin/src/main/antlr4/Java.g4 b/i18n-maven-plugin/src/main/antlr4/Java.g4 deleted file mode 100644 index 6a4b905..0000000 --- a/i18n-maven-plugin/src/main/antlr4/Java.g4 +++ /dev/null @@ -1,1020 +0,0 @@ -/* - [The "BSD licence"] - Copyright (c) 2013 Terence Parr, Sam Harwell - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - 2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. - 3. The name of the author may not be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ - -/** A Java 1.7 grammar for ANTLR v4 derived from ANTLR v3 Java grammar. - * Uses ANTLR v4's left-recursive expression notation. - * It parses ECJ, Netbeans, JDK etc... - * - * Sam Harwell cleaned this up significantly and updated to 1.7! - * - * You can test with - * - * $ antlr4 Java.g4 - * $ javac *.java - * $ grun Java compilationUnit *.java - */ -grammar Java; - -// starting point for parsing a java file -compilationUnit - : packageDeclaration? importDeclaration* typeDeclaration* EOF - ; - -packageDeclaration - : annotation* 'package' qualifiedName ';' - ; - -importDeclaration - : 'import' 'static'? qualifiedName ('.' '*')? ';' - ; - -typeDeclaration - : classOrInterfaceModifier* classDeclaration - | classOrInterfaceModifier* enumDeclaration - | classOrInterfaceModifier* interfaceDeclaration - | classOrInterfaceModifier* annotationTypeDeclaration - | ';' - ; - -modifier - : classOrInterfaceModifier - | ( 'native' - | 'synchronized' - | 'transient' - | 'volatile' - ) - ; - -classOrInterfaceModifier - : annotation // class or interface - | ( 'public' // class or interface - | 'protected' // class or interface - | 'private' // class or interface - | 'static' // class or interface - | 'abstract' // class or interface - | 'final' // class only -- does not apply to interfaces - | 'strictfp' // class or interface - ) - ; - -variableModifier - : 'final' - | annotation - ; - -classDeclaration - : 'class' Identifier typeParameters? - ('extends' type)? - ('implements' typeList)? - classBody - ; - -typeParameters - : '<' typeParameter (',' typeParameter)* '>' - ; - -typeParameter - : Identifier ('extends' typeBound)? - ; - -typeBound - : type ('&' type)* - ; - -enumDeclaration - : ENUM Identifier ('implements' typeList)? - '{' enumConstants? ','? enumBodyDeclarations? '}' - ; - -enumConstants - : enumConstant (',' enumConstant)* - ; - -enumConstant - : annotation* Identifier arguments? classBody? - ; - -enumBodyDeclarations - : ';' classBodyDeclaration* - ; - -interfaceDeclaration - : 'interface' Identifier typeParameters? ('extends' typeList)? interfaceBody - ; - -typeList - : type (',' type)* - ; - -classBody - : '{' classBodyDeclaration* '}' - ; - -interfaceBody - : '{' interfaceBodyDeclaration* '}' - ; - -classBodyDeclaration - : ';' - | 'static'? block - | modifier* memberDeclaration - ; - -memberDeclaration - : methodDeclaration - | genericMethodDeclaration - | fieldDeclaration - | constructorDeclaration - | genericConstructorDeclaration - | interfaceDeclaration - | annotationTypeDeclaration - | classDeclaration - | enumDeclaration - ; - -/* We use rule this even for void methods which cannot have [] after parameters. - This simplifies grammar and we can consider void to be a type, which - renders the [] matching as a context-sensitive issue or a semantic check - for invalid return type after parsing. - */ -methodDeclaration - : (type|'void') Identifier formalParameters ('[' ']')* - ('throws' qualifiedNameList)? - ( methodBody - | ';' - ) - ; - -genericMethodDeclaration - : typeParameters methodDeclaration - ; - -constructorDeclaration - : Identifier formalParameters ('throws' qualifiedNameList)? - constructorBody - ; - -genericConstructorDeclaration - : typeParameters constructorDeclaration - ; - -fieldDeclaration - : type variableDeclarators ';' - ; - -interfaceBodyDeclaration - : modifier* interfaceMemberDeclaration - | ';' - ; - -interfaceMemberDeclaration - : constDeclaration - | interfaceMethodDeclaration - | genericInterfaceMethodDeclaration - | interfaceDeclaration - | annotationTypeDeclaration - | classDeclaration - | enumDeclaration - ; - -constDeclaration - : type constantDeclarator (',' constantDeclarator)* ';' - ; - -constantDeclarator - : Identifier ('[' ']')* '=' variableInitializer - ; - -// see matching of [] comment in methodDeclaratorRest -interfaceMethodDeclaration - : (type|'void') Identifier formalParameters ('[' ']')* - ('throws' qualifiedNameList)? - ';' - ; - -genericInterfaceMethodDeclaration - : typeParameters interfaceMethodDeclaration - ; - -variableDeclarators - : variableDeclarator (',' variableDeclarator)* - ; - -variableDeclarator - : variableDeclaratorId ('=' variableInitializer)? - ; - -variableDeclaratorId - : Identifier ('[' ']')* - ; - -variableInitializer - : arrayInitializer - | expression - ; - -arrayInitializer - : '{' (variableInitializer (',' variableInitializer)* (',')? )? '}' - ; - -enumConstantName - : Identifier - ; - -type - : classOrInterfaceType ('[' ']')* - | primitiveType ('[' ']')* - ; - -classOrInterfaceType - : Identifier typeArguments? ('.' Identifier typeArguments? )* - ; - -primitiveType - : 'boolean' - | 'char' - | 'byte' - | 'short' - | 'int' - | 'long' - | 'float' - | 'double' - ; - -typeArguments - : '<' typeArgument (',' typeArgument)* '>' - ; - -typeArgument - : type - | '?' (('extends' | 'super') type)? - ; - -qualifiedNameList - : qualifiedName (',' qualifiedName)* - ; - -formalParameters - : '(' formalParameterList? ')' - ; - -formalParameterList - : formalParameter (',' formalParameter)* (',' lastFormalParameter)? - | lastFormalParameter - ; - -formalParameter - : variableModifier* type variableDeclaratorId - ; - -lastFormalParameter - : variableModifier* type '...' variableDeclaratorId - ; - -methodBody - : block - ; - -constructorBody - : block - ; - -qualifiedName - : Identifier ('.' Identifier)* - ; - -literal - : IntegerLiteral - | FloatingPointLiteral - | CharacterLiteral - | StringLiteral - | BooleanLiteral - | 'null' - ; - -// ANNOTATIONS - -annotation - : '@' annotationName ( '(' ( elementValuePairs | elementValue )? ')' )? - ; - -annotationName : qualifiedName ; - -elementValuePairs - : elementValuePair (',' elementValuePair)* - ; - -elementValuePair - : Identifier '=' elementValue - ; - -elementValue - : expression - | annotation - | elementValueArrayInitializer - ; - -elementValueArrayInitializer - : '{' (elementValue (',' elementValue)*)? (',')? '}' - ; - -annotationTypeDeclaration - : '@' 'interface' Identifier annotationTypeBody - ; - -annotationTypeBody - : '{' (annotationTypeElementDeclaration)* '}' - ; - -annotationTypeElementDeclaration - : modifier* annotationTypeElementRest - | ';' // this is not allowed by the grammar, but apparently allowed by the actual compiler - ; - -annotationTypeElementRest - : type annotationMethodOrConstantRest ';' - | classDeclaration ';'? - | interfaceDeclaration ';'? - | enumDeclaration ';'? - | annotationTypeDeclaration ';'? - ; - -annotationMethodOrConstantRest - : annotationMethodRest - | annotationConstantRest - ; - -annotationMethodRest - : Identifier '(' ')' defaultValue? - ; - -annotationConstantRest - : variableDeclarators - ; - -defaultValue - : 'default' elementValue - ; - -// STATEMENTS / BLOCKS - -block - : '{' blockStatement* '}' - ; - -blockStatement - : localVariableDeclarationStatement - | statement - | typeDeclaration - ; - -localVariableDeclarationStatement - : localVariableDeclaration ';' - ; - -localVariableDeclaration - : variableModifier* type variableDeclarators - ; - -statement - : block - | ASSERT expression (':' expression)? ';' - | 'if' parExpression statement ('else' statement)? - | 'for' '(' forControl ')' statement - | 'while' parExpression statement - | 'do' statement 'while' parExpression ';' - | 'try' block (catchClause+ finallyBlock? | finallyBlock) - | 'try' resourceSpecification block catchClause* finallyBlock? - | 'switch' parExpression '{' switchBlockStatementGroup* switchLabel* '}' - | 'synchronized' parExpression block - | 'return' expression? ';' - | 'throw' expression ';' - | 'break' Identifier? ';' - | 'continue' Identifier? ';' - | ';' - | statementExpression ';' - | Identifier ':' statement - ; - -catchClause - : 'catch' '(' variableModifier* catchType Identifier ')' block - ; - -catchType - : qualifiedName ('|' qualifiedName)* - ; - -finallyBlock - : 'finally' block - ; - -resourceSpecification - : '(' resources ';'? ')' - ; - -resources - : resource (';' resource)* - ; - -resource - : variableModifier* classOrInterfaceType variableDeclaratorId '=' expression - ; - -/** Matches cases then statements, both of which are mandatory. - * To handle empty cases at the end, we add switchLabel* to statement. - */ -switchBlockStatementGroup - : switchLabel+ blockStatement+ - ; - -switchLabel - : 'case' constantExpression ':' - | 'case' enumConstantName ':' - | 'default' ':' - ; - -forControl - : enhancedForControl - | forInit? ';' expression? ';' forUpdate? - ; - -forInit - : localVariableDeclaration - | expressionList - ; - -enhancedForControl - : variableModifier* type Identifier ':' expression - ; - -forUpdate - : expressionList - ; - -// EXPRESSIONS - -parExpression - : '(' expression ')' - ; - -expressionList - : expression (',' expression)* - ; - -statementExpression - : expression - ; - -constantExpression - : expression - ; - -expression - : primary - | expression '.' Identifier - | expression '.' 'this' - | expression '.' 'new' nonWildcardTypeArguments? innerCreator - | expression '.' 'super' superSuffix - | expression '.' explicitGenericInvocation - | expression '[' expression ']' - | expression '(' expressionList? ')' - | 'new' creator - | '(' type ')' expression - | expression ('++' | '--') - | ('+'|'-'|'++'|'--') expression - | ('~'|'!') expression - | expression ('*'|'/'|'%') expression - | expression ('+'|'-') expression - | expression ('<' '<' | '>' '>' '>' | '>' '>') expression - | expression ('<=' | '>=' | '>' | '<') expression - | expression 'instanceof' type - | expression ('==' | '!=') expression - | expression '&' expression - | expression '^' expression - | expression '|' expression - | expression '&&' expression - | expression '||' expression - | expression '?' expression ':' expression - | expression - ( '='<assoc=right> - | '+='<assoc=right> - | '-='<assoc=right> - | '*='<assoc=right> - | '/='<assoc=right> - | '&='<assoc=right> - | '|='<assoc=right> - | '^='<assoc=right> - | '>>='<assoc=right> - | '>>>='<assoc=right> - | '<<='<assoc=right> - | '%='<assoc=right> - ) - expression - ; - -primary - : '(' expression ')' - | 'this' - | 'super' - | literal - | Identifier - | type '.' 'class' - | 'void' '.' 'class' - | nonWildcardTypeArguments (explicitGenericInvocationSuffix | 'this' arguments) - ; - -creator - : nonWildcardTypeArguments createdName classCreatorRest - | createdName (arrayCreatorRest | classCreatorRest) - ; - -createdName - : Identifier typeArgumentsOrDiamond? ('.' Identifier typeArgumentsOrDiamond?)* - | primitiveType - ; - -innerCreator - : Identifier nonWildcardTypeArgumentsOrDiamond? classCreatorRest - ; - -arrayCreatorRest - : '[' - ( ']' ('[' ']')* arrayInitializer - | expression ']' ('[' expression ']')* ('[' ']')* - ) - ; - -classCreatorRest - : arguments classBody? - ; - -explicitGenericInvocation - : nonWildcardTypeArguments explicitGenericInvocationSuffix - ; - -nonWildcardTypeArguments - : '<' typeList '>' - ; - -typeArgumentsOrDiamond - : '<' '>' - | typeArguments - ; - -nonWildcardTypeArgumentsOrDiamond - : '<' '>' - | nonWildcardTypeArguments - ; - -superSuffix - : arguments - | '.' Identifier arguments? - ; - -explicitGenericInvocationSuffix - : 'super' superSuffix - | Identifier arguments - ; - -arguments - : '(' expressionList? ')' - ; - -// LEXER - -// §3.9 Keywords - -ABSTRACT : 'abstract'; -ASSERT : 'assert'; -BOOLEAN : 'boolean'; -BREAK : 'break'; -BYTE : 'byte'; -CASE : 'case'; -CATCH : 'catch'; -CHAR : 'char'; -CLASS : 'class'; -CONST : 'const'; -CONTINUE : 'continue'; -DEFAULT : 'default'; -DO : 'do'; -DOUBLE : 'double'; -ELSE : 'else'; -ENUM : 'enum'; -EXTENDS : 'extends'; -FINAL : 'final'; -FINALLY : 'finally'; -FLOAT : 'float'; -FOR : 'for'; -IF : 'if'; -GOTO : 'goto'; -IMPLEMENTS : 'implements'; -IMPORT : 'import'; -INSTANCEOF : 'instanceof'; -INT : 'int'; -INTERFACE : 'interface'; -LONG : 'long'; -NATIVE : 'native'; -NEW : 'new'; -PACKAGE : 'package'; -PRIVATE : 'private'; -PROTECTED : 'protected'; -PUBLIC : 'public'; -RETURN : 'return'; -SHORT : 'short'; -STATIC : 'static'; -STRICTFP : 'strictfp'; -SUPER : 'super'; -SWITCH : 'switch'; -SYNCHRONIZED : 'synchronized'; -THIS : 'this'; -THROW : 'throw'; -THROWS : 'throws'; -TRANSIENT : 'transient'; -TRY : 'try'; -VOID : 'void'; -VOLATILE : 'volatile'; -WHILE : 'while'; - -// §3.10.1 Integer Literals - -IntegerLiteral - : DecimalIntegerLiteral - | HexIntegerLiteral - | OctalIntegerLiteral - | BinaryIntegerLiteral - ; - -fragment -DecimalIntegerLiteral - : DecimalNumeral IntegerTypeSuffix? - ; - -fragment -HexIntegerLiteral - : HexNumeral IntegerTypeSuffix? - ; - -fragment -OctalIntegerLiteral - : OctalNumeral IntegerTypeSuffix? - ; - -fragment -BinaryIntegerLiteral - : BinaryNumeral IntegerTypeSuffix? - ; - -fragment -IntegerTypeSuffix - : [lL] - ; - -fragment -DecimalNumeral - : '0' - | NonZeroDigit (Digits? | Underscores Digits) - ; - -fragment -Digits - : Digit (DigitOrUnderscore* Digit)? - ; - -fragment -Digit - : '0' - | NonZeroDigit - ; - -fragment -NonZeroDigit - : [1-9] - ; - -fragment -DigitOrUnderscore - : Digit - | '_' - ; - -fragment -Underscores - : '_'+ - ; - -fragment -HexNumeral - : '0' [xX] HexDigits - ; - -fragment -HexDigits - : HexDigit (HexDigitOrUnderscore* HexDigit)? - ; - -fragment -HexDigit - : [0-9a-fA-F] - ; - -fragment -HexDigitOrUnderscore - : HexDigit - | '_' - ; - -fragment -OctalNumeral - : '0' Underscores? OctalDigits - ; - -fragment -OctalDigits - : OctalDigit (OctalDigitOrUnderscore* OctalDigit)? - ; - -fragment -OctalDigit - : [0-7] - ; - -fragment -OctalDigitOrUnderscore - : OctalDigit - | '_' - ; - -fragment -BinaryNumeral - : '0' [bB] BinaryDigits - ; - -fragment -BinaryDigits - : BinaryDigit (BinaryDigitOrUnderscore* BinaryDigit)? - ; - -fragment -BinaryDigit - : [01] - ; - -fragment -BinaryDigitOrUnderscore - : BinaryDigit - | '_' - ; - -// §3.10.2 Floating-Point Literals - -FloatingPointLiteral - : DecimalFloatingPointLiteral - | HexadecimalFloatingPointLiteral - ; - -fragment -DecimalFloatingPointLiteral - : Digits '.' Digits? ExponentPart? FloatTypeSuffix? - | '.' Digits ExponentPart? FloatTypeSuffix? - | Digits ExponentPart FloatTypeSuffix? - | Digits FloatTypeSuffix - ; - -fragment -ExponentPart - : ExponentIndicator SignedInteger - ; - -fragment -ExponentIndicator - : [eE] - ; - -fragment -SignedInteger - : Sign? Digits - ; - -fragment -Sign - : [+-] - ; - -fragment -FloatTypeSuffix - : [fFdD] - ; - -fragment -HexadecimalFloatingPointLiteral - : HexSignificand BinaryExponent FloatTypeSuffix? - ; - -fragment -HexSignificand - : HexNumeral '.'? - | '0' [xX] HexDigits? '.' HexDigits - ; - -fragment -BinaryExponent - : BinaryExponentIndicator SignedInteger - ; - -fragment -BinaryExponentIndicator - : [pP] - ; - -// §3.10.3 Boolean Literals - -BooleanLiteral - : 'true' - | 'false' - ; - -// §3.10.4 Character Literals - -CharacterLiteral - : '\'' SingleCharacter '\'' - | '\'' EscapeSequence '\'' - ; - -fragment -SingleCharacter - : ~['\\] - ; - -// §3.10.5 String Literals - -StringLiteral - : '"' StringCharacters? '"' - ; - -fragment -StringCharacters - : StringCharacter+ - ; - -fragment -StringCharacter - : ~["\\] - | EscapeSequence - ; - -// §3.10.6 Escape Sequences for Character and String Literals - -fragment -EscapeSequence - : '\\' [btnfr"'\\] - | OctalEscape - | UnicodeEscape - ; - -fragment -OctalEscape - : '\\' OctalDigit - | '\\' OctalDigit OctalDigit - | '\\' ZeroToThree OctalDigit OctalDigit - ; - -fragment -UnicodeEscape - : '\\' 'u' HexDigit HexDigit HexDigit HexDigit - ; - -fragment -ZeroToThree - : [0-3] - ; - -// §3.10.7 The Null Literal - -NullLiteral - : 'null' - ; - -// §3.11 Separators - -LPAREN : '('; -RPAREN : ')'; -LBRACE : '{'; -RBRACE : '}'; -LBRACK : '['; -RBRACK : ']'; -SEMI : ';'; -COMMA : ','; -DOT : '.'; - -// §3.12 Operators - -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 : '>>>='; - -// §3.8 Identifiers (must appear after all keywords in the grammar) - -Identifier - : JavaLetter JavaLetterOrDigit* - ; - -fragment -JavaLetter - : [a-zA-Z$_] // these are the "java letters" below 0xFF - | // covers all characters above 0xFF which are not a surrogate - ~[\u0000-\u00FF\uD800-\uDBFF] - {Character.isJavaIdentifierStart(_input.LA(-1))}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] - {Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? - ; - -fragment -JavaLetterOrDigit - : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0xFF - | // covers all characters above 0xFF which are not a surrogate - ~[\u0000-\u00FF\uD800-\uDBFF] - {Character.isJavaIdentifierPart(_input.LA(-1))}? - | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF - [\uD800-\uDBFF] [\uDC00-\uDFFF] - {Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? - ; - -// -// Additional symbols not defined in the lexical specification -// - -AT : '@'; -ELLIPSIS : '...'; - -// -// Whitespace and comments -// - -WS : [ \t\r\n\u000C]+ -> skip - ; - -COMMENT - : '/*' .*? '*/' -> skip - ; - -LINE_COMMENT - : '//' ~[\r\n]* -> skip - ; diff --git a/i18n-maven-plugin/src/main/antlr4/Java8.g4 b/i18n-maven-plugin/src/main/antlr4/Java8.g4 new file mode 100644 index 0000000..f63f01a --- /dev/null +++ b/i18n-maven-plugin/src/main/antlr4/Java8.g4 @@ -0,0 +1,1779 @@ +/* + * [The "BSD license"] + * Copyright (c) 2014 Terence Parr + * Copyright (c) 2014 Sam Harwell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * A Java 8 grammar for ANTLR 4 derived from the Java Language Specification + * chapter 19. + * + * NOTE: This grammar results in a generated parser that is much slower + * than the Java 7 grammar in the grammars-v4/java directory. This + * one is, however, extremely close to the spec. + * + * You can test with + * + * $ antlr4 Java8.g4 + * $ javac *.java + * $ grun Java8 compilationUnit *.java + * + * Or, +~/antlr/code/grammars-v4/java8 $ java Test . +/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java +/Users/parrt/antlr/code/grammars-v4/java8/./Test.java +Total lexer+parser time 30844ms. + */ +grammar Java8; + +/* + * Productions from §3 (Lexical Structure) + */ + +literal + : IntegerLiteral + | FloatingPointLiteral + | BooleanLiteral + | CharacterLiteral + | StringLiteral + | NullLiteral + ; + +/* + * Productions from §4 (Types, Values, and Variables) + */ + +type + : primitiveType + | referenceType + ; + +primitiveType + : annotation* numericType + | annotation* 'boolean' + ; + +numericType + : integralType + | floatingPointType + ; + +integralType + : 'byte' + | 'short' + | 'int' + | 'long' + | 'char' + ; + +floatingPointType + : 'float' + | 'double' + ; + +referenceType + : classOrInterfaceType + | typeVariable + | arrayType + ; + +classOrInterfaceType + : ( classType_lfno_classOrInterfaceType + | interfaceType_lfno_classOrInterfaceType + ) + ( classType_lf_classOrInterfaceType + | interfaceType_lf_classOrInterfaceType + )* + ; + +classType + : annotation* Identifier typeArguments? + | classOrInterfaceType '.' annotation* Identifier typeArguments? + ; + +classType_lf_classOrInterfaceType + : '.' annotation* Identifier typeArguments? + ; + +classType_lfno_classOrInterfaceType + : annotation* Identifier typeArguments? + ; + +interfaceType + : classType + ; + +interfaceType_lf_classOrInterfaceType + : classType_lf_classOrInterfaceType + ; + +interfaceType_lfno_classOrInterfaceType + : classType_lfno_classOrInterfaceType + ; + +typeVariable + : annotation* Identifier + ; + +arrayType + : primitiveType dims + | classOrInterfaceType dims + | typeVariable dims + ; + +dims + : annotation* '[' ']' (annotation* '[' ']')* + ; + +typeParameter + : typeParameterModifier* Identifier typeBound? + ; + +typeParameterModifier + : annotation + ; + +typeBound + : 'extends' typeVariable + | 'extends' classOrInterfaceType additionalBound* + ; + +additionalBound + : '&' interfaceType + ; + +typeArguments + : '<' typeArgumentList '>' + ; + +typeArgumentList + : typeArgument (',' typeArgument)* + ; + +typeArgument + : referenceType + | wildcard + ; + +wildcard + : annotation* '?' wildcardBounds? + ; + +wildcardBounds + : 'extends' referenceType + | 'super' referenceType + ; + +/* + * Productions from §6 (Names) + */ + +packageName + : Identifier + | packageName '.' Identifier + ; + +typeName + : Identifier + | packageOrTypeName '.' Identifier + ; + +packageOrTypeName + : Identifier + | packageOrTypeName '.' Identifier + ; + +expressionName + : Identifier + | ambiguousName '.' Identifier + ; + +methodName + : Identifier + ; + +ambiguousName + : Identifier + | ambiguousName '.' Identifier + ; + +/* + * Productions from §7 (Packages) + */ + +compilationUnit + : packageDeclaration? importDeclaration* typeDeclaration* EOF + ; + +packageDeclaration + : packageModifier* 'package' Identifier ('.' Identifier)* ';' + ; + +packageModifier + : annotation + ; + +importDeclaration + : singleTypeImportDeclaration + | typeImportOnDemandDeclaration + | singleStaticImportDeclaration + | staticImportOnDemandDeclaration + ; + +singleTypeImportDeclaration + : 'import' typeName ';' + ; + +typeImportOnDemandDeclaration + : 'import' packageOrTypeName '.' '*' ';' + ; + +singleStaticImportDeclaration + : 'import' 'static' typeName '.' Identifier ';' + ; + +staticImportOnDemandDeclaration + : 'import' 'static' typeName '.' '*' ';' + ; + +typeDeclaration + : classDeclaration + | interfaceDeclaration + | ';' + ; + +/* + * Productions from §8 (Classes) + */ + +classDeclaration + : normalClassDeclaration + | enumDeclaration + ; + +normalClassDeclaration + : classModifier* 'class' Identifier typeParameters? superclass? superinterfaces? classBody + ; + +classModifier + : annotation + | 'public' + | 'protected' + | 'private' + | 'abstract' + | 'static' + | 'final' + | 'strictfp' + ; + +typeParameters + : '<' typeParameterList '>' + ; + +typeParameterList + : typeParameter (',' typeParameter)* + ; + +superclass + : 'extends' classType + ; + +superinterfaces + : 'implements' interfaceTypeList + ; + +interfaceTypeList + : interfaceType (',' interfaceType)* + ; + +classBody + : '{' classBodyDeclaration* '}' + ; + +classBodyDeclaration + : classMemberDeclaration + | instanceInitializer + | staticInitializer + | constructorDeclaration + ; + +classMemberDeclaration + : fieldDeclaration + | methodDeclaration + | classDeclaration + | interfaceDeclaration + | ';' + ; + +fieldDeclaration + : fieldModifier* unannType variableDeclaratorList ';' + ; + +fieldModifier + : annotation + | 'public' + | 'protected' + | 'private' + | 'static' + | 'final' + | 'transient' + | 'volatile' + ; + +variableDeclaratorList + : variableDeclarator (',' variableDeclarator)* + ; + +variableDeclarator + : variableDeclaratorId ('=' variableInitializer)? + ; + +variableDeclaratorId + : Identifier dims? + ; + +variableInitializer + : expression + | arrayInitializer + ; + +unannType + : unannPrimitiveType + | unannReferenceType + ; + +unannPrimitiveType + : numericType + | 'boolean' + ; + +unannReferenceType + : unannClassOrInterfaceType + | unannTypeVariable + | unannArrayType + ; + +unannClassOrInterfaceType + : ( unannClassType_lfno_unannClassOrInterfaceType + | unannInterfaceType_lfno_unannClassOrInterfaceType + ) + ( unannClassType_lf_unannClassOrInterfaceType + | unannInterfaceType_lf_unannClassOrInterfaceType + )* + ; + +unannClassType + : Identifier typeArguments? + | unannClassOrInterfaceType '.' annotation* Identifier typeArguments? + ; + +unannClassType_lf_unannClassOrInterfaceType + : '.' annotation* Identifier typeArguments? + ; + +unannClassType_lfno_unannClassOrInterfaceType + : Identifier typeArguments? + ; + +unannInterfaceType + : unannClassType + ; + +unannInterfaceType_lf_unannClassOrInterfaceType + : unannClassType_lf_unannClassOrInterfaceType + ; + +unannInterfaceType_lfno_unannClassOrInterfaceType + : unannClassType_lfno_unannClassOrInterfaceType + ; + +unannTypeVariable + : Identifier + ; + +unannArrayType + : unannPrimitiveType dims + | unannClassOrInterfaceType dims + | unannTypeVariable dims + ; + +methodDeclaration + : methodModifier* methodHeader methodBody + ; + +methodModifier + : annotation + | 'public' + | 'protected' + | 'private' + | 'abstract' + | 'static' + | 'final' + | 'synchronized' + | 'native' + | 'strictfp' + ; + +methodHeader + : result methodDeclarator throws_? + | typeParameters annotation* result methodDeclarator throws_? + ; + +result + : unannType + | 'void' + ; + +methodDeclarator + : Identifier '(' formalParameterList? ')' dims? + ; + +formalParameterList + : formalParameters ',' lastFormalParameter + | lastFormalParameter + ; + +formalParameters + : formalParameter (',' formalParameter)* + | receiverParameter (',' formalParameter)* + ; + +formalParameter + : variableModifier* unannType variableDeclaratorId + ; + +variableModifier + : annotation + | 'final' + ; + +lastFormalParameter + : variableModifier* unannType annotation* '...' variableDeclaratorId + | formalParameter + ; + +receiverParameter + : annotation* unannType (Identifier '.')? 'this' + ; + +throws_ + : 'throws' exceptionTypeList + ; + +exceptionTypeList + : exceptionType (',' exceptionType)* + ; + +exceptionType + : classType + | typeVariable + ; + +methodBody + : block + | ';' + ; + +instanceInitializer + : block + ; + +staticInitializer + : 'static' block + ; + +constructorDeclaration + : constructorModifier* constructorDeclarator throws_? constructorBody + ; + +constructorModifier + : annotation + | 'public' + | 'protected' + | 'private' + ; + +constructorDeclarator + : typeParameters? simpleTypeName '(' formalParameterList? ')' + ; + +simpleTypeName + : Identifier + ; + +constructorBody + : '{' explicitConstructorInvocation? blockStatements? '}' + ; + +explicitConstructorInvocation + : typeArguments? 'this' '(' argumentList? ')' ';' + | typeArguments? 'super' '(' argumentList? ')' ';' + | expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';' + | primary '.' typeArguments? 'super' '(' argumentList? ')' ';' + ; + +enumDeclaration + : classModifier* 'enum' Identifier superinterfaces? enumBody + ; + +enumBody + : '{' enumConstantList? ','? enumBodyDeclarations? '}' + ; + +enumConstantList + : enumConstant (',' enumConstant)* + ; + +enumConstant + : enumConstantModifier* Identifier ('(' argumentList? ')')? classBody? + ; + +enumConstantModifier + : annotation + ; + +enumBodyDeclarations + : ';' classBodyDeclaration* + ; + +/* + * Productions from §9 (Interfaces) + */ + +interfaceDeclaration + : normalInterfaceDeclaration + | annotationTypeDeclaration + ; + +normalInterfaceDeclaration + : interfaceModifier* 'interface' Identifier typeParameters? extendsInterfaces? interfaceBody + ; + +interfaceModifier + : annotation + | 'public' + | 'protected' + | 'private' + | 'abstract' + | 'static' + | 'strictfp' + ; + +extendsInterfaces + : 'extends' interfaceTypeList + ; + +interfaceBody + : '{' interfaceMemberDeclaration* '}' + ; + +interfaceMemberDeclaration + : constantDeclaration + | interfaceMethodDeclaration + | classDeclaration + | interfaceDeclaration + | ';' + ; + +constantDeclaration + : constantModifier* unannType variableDeclaratorList ';' + ; + +constantModifier + : annotation + | 'public' + | 'static' + | 'final' + ; + +interfaceMethodDeclaration + : interfaceMethodModifier* methodHeader methodBody + ; + +interfaceMethodModifier + : annotation + | 'public' + | 'abstract' + | 'default' + | 'static' + | 'strictfp' + ; + +annotationTypeDeclaration + : interfaceModifier* '@' 'interface' Identifier annotationTypeBody + ; + +annotationTypeBody + : '{' annotationTypeMemberDeclaration* '}' + ; + +annotationTypeMemberDeclaration + : annotationTypeElementDeclaration + | constantDeclaration + | classDeclaration + | interfaceDeclaration + | ';' + ; + +annotationTypeElementDeclaration + : annotationTypeElementModifier* unannType Identifier '(' ')' dims? defaultValue? ';' + ; + +annotationTypeElementModifier + : annotation + | 'public' + | 'abstract' + ; + +defaultValue + : 'default' elementValue + ; + +annotation + : normalAnnotation + | markerAnnotation + | singleElementAnnotation + ; + +normalAnnotation + : '@' typeName '(' elementValuePairList? ')' + ; + +elementValuePairList + : elementValuePair (',' elementValuePair)* + ; + +elementValuePair + : Identifier '=' elementValue + ; + +elementValue + : conditionalExpression + | elementValueArrayInitializer + | annotation + ; + +elementValueArrayInitializer + : '{' elementValueList? ','? '}' + ; + +elementValueList + : elementValue (',' elementValue)* + ; + +markerAnnotation + : '@' typeName + ; + +singleElementAnnotation + : '@' typeName '(' elementValue ')' + ; + +/* + * Productions from §10 (Arrays) + */ + +arrayInitializer + : '{' variableInitializerList? ','? '}' + ; + +variableInitializerList + : variableInitializer (',' variableInitializer)* + ; + +/* + * Productions from §14 (Blocks and Statements) + */ + +block + : '{' blockStatements? '}' + ; + +blockStatements + : blockStatement blockStatement* + ; + +blockStatement + : localVariableDeclarationStatement + | classDeclaration + | statement + ; + +localVariableDeclarationStatement + : localVariableDeclaration ';' + ; + +localVariableDeclaration + : variableModifier* unannType variableDeclaratorList + ; + +statement + : statementWithoutTrailingSubstatement + | labeledStatement + | ifThenStatement + | ifThenElseStatement + | whileStatement + | forStatement + ; + +statementNoShortIf + : statementWithoutTrailingSubstatement + | labeledStatementNoShortIf + | ifThenElseStatementNoShortIf + | whileStatementNoShortIf + | forStatementNoShortIf + ; + +statementWithoutTrailingSubstatement + : block + | emptyStatement + | expressionStatement + | assertStatement + | switchStatement + | doStatement + | breakStatement + | continueStatement + | returnStatement + | synchronizedStatement + | throwStatement + | tryStatement + ; + +emptyStatement + : ';' + ; + +labeledStatement + : Identifier ':' statement + ; + +labeledStatementNoShortIf + : Identifier ':' statementNoShortIf + ; + +expressionStatement + : statementExpression ';' + ; + +statementExpression + : assignment + | preIncrementExpression + | preDecrementExpression + | postIncrementExpression + | postDecrementExpression + | methodInvocation + | classInstanceCreationExpression + ; + +ifThenStatement + : 'if' '(' expression ')' statement + ; + +ifThenElseStatement + : 'if' '(' expression ')' statementNoShortIf 'else' statement + ; + +ifThenElseStatementNoShortIf + : 'if' '(' expression ')' statementNoShortIf 'else' statementNoShortIf + ; + +assertStatement + : 'assert' expression ';' + | 'assert' expression ':' expression ';' + ; + +switchStatement + : 'switch' '(' expression ')' switchBlock + ; + +switchBlock + : '{' switchBlockStatementGroup* switchLabel* '}' + ; + +switchBlockStatementGroup + : switchLabels blockStatements + ; + +switchLabels + : switchLabel switchLabel* + ; + +switchLabel + : 'case' constantExpression ':' + | 'case' enumConstantName ':' + | 'default' ':' + ; + +enumConstantName + : Identifier + ; + +whileStatement + : 'while' '(' expression ')' statement + ; + +whileStatementNoShortIf + : 'while' '(' expression ')' statementNoShortIf + ; + +doStatement + : 'do' statement 'while' '(' expression ')' ';' + ; + +forStatement + : basicForStatement + | enhancedForStatement + ; + +forStatementNoShortIf + : basicForStatementNoShortIf + | enhancedForStatementNoShortIf + ; + +basicForStatement + : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statement + ; + +basicForStatementNoShortIf + : 'for' '(' forInit? ';' expression? ';' forUpdate? ')' statementNoShortIf + ; + +forInit + : statementExpressionList + | localVariableDeclaration + ; + +forUpdate + : statementExpressionList + ; + +statementExpressionList + : statementExpression (',' statementExpression)* + ; + +enhancedForStatement + : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statement + ; + +enhancedForStatementNoShortIf + : 'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statementNoShortIf + ; + +breakStatement + : 'break' Identifier? ';' + ; + +continueStatement + : 'continue' Identifier? ';' + ; + +returnStatement + : 'return' expression? ';' + ; + +throwStatement + : 'throw' expression ';' + ; + +synchronizedStatement + : 'synchronized' '(' expression ')' block + ; + +tryStatement + : 'try' block catches + | 'try' block catches? finally_ + | tryWithResourcesStatement + ; + +catches + : catchClause catchClause* + ; + +catchClause + : 'catch' '(' catchFormalParameter ')' block + ; + +catchFormalParameter + : variableModifier* catchType variableDeclaratorId + ; + +catchType + : unannClassType ('|' classType)* + ; + +finally_ + : 'finally' block + ; + +tryWithResourcesStatement + : 'try' resourceSpecification block catches? finally_? + ; + +resourceSpecification + : '(' resourceList ';'? ')' + ; + +resourceList + : resource (';' resource)* + ; + +resource + : variableModifier* unannType variableDeclaratorId '=' expression + ; + +/* + * Productions from §15 (Expressions) + */ + +primary + : ( primaryNoNewArray_lfno_primary + | arrayCreationExpression + ) + ( primaryNoNewArray_lf_primary + )* + ; + +primaryNoNewArray + : literal + | typeName ('[' ']')* '.' 'class' + | 'void' '.' 'class' + | 'this' + | typeName '.' 'this' + | '(' expression ')' + | classInstanceCreationExpression + | fieldAccess + | arrayAccess + | methodInvocation + | methodReference + ; + +primaryNoNewArray_lf_arrayAccess + : + ; + +primaryNoNewArray_lfno_arrayAccess + : literal + | typeName ('[' ']')* '.' 'class' + | 'void' '.' 'class' + | 'this' + | typeName '.' 'this' + | '(' expression ')' + | classInstanceCreationExpression + | fieldAccess + | methodInvocation + | methodReference + ; + +primaryNoNewArray_lf_primary + : classInstanceCreationExpression_lf_primary + | fieldAccess_lf_primary + | arrayAccess_lf_primary + | methodInvocation_lf_primary + | methodReference_lf_primary + ; + +primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary + : + ; + +primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary + : classInstanceCreationExpression_lf_primary + | fieldAccess_lf_primary + | methodInvocation_lf_primary + | methodReference_lf_primary + ; + +primaryNoNewArray_lfno_primary + : literal + | typeName ('[' ']')* '.' 'class' + | unannPrimitiveType ('[' ']')* '.' 'class' + | 'void' '.' 'class' + | 'this' + | typeName '.' 'this' + | '(' expression ')' + | classInstanceCreationExpression_lfno_primary + | fieldAccess_lfno_primary + | arrayAccess_lfno_primary + | methodInvocation_lfno_primary + | methodReference_lfno_primary + ; + +primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary + : + ; + +primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary + : literal + | typeName ('[' ']')* '.' 'class' + | unannPrimitiveType ('[' ']')* '.' 'class' + | 'void' '.' 'class' + | 'this' + | typeName '.' 'this' + | '(' expression ')' + | classInstanceCreationExpression_lfno_primary + | fieldAccess_lfno_primary + | methodInvocation_lfno_primary + | methodReference_lfno_primary + ; + +classInstanceCreationExpression + : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + | primary '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + ; + +classInstanceCreationExpression_lf_primary + : '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + ; + +classInstanceCreationExpression_lfno_primary + : 'new' typeArguments? annotation* Identifier ('.' annotation* Identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + | expressionName '.' 'new' typeArguments? annotation* Identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody? + ; + +typeArgumentsOrDiamond + : typeArguments + | '<' '>' + ; + +fieldAccess + : primary '.' Identifier + | 'super' '.' Identifier + | typeName '.' 'super' '.' Identifier + ; + +fieldAccess_lf_primary + : '.' Identifier + ; + +fieldAccess_lfno_primary + : 'super' '.' Identifier + | typeName '.' 'super' '.' Identifier + ; + +arrayAccess + : ( expressionName '[' expression ']' + | primaryNoNewArray_lfno_arrayAccess '[' expression ']' + ) + ( primaryNoNewArray_lf_arrayAccess '[' expression ']' + )* + ; + +arrayAccess_lf_primary + : ( primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary '[' expression ']' + ) + ( primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary '[' expression ']' + )* + ; + +arrayAccess_lfno_primary + : ( expressionName '[' expression ']' + | primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary '[' expression ']' + ) + ( primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary '[' expression ']' + )* + ; + +methodInvocation + : methodName '(' argumentList? ')' + | typeName '.' typeArguments? Identifier '(' argumentList? ')' + | expressionName '.' typeArguments? Identifier '(' argumentList? ')' + | primary '.' typeArguments? Identifier '(' argumentList? ')' + | 'super' '.' typeArguments? Identifier '(' argumentList? ')' + | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' + ; + +methodInvocation_lf_primary + : '.' typeArguments? Identifier '(' argumentList? ')' + ; + +methodInvocation_lfno_primary + : methodName '(' argumentList? ')' + | typeName '.' typeArguments? Identifier '(' argumentList? ')' + | expressionName '.' typeArguments? Identifier '(' argumentList? ')' + | 'super' '.' typeArguments? Identifier '(' argumentList? ')' + | typeName '.' 'super' '.' typeArguments? Identifier '(' argumentList? ')' + ; + +argumentList + : expression (',' expression)* + ; + +methodReference + : expressionName '::' typeArguments? Identifier + | referenceType '::' typeArguments? Identifier + | primary '::' typeArguments? Identifier + | 'super' '::' typeArguments? Identifier + | typeName '.' 'super' '::' typeArguments? Identifier + | classType '::' typeArguments? 'new' + | arrayType '::' 'new' + ; + +methodReference_lf_primary + : '::' typeArguments? Identifier + ; + +methodReference_lfno_primary + : expressionName '::' typeArguments? Identifier + | referenceType '::' typeArguments? Identifier + | 'super' '::' typeArguments? Identifier + | typeName '.' 'super' '::' typeArguments? Identifier + | classType '::' typeArguments? 'new' + | arrayType '::' 'new' + ; + +arrayCreationExpression + : 'new' primitiveType dimExprs dims? + | 'new' classOrInterfaceType dimExprs dims? + | 'new' primitiveType dims arrayInitializer + | 'new' classOrInterfaceType dims arrayInitializer + ; + +dimExprs + : dimExpr dimExpr* + ; + +dimExpr + : annotation* '[' expression ']' + ; + +constantExpression + : expression + ; + +expression + : lambdaExpression + | assignmentExpression + ; + +lambdaExpression + : lambdaParameters '->' lambdaBody + ; + +lambdaParameters + : Identifier + | '(' formalParameterList? ')' + | '(' inferredFormalParameterList ')' + ; + +inferredFormalParameterList + : Identifier (',' Identifier)* + ; + +lambdaBody + : expression + | block + ; + +assignmentExpression + : conditionalExpression + | assignment + ; + +assignment + : leftHandSide assignmentOperator expression + ; + +leftHandSide + : expressionName + | fieldAccess + | arrayAccess + ; + +assignmentOperator + : '=' + | '*=' + | '/=' + | '%=' + | '+=' + | '-=' + | '<<=' + | '>>=' + | '>>>=' + | '&=' + | '^=' + | '|=' + ; + +conditionalExpression + : conditionalOrExpression + | conditionalOrExpression '?' expression ':' conditionalExpression + ; + +conditionalOrExpression + : conditionalAndExpression + | conditionalOrExpression '||' conditionalAndExpression + ; + +conditionalAndExpression + : inclusiveOrExpression + | conditionalAndExpression '&&' inclusiveOrExpression + ; + +inclusiveOrExpression + : exclusiveOrExpression + | inclusiveOrExpression '|' exclusiveOrExpression + ; + +exclusiveOrExpression + : andExpression + | exclusiveOrExpression '^' andExpression + ; + +andExpression + : equalityExpression + | andExpression '&' equalityExpression + ; + +equalityExpression + : relationalExpression + | equalityExpression '==' relationalExpression + | equalityExpression '!=' relationalExpression + ; + +relationalExpression + : shiftExpression + | relationalExpression '<' shiftExpression + | relationalExpression '>' shiftExpression + | relationalExpression '<=' shiftExpression + | relationalExpression '>=' shiftExpression + | relationalExpression 'instanceof' referenceType + ; + +shiftExpression + : additiveExpression + | shiftExpression '<' '<' additiveExpression + | shiftExpression '>' '>' additiveExpression + | shiftExpression '>' '>' '>' additiveExpression + ; + +additiveExpression + : multiplicativeExpression + | additiveExpression '+' multiplicativeExpression + | additiveExpression '-' multiplicativeExpression + ; + +multiplicativeExpression + : unaryExpression + | multiplicativeExpression '*' unaryExpression + | multiplicativeExpression '/' unaryExpression + | multiplicativeExpression '%' unaryExpression + ; + +unaryExpression + : preIncrementExpression + | preDecrementExpression + | '+' unaryExpression + | '-' unaryExpression + | unaryExpressionNotPlusMinus + ; + +preIncrementExpression + : '++' unaryExpression + ; + +preDecrementExpression + : '--' unaryExpression + ; + +unaryExpressionNotPlusMinus + : postfixExpression + | '~' unaryExpression + | '!' unaryExpression + | castExpression + ; + +postfixExpression + : ( primary + | expressionName + ) + ( postIncrementExpression_lf_postfixExpression + | postDecrementExpression_lf_postfixExpression + )* + ; + +postIncrementExpression + : postfixExpression '++' + ; + +postIncrementExpression_lf_postfixExpression + : '++' + ; + +postDecrementExpression + : postfixExpression '--' + ; + +postDecrementExpression_lf_postfixExpression + : '--' + ; + +castExpression + : '(' primitiveType ')' unaryExpression + | '(' referenceType additionalBound* ')' unaryExpressionNotPlusMinus + | '(' referenceType additionalBound* ')' lambdaExpression + ; + +// LEXER + +// §3.9 Keywords + +ABSTRACT : 'abstract'; +ASSERT : 'assert'; +BOOLEAN : 'boolean'; +BREAK : 'break'; +BYTE : 'byte'; +CASE : 'case'; +CATCH : 'catch'; +CHAR : 'char'; +CLASS : 'class'; +CONST : 'const'; +CONTINUE : 'continue'; +DEFAULT : 'default'; +DO : 'do'; +DOUBLE : 'double'; +ELSE : 'else'; +ENUM : 'enum'; +EXTENDS : 'extends'; +FINAL : 'final'; +FINALLY : 'finally'; +FLOAT : 'float'; +FOR : 'for'; +IF : 'if'; +GOTO : 'goto'; +IMPLEMENTS : 'implements'; +IMPORT : 'import'; +INSTANCEOF : 'instanceof'; +INT : 'int'; +INTERFACE : 'interface'; +LONG : 'long'; +NATIVE : 'native'; +NEW : 'new'; +PACKAGE : 'package'; +PRIVATE : 'private'; +PROTECTED : 'protected'; +PUBLIC : 'public'; +RETURN : 'return'; +SHORT : 'short'; +STATIC : 'static'; +STRICTFP : 'strictfp'; +SUPER : 'super'; +SWITCH : 'switch'; +SYNCHRONIZED : 'synchronized'; +THIS : 'this'; +THROW : 'throw'; +THROWS : 'throws'; +TRANSIENT : 'transient'; +TRY : 'try'; +VOID : 'void'; +VOLATILE : 'volatile'; +WHILE : 'while'; + +// §3.10.1 Integer Literals + +IntegerLiteral + : DecimalIntegerLiteral + | HexIntegerLiteral + | OctalIntegerLiteral + | BinaryIntegerLiteral + ; + +fragment +DecimalIntegerLiteral + : DecimalNumeral IntegerTypeSuffix? + ; + +fragment +HexIntegerLiteral + : HexNumeral IntegerTypeSuffix? + ; + +fragment +OctalIntegerLiteral + : OctalNumeral IntegerTypeSuffix? + ; + +fragment +BinaryIntegerLiteral + : BinaryNumeral IntegerTypeSuffix? + ; + +fragment +IntegerTypeSuffix + : [lL] + ; + +fragment +DecimalNumeral + : '0' + | NonZeroDigit (Digits? | Underscores Digits) + ; + +fragment +Digits + : Digit (DigitsAndUnderscores? Digit)? + ; + +fragment +Digit + : '0' + | NonZeroDigit + ; + +fragment +NonZeroDigit + : [1-9] + ; + +fragment +DigitsAndUnderscores + : DigitOrUnderscore+ + ; + +fragment +DigitOrUnderscore + : Digit + | '_' + ; + +fragment +Underscores + : '_'+ + ; + +fragment +HexNumeral + : '0' [xX] HexDigits + ; + +fragment +HexDigits + : HexDigit (HexDigitsAndUnderscores? HexDigit)? + ; + +fragment +HexDigit + : [0-9a-fA-F] + ; + +fragment +HexDigitsAndUnderscores + : HexDigitOrUnderscore+ + ; + +fragment +HexDigitOrUnderscore + : HexDigit + | '_' + ; + +fragment +OctalNumeral + : '0' Underscores? OctalDigits + ; + +fragment +OctalDigits + : OctalDigit (OctalDigitsAndUnderscores? OctalDigit)? + ; + +fragment +OctalDigit + : [0-7] + ; + +fragment +OctalDigitsAndUnderscores + : OctalDigitOrUnderscore+ + ; + +fragment +OctalDigitOrUnderscore + : OctalDigit + | '_' + ; + +fragment +BinaryNumeral + : '0' [bB] BinaryDigits + ; + +fragment +BinaryDigits + : BinaryDigit (BinaryDigitsAndUnderscores? BinaryDigit)? + ; + +fragment +BinaryDigit + : [01] + ; + +fragment +BinaryDigitsAndUnderscores + : BinaryDigitOrUnderscore+ + ; + +fragment +BinaryDigitOrUnderscore + : BinaryDigit + | '_' + ; + +// §3.10.2 Floating-Point Literals + +FloatingPointLiteral + : DecimalFloatingPointLiteral + | HexadecimalFloatingPointLiteral + ; + +fragment +DecimalFloatingPointLiteral + : Digits '.' Digits? ExponentPart? FloatTypeSuffix? + | '.' Digits ExponentPart? FloatTypeSuffix? + | Digits ExponentPart FloatTypeSuffix? + | Digits FloatTypeSuffix + ; + +fragment +ExponentPart + : ExponentIndicator SignedInteger + ; + +fragment +ExponentIndicator + : [eE] + ; + +fragment +SignedInteger + : Sign? Digits + ; + +fragment +Sign + : [+-] + ; + +fragment +FloatTypeSuffix + : [fFdD] + ; + +fragment +HexadecimalFloatingPointLiteral + : HexSignificand BinaryExponent FloatTypeSuffix? + ; + +fragment +HexSignificand + : HexNumeral '.'? + | '0' [xX] HexDigits? '.' HexDigits + ; + +fragment +BinaryExponent + : BinaryExponentIndicator SignedInteger + ; + +fragment +BinaryExponentIndicator + : [pP] + ; + +// §3.10.3 Boolean Literals + +BooleanLiteral + : 'true' + | 'false' + ; + +// §3.10.4 Character Literals + +CharacterLiteral + : '\'' SingleCharacter '\'' + | '\'' EscapeSequence '\'' + ; + +fragment +SingleCharacter + : ~['\\] + ; + +// §3.10.5 String Literals + +StringLiteral + : '"' StringCharacters? '"' + ; + +fragment +StringCharacters + : StringCharacter+ + ; + +fragment +StringCharacter + : ~["\\] + | EscapeSequence + ; + +// §3.10.6 Escape Sequences for Character and String Literals + +fragment +EscapeSequence + : '\\' [btnfr"'\\] + | OctalEscape + | UnicodeEscape // This is not in the spec but prevents having to preprocess the input + ; + +fragment +OctalEscape + : '\\' OctalDigit + | '\\' OctalDigit OctalDigit + | '\\' ZeroToThree OctalDigit OctalDigit + ; + +fragment +ZeroToThree + : [0-3] + ; + +// This is not in the spec but prevents having to preprocess the input +fragment +UnicodeEscape + : '\\' 'u' HexDigit HexDigit HexDigit HexDigit + ; + +// §3.10.7 The Null Literal + +NullLiteral + : 'null' + ; + +// §3.11 Separators + +LPAREN : '('; +RPAREN : ')'; +LBRACE : '{'; +RBRACE : '}'; +LBRACK : '['; +RBRACK : ']'; +SEMI : ';'; +COMMA : ','; +DOT : '.'; + +// §3.12 Operators + +ASSIGN : '='; +GT : '>'; +LT : '<'; +BANG : '!'; +TILDE : '~'; +QUESTION : '?'; +COLON : ':'; +EQUAL : '=='; +LE : '<='; +GE : '>='; +NOTEQUAL : '!='; +AND : '&&'; +OR : '||'; +INC : '++'; +DEC : '--'; +ADD : '+'; +SUB : '-'; +MUL : '*'; +DIV : '/'; +BITAND : '&'; +BITOR : '|'; +CARET : '^'; +MOD : '%'; +ARROW : '->'; +COLONCOLON : '::'; + +ADD_ASSIGN : '+='; +SUB_ASSIGN : '-='; +MUL_ASSIGN : '*='; +DIV_ASSIGN : '/='; +AND_ASSIGN : '&='; +OR_ASSIGN : '|='; +XOR_ASSIGN : '^='; +MOD_ASSIGN : '%='; +LSHIFT_ASSIGN : '<<='; +RSHIFT_ASSIGN : '>>='; +URSHIFT_ASSIGN : '>>>='; + +// §3.8 Identifiers (must appear after all keywords in the grammar) + +Identifier + : JavaLetter JavaLetterOrDigit* + ; + +fragment +JavaLetter + : [a-zA-Z$_] // these are the "java letters" below 0x7F + | // covers all characters above 0x7F which are not a surrogate + ~[\u0000-\u007F\uD800-\uDBFF] + {Character.isJavaIdentifierStart(_input.LA(-1))}? + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + {Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? + ; + +fragment +JavaLetterOrDigit + : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0x7F + | // covers all characters above 0x7F which are not a surrogate + ~[\u0000-\u007F\uD800-\uDBFF] + {Character.isJavaIdentifierPart(_input.LA(-1))}? + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + {Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? + ; + +// +// Additional symbols not defined in the lexical specification +// + +AT : '@'; +ELLIPSIS : '...'; + +// +// Whitespace and comments +// + +WS : [ \t\r\n\u000C]+ -> skip + ; + +COMMENT + : '/*' .*? '*/' -> skip + ; + +LINE_COMMENT + : '//' ~[\r\n]* -> skip + ; diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens b/i18n-maven-plugin/src/main/antlr4/Java8.tokens similarity index 81% copy from i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens copy to i18n-maven-plugin/src/main/antlr4/Java8.tokens index 22c63e5..52ef1ee 100644 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens +++ b/i18n-maven-plugin/src/main/antlr4/Java8.tokens @@ -1,201 +1,205 @@ -PACKAGE=32 -LT=68 -WHILE=50 -MOD=88 -CONST=10 -MOD_ASSIGN=96 +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 CASE=6 -NEW=31 +CATCH=7 CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 DO=13 -DIV_ASSIGN=92 -BREAK=4 -Identifier=100 -NOTEQUAL=76 -MUL_ASSIGN=91 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 FINAL=18 -RPAREN=58 -INC=79 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 IMPORT=25 -CARET=87 -THIS=43 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 RETURN=36 -DOUBLE=14 -VOID=48 -SUPER=40 -GOTO=23 -COMMENT=104 -RBRACK=62 -LSHIFT_ASSIGN=97 -GE=75 -RBRACE=60 -LINE_COMMENT=105 +SHORT=37 STATIC=38 -PRIVATE=33 -ADD_ASSIGN=89 -SWITCH=41 STRICTFP=39 -ELSE=15 -ELLIPSIS=102 -NATIVE=30 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 THROWS=45 -INT=27 -ASSERT=2 -MUL=83 +TRANSIENT=46 TRY=47 -WS=103 -BITOR=86 +VOID=48 +VOLATILE=49 +WHILE=50 +IntegerLiteral=51 FloatingPointLiteral=52 -OR=78 -GT=67 -CATCH=7 -THROW=44 BooleanLiteral=53 -PROTECTED=34 -DEC=80 -CLASS=9 -NullLiteral=56 -LBRACK=61 CharacterLiteral=54 -LBRACE=59 -FOR=21 -SUB=82 -FLOAT=20 -ABSTRACT=1 -AND=77 -AND_ASSIGN=93 -BITAND=85 +StringLiteral=55 +NullLiteral=56 LPAREN=57 -IF=22 -AT=101 -SYNCHRONIZED=42 -BOOLEAN=3 -IMPLEMENTS=24 -CONTINUE=11 +RPAREN=58 +LBRACE=59 +RBRACE=60 +LBRACK=61 +RBRACK=62 +SEMI=63 COMMA=64 -TRANSIENT=46 -EQUAL=73 -XOR_ASSIGN=95 -TILDE=70 DOT=65 -ADD=81 -BYTE=5 -VOLATILE=49 -DEFAULT=12 -SHORT=37 +ASSIGN=66 +GT=67 +LT=68 BANG=69 -INSTANCEOF=26 -RSHIFT_ASSIGN=98 -SEMI=63 -StringLiteral=55 -COLON=72 -OR_ASSIGN=94 -ENUM=16 +TILDE=70 QUESTION=71 -FINALLY=19 -URSHIFT_ASSIGN=99 -ASSIGN=66 -INTERFACE=28 -IntegerLiteral=51 -DIV=84 -LONG=29 -PUBLIC=35 -EXTENDS=17 -SUB_ASSIGN=90 +COLON=72 +EQUAL=73 LE=74 -'instanceof'=26 -'>='=75 -'~'=70 -'/'=84 -'=='=73 -'/='=92 -'switch'=41 -'%='=96 -'implements'=24 -'>'=67 -'||'=78 -'this'=43 -'&&'=77 -';'=63 -'volatile'=49 -'return'=36 -'for'=21 -'protected'=34 -'+'=81 -'.'=65 -'^'=87 +GE=75 +NOTEQUAL=76 +AND=77 +OR=78 +INC=79 +DEC=80 +ADD=81 +SUB=82 +MUL=83 +DIV=84 +BITAND=85 +BITOR=86 +CARET=87 +MOD=88 +ARROW=89 +COLONCOLON=90 +ADD_ASSIGN=91 +SUB_ASSIGN=92 +MUL_ASSIGN=93 +DIV_ASSIGN=94 +AND_ASSIGN=95 +OR_ASSIGN=96 +XOR_ASSIGN=97 +MOD_ASSIGN=98 +LSHIFT_ASSIGN=99 +RSHIFT_ASSIGN=100 +URSHIFT_ASSIGN=101 +Identifier=102 +AT=103 +ELLIPSIS=104 +WS=105 +COMMENT=106 +LINE_COMMENT=107 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 'byte'=5 -'import'=25 -'++'=79 -'static'=38 -'else'=15 +'case'=6 'catch'=7 -'final'=18 -'^='=95 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 'extends'=17 -'+='=89 +'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 -'break'=4 -'...'=102 -'{'=59 -'>>='=98 +'new'=31 'package'=32 -'>>>='=99 -'void'=48 -'?'=71 -'try'=47 'private'=33 -'int'=27 -'&='=93 -'if'=22 -':'=72 -'('=57 -'-'=82 -'while'=50 -','=64 -'synchronized'=42 -'default'=12 +'protected'=34 'public'=35 -'-='=90 -'<<='=97 -']'=62 +'return'=36 'short'=37 -'long'=29 -'enum'=16 -'!'=69 -'transient'=46 -'|'=86 -'finally'=19 -'assert'=2 -'class'=9 -'new'=31 -'|='=94 +'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 'null'=56 -'const'=10 -'goto'=23 -'='=66 -'@'=101 -'throw'=44 +'('=57 ')'=58 -'*='=91 -'%'=88 -'do'=13 -'super'=40 -'case'=6 -'char'=8 -'strictfp'=39 -'float'=20 +'{'=59 '}'=60 -'boolean'=3 -'abstract'=1 -'double'=14 +'['=61 +']'=62 +';'=63 +','=64 +'.'=65 +'='=66 +'>'=67 +'<'=68 +'!'=69 +'~'=70 +'?'=71 +':'=72 +'=='=73 '<='=74 +'>='=75 '!='=76 -'continue'=11 +'&&'=77 +'||'=78 +'++'=79 '--'=80 -'<'=68 +'+'=81 +'-'=82 '*'=83 -'['=61 +'/'=84 '&'=85 -'interface'=28 +'|'=86 +'^'=87 +'%'=88 +'->'=89 +'::'=90 +'+='=91 +'-='=92 +'*='=93 +'/='=94 +'&='=95 +'|='=96 +'^='=97 +'%='=98 +'<<='=99 +'>>='=100 +'>>>='=101 +'@'=103 +'...'=104 diff --git a/i18n-maven-plugin/src/main/antlr4/Java8BaseVisitor.java b/i18n-maven-plugin/src/main/antlr4/Java8BaseVisitor.java new file mode 100644 index 0000000..4676b32 --- /dev/null +++ b/i18n-maven-plugin/src/main/antlr4/Java8BaseVisitor.java @@ -0,0 +1,1672 @@ +// Generated from ../projets/nuiton-all/i18n/i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link Java8Visitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param <T> The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public class Java8BaseVisitor<T> extends AbstractParseTreeVisitor<T> implements Java8Visitor<T> { + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLiteral(Java8Parser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitType(Java8Parser.TypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimitiveType(Java8Parser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNumericType(Java8Parser.NumericTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIntegralType(Java8Parser.IntegralTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFloatingPointType(Java8Parser.FloatingPointTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReferenceType(Java8Parser.ReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassOrInterfaceType(Java8Parser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType(Java8Parser.ClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType_lf_classOrInterfaceType(Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType_lfno_classOrInterfaceType(Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType(Java8Parser.InterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType_lf_classOrInterfaceType(Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType_lfno_classOrInterfaceType(Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeVariable(Java8Parser.TypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayType(Java8Parser.ArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDims(Java8Parser.DimsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameter(Java8Parser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameterModifier(Java8Parser.TypeParameterModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeBound(Java8Parser.TypeBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAdditionalBound(Java8Parser.AdditionalBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArguments(Java8Parser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgumentList(Java8Parser.TypeArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgument(Java8Parser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWildcard(Java8Parser.WildcardContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWildcardBounds(Java8Parser.WildcardBoundsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageName(Java8Parser.PackageNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeName(Java8Parser.TypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageOrTypeName(Java8Parser.PackageOrTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpressionName(Java8Parser.ExpressionNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodName(Java8Parser.MethodNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAmbiguousName(Java8Parser.AmbiguousNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCompilationUnit(Java8Parser.CompilationUnitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageDeclaration(Java8Parser.PackageDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageModifier(Java8Parser.PackageModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitImportDeclaration(Java8Parser.ImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeDeclaration(Java8Parser.TypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassDeclaration(Java8Parser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalClassDeclaration(Java8Parser.NormalClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassModifier(Java8Parser.ClassModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameters(Java8Parser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameterList(Java8Parser.TypeParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSuperclass(Java8Parser.SuperclassContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSuperinterfaces(Java8Parser.SuperinterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceTypeList(Java8Parser.InterfaceTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassBody(Java8Parser.ClassBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassBodyDeclaration(Java8Parser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassMemberDeclaration(Java8Parser.ClassMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldDeclaration(Java8Parser.FieldDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldModifier(Java8Parser.FieldModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclaratorList(Java8Parser.VariableDeclaratorListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclarator(Java8Parser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclaratorId(Java8Parser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableInitializer(Java8Parser.VariableInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannType(Java8Parser.UnannTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannPrimitiveType(Java8Parser.UnannPrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannReferenceType(Java8Parser.UnannReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassOrInterfaceType(Java8Parser.UnannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType(Java8Parser.UnannClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType_lf_unannClassOrInterfaceType(Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType_lfno_unannClassOrInterfaceType(Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType(Java8Parser.UnannInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType_lf_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannTypeVariable(Java8Parser.UnannTypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannArrayType(Java8Parser.UnannArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodDeclaration(Java8Parser.MethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodModifier(Java8Parser.MethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodHeader(Java8Parser.MethodHeaderContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResult(Java8Parser.ResultContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodDeclarator(Java8Parser.MethodDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameterList(Java8Parser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameters(Java8Parser.FormalParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameter(Java8Parser.FormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableModifier(Java8Parser.VariableModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLastFormalParameter(Java8Parser.LastFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReceiverParameter(Java8Parser.ReceiverParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitThrows_(Java8Parser.Throws_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExceptionTypeList(Java8Parser.ExceptionTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExceptionType(Java8Parser.ExceptionTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodBody(Java8Parser.MethodBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInstanceInitializer(Java8Parser.InstanceInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStaticInitializer(Java8Parser.StaticInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorDeclaration(Java8Parser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorModifier(Java8Parser.ConstructorModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorDeclarator(Java8Parser.ConstructorDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSimpleTypeName(Java8Parser.SimpleTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorBody(Java8Parser.ConstructorBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExplicitConstructorInvocation(Java8Parser.ExplicitConstructorInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumDeclaration(Java8Parser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumBody(Java8Parser.EnumBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantList(Java8Parser.EnumConstantListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstant(Java8Parser.EnumConstantContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantModifier(Java8Parser.EnumConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumBodyDeclarations(Java8Parser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceDeclaration(Java8Parser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalInterfaceDeclaration(Java8Parser.NormalInterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceModifier(Java8Parser.InterfaceModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExtendsInterfaces(Java8Parser.ExtendsInterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceBody(Java8Parser.InterfaceBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMemberDeclaration(Java8Parser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantDeclaration(Java8Parser.ConstantDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantModifier(Java8Parser.ConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMethodDeclaration(Java8Parser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMethodModifier(Java8Parser.InterfaceMethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeDeclaration(Java8Parser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeBody(Java8Parser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeMemberDeclaration(Java8Parser.AnnotationTypeMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeElementDeclaration(Java8Parser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeElementModifier(Java8Parser.AnnotationTypeElementModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDefaultValue(Java8Parser.DefaultValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotation(Java8Parser.AnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalAnnotation(Java8Parser.NormalAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValuePairList(Java8Parser.ElementValuePairListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValuePair(Java8Parser.ElementValuePairContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValue(Java8Parser.ElementValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValueArrayInitializer(Java8Parser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValueList(Java8Parser.ElementValueListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMarkerAnnotation(Java8Parser.MarkerAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleElementAnnotation(Java8Parser.SingleElementAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayInitializer(Java8Parser.ArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableInitializerList(Java8Parser.VariableInitializerListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlock(Java8Parser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlockStatements(Java8Parser.BlockStatementsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlockStatement(Java8Parser.BlockStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLocalVariableDeclarationStatement(Java8Parser.LocalVariableDeclarationStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLocalVariableDeclaration(Java8Parser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatement(Java8Parser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementNoShortIf(Java8Parser.StatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementWithoutTrailingSubstatement(Java8Parser.StatementWithoutTrailingSubstatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEmptyStatement(Java8Parser.EmptyStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLabeledStatement(Java8Parser.LabeledStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLabeledStatementNoShortIf(Java8Parser.LabeledStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpressionStatement(Java8Parser.ExpressionStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementExpression(Java8Parser.StatementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenStatement(Java8Parser.IfThenStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenElseStatement(Java8Parser.IfThenElseStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenElseStatementNoShortIf(Java8Parser.IfThenElseStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssertStatement(Java8Parser.AssertStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchStatement(Java8Parser.SwitchStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchBlock(Java8Parser.SwitchBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchBlockStatementGroup(Java8Parser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchLabels(Java8Parser.SwitchLabelsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchLabel(Java8Parser.SwitchLabelContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantName(Java8Parser.EnumConstantNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWhileStatement(Java8Parser.WhileStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWhileStatementNoShortIf(Java8Parser.WhileStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDoStatement(Java8Parser.DoStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForStatement(Java8Parser.ForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForStatementNoShortIf(Java8Parser.ForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBasicForStatement(Java8Parser.BasicForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBasicForStatementNoShortIf(Java8Parser.BasicForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForInit(Java8Parser.ForInitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForUpdate(Java8Parser.ForUpdateContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementExpressionList(Java8Parser.StatementExpressionListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnhancedForStatement(Java8Parser.EnhancedForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnhancedForStatementNoShortIf(Java8Parser.EnhancedForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBreakStatement(Java8Parser.BreakStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitContinueStatement(Java8Parser.ContinueStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReturnStatement(Java8Parser.ReturnStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitThrowStatement(Java8Parser.ThrowStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSynchronizedStatement(Java8Parser.SynchronizedStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTryStatement(Java8Parser.TryStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatches(Java8Parser.CatchesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchClause(Java8Parser.CatchClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchFormalParameter(Java8Parser.CatchFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchType(Java8Parser.CatchTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFinally_(Java8Parser.Finally_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTryWithResourcesStatement(Java8Parser.TryWithResourcesStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResourceSpecification(Java8Parser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResourceList(Java8Parser.ResourceListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResource(Java8Parser.ResourceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimary(Java8Parser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray(Java8Parser.PrimaryNoNewArrayContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_arrayAccess(Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_arrayAccess(Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression(Java8Parser.ClassInstanceCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression_lf_primary(Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression_lfno_primary(Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgumentsOrDiamond(Java8Parser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess(Java8Parser.FieldAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess_lf_primary(Java8Parser.FieldAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess_lfno_primary(Java8Parser.FieldAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess(Java8Parser.ArrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess_lf_primary(Java8Parser.ArrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess_lfno_primary(Java8Parser.ArrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation(Java8Parser.MethodInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation_lf_primary(Java8Parser.MethodInvocation_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation_lfno_primary(Java8Parser.MethodInvocation_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArgumentList(Java8Parser.ArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference(Java8Parser.MethodReferenceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference_lf_primary(Java8Parser.MethodReference_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference_lfno_primary(Java8Parser.MethodReference_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayCreationExpression(Java8Parser.ArrayCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDimExprs(Java8Parser.DimExprsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDimExpr(Java8Parser.DimExprContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantExpression(Java8Parser.ConstantExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpression(Java8Parser.ExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaExpression(Java8Parser.LambdaExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaParameters(Java8Parser.LambdaParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInferredFormalParameterList(Java8Parser.InferredFormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaBody(Java8Parser.LambdaBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignmentExpression(Java8Parser.AssignmentExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignment(Java8Parser.AssignmentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLeftHandSide(Java8Parser.LeftHandSideContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignmentOperator(Java8Parser.AssignmentOperatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalExpression(Java8Parser.ConditionalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalOrExpression(Java8Parser.ConditionalOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalAndExpression(Java8Parser.ConditionalAndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInclusiveOrExpression(Java8Parser.InclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExclusiveOrExpression(Java8Parser.ExclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAndExpression(Java8Parser.AndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEqualityExpression(Java8Parser.EqualityExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitRelationalExpression(Java8Parser.RelationalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitShiftExpression(Java8Parser.ShiftExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAdditiveExpression(Java8Parser.AdditiveExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMultiplicativeExpression(Java8Parser.MultiplicativeExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnaryExpression(Java8Parser.UnaryExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPreIncrementExpression(Java8Parser.PreIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPreDecrementExpression(Java8Parser.PreDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnaryExpressionNotPlusMinus(Java8Parser.UnaryExpressionNotPlusMinusContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostfixExpression(Java8Parser.PostfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostIncrementExpression(Java8Parser.PostIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostIncrementExpression_lf_postfixExpression(Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostDecrementExpression(Java8Parser.PostDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostDecrementExpression_lf_postfixExpression(Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCastExpression(Java8Parser.CastExpressionContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/antlr4/Java8Lexer.java b/i18n-maven-plugin/src/main/antlr4/Java8Lexer.java new file mode 100644 index 0000000..ef9ff43 --- /dev/null +++ b/i18n-maven-plugin/src/main/antlr4/Java8Lexer.java @@ -0,0 +1,583 @@ +// Generated from ../projets/nuiton-all/i18n/i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, + ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, + OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, + URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, + LINE_COMMENT=107; + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + public static final String[] ruleNames = { + "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", + "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", + "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", + "HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", + "DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", + "DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", + "HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", + "OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", + "BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", + "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", + "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", + "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", + "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", + "StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", + "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", + "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", + "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", + "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", + "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", + "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", + "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + + private static final String[] _LITERAL_NAMES = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", + "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", + "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", + "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + 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; + } + + + public Java8Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Java8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 146: + return JavaLetter_sempred((RuleContext)_localctx, predIndex); + case 147: + return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return Character.isJavaIdentifierStart(_input.LA(-1)); + case 1: + return Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); + } + return true; + } + private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return Character.isJavaIdentifierPart(_input.LA(-1)); + case 3: + return Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); + } + return true; + } + + public static final String _serializedATN = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2m\u0448\b\1\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ + "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ + "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ + "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\3\2\3\2\3\2\3"+ + "\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4"+ + "\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3"+ + "\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n"+ + "\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f"+ + "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3"+ + "\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3"+ + "\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3"+ + "\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3"+ + "\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3"+ + "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3"+ + "\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3"+ + "\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3"+ + "\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!"+ + "\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3"+ + "#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3"+ + "\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3"+ + ")\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3"+ + ",\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3"+ + "/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3"+ + "\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3"+ + "\64\3\64\5\64\u028d\n\64\3\65\3\65\5\65\u0291\n\65\3\66\3\66\5\66\u0295"+ + "\n\66\3\67\3\67\5\67\u0299\n\67\38\38\58\u029d\n8\39\39\3:\3:\3:\5:\u02a4"+ + "\n:\3:\3:\3:\5:\u02a9\n:\5:\u02ab\n:\3;\3;\5;\u02af\n;\3;\5;\u02b2\n;"+ + "\3<\3<\5<\u02b6\n<\3=\3=\3>\6>\u02bb\n>\r>\16>\u02bc\3?\3?\5?\u02c1\n"+ + "?\3@\6@\u02c4\n@\r@\16@\u02c5\3A\3A\3A\3A\3B\3B\5B\u02ce\nB\3B\5B\u02d1"+ + "\nB\3C\3C\3D\6D\u02d6\nD\rD\16D\u02d7\3E\3E\5E\u02dc\nE\3F\3F\5F\u02e0"+ + "\nF\3F\3F\3G\3G\5G\u02e6\nG\3G\5G\u02e9\nG\3H\3H\3I\6I\u02ee\nI\rI\16"+ + "I\u02ef\3J\3J\5J\u02f4\nJ\3K\3K\3K\3K\3L\3L\5L\u02fc\nL\3L\5L\u02ff\n"+ + "L\3M\3M\3N\6N\u0304\nN\rN\16N\u0305\3O\3O\5O\u030a\nO\3P\3P\5P\u030e\n"+ + "P\3Q\3Q\3Q\5Q\u0313\nQ\3Q\5Q\u0316\nQ\3Q\5Q\u0319\nQ\3Q\3Q\3Q\5Q\u031e"+ + "\nQ\3Q\5Q\u0321\nQ\3Q\3Q\3Q\5Q\u0326\nQ\3Q\3Q\3Q\5Q\u032b\nQ\3R\3R\3R"+ + "\3S\3S\3T\5T\u0333\nT\3T\3T\3U\3U\3V\3V\3W\3W\3W\5W\u033e\nW\3X\3X\5X"+ + "\u0342\nX\3X\3X\3X\5X\u0347\nX\3X\3X\5X\u034b\nX\3Y\3Y\3Y\3Z\3Z\3[\3["+ + "\3[\3[\3[\3[\3[\3[\3[\5[\u035b\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\"+ + "\u0365\n\\\3]\3]\3^\3^\5^\u036b\n^\3^\3^\3_\6_\u0370\n_\r_\16_\u0371\3"+ + "`\3`\5`\u0376\n`\3a\3a\3a\3a\5a\u037c\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3"+ + "b\3b\5b\u0389\nb\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3g\3"+ + "g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3"+ + "s\3s\3t\3t\3u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3z\3{\3{\3"+ + "{\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081"+ + "\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086"+ + "\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089"+ + "\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c"+ + "\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f"+ + "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\7\u0093"+ + "\u040e\n\u0093\f\u0093\16\u0093\u0411\13\u0093\3\u0094\3\u0094\3\u0094"+ + "\3\u0094\3\u0094\3\u0094\5\u0094\u0419\n\u0094\3\u0095\3\u0095\3\u0095"+ + "\3\u0095\3\u0095\3\u0095\5\u0095\u0421\n\u0095\3\u0096\3\u0096\3\u0097"+ + "\3\u0097\3\u0097\3\u0097\3\u0098\6\u0098\u042a\n\u0098\r\u0098\16\u0098"+ + "\u042b\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u0434\n"+ + "\u0099\f\u0099\16\u0099\u0437\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ + "\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u0442\n\u009a\f\u009a"+ + "\16\u009a\u0445\13\u009a\3\u009a\3\u009a\3\u0435\2\u009b\3\3\5\4\7\5\t"+ + "\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+ + "%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+ + "%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\2k\2m\2o\2q\2s\2u\2w\2"+ + "y\2{\2}\2\177\2\u0081\2\u0083\2\u0085\2\u0087\2\u0089\2\u008b\2\u008d"+ + "\2\u008f\2\u0091\2\u0093\2\u0095\2\u0097\2\u0099\2\u009b\2\u009d\2\u009f"+ + "\66\u00a1\2\u00a3\2\u00a5\2\u00a7\2\u00a9\2\u00ab\2\u00ad\2\u00af\2\u00b1"+ + "\2\u00b3\2\u00b5\67\u00b78\u00b9\2\u00bb9\u00bd\2\u00bf\2\u00c1\2\u00c3"+ + "\2\u00c5\2\u00c7\2\u00c9:\u00cb;\u00cd<\u00cf=\u00d1>\u00d3?\u00d5@\u00d7"+ + "A\u00d9B\u00dbC\u00ddD\u00dfE\u00e1F\u00e3G\u00e5H\u00e7I\u00e9J\u00eb"+ + "K\u00edL\u00efM\u00f1N\u00f3O\u00f5P\u00f7Q\u00f9R\u00fbS\u00fdT\u00ff"+ + "U\u0101V\u0103W\u0105X\u0107Y\u0109Z\u010b[\u010d\\\u010f]\u0111^\u0113"+ + "_\u0115`\u0117a\u0119b\u011bc\u011dd\u011fe\u0121f\u0123g\u0125h\u0127"+ + "\2\u0129\2\u012bi\u012dj\u012fk\u0131l\u0133m\3\2\30\4\2NNnn\3\2\63;\4"+ + "\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4\2GGgg\4\2--//\6\2FFHHf"+ + "fhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\aac"+ + "|\4\2\2\u0081\ud802\udc01\3\2\ud802\udc01\3\2\udc02\ue001\7\2&&\62;C\\"+ + "aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\u0456\2\3\3\2\2\2\2\5\3\2\2\2\2"+ + "\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2"+ + "\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2"+ + "\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2"+ + "\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2"+ + "\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2"+ + "\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2"+ + "M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3"+ + "\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2"+ + "\2\2g\3\2\2\2\2\u009f\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00bb"+ + "\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2"+ + "\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9"+ + "\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2"+ + "\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb"+ + "\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2"+ + "\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd"+ + "\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2"+ + "\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f"+ + "\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2"+ + "\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2\2\2\u0121"+ + "\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2"+ + "\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\3\u0135\3\2\2\2\5\u013e"+ + "\3\2\2\2\7\u0145\3\2\2\2\t\u014d\3\2\2\2\13\u0153\3\2\2\2\r\u0158\3\2"+ + "\2\2\17\u015d\3\2\2\2\21\u0163\3\2\2\2\23\u0168\3\2\2\2\25\u016e\3\2\2"+ + "\2\27\u0174\3\2\2\2\31\u017d\3\2\2\2\33\u0185\3\2\2\2\35\u0188\3\2\2\2"+ + "\37\u018f\3\2\2\2!\u0194\3\2\2\2#\u0199\3\2\2\2%\u01a1\3\2\2\2\'\u01a7"+ + "\3\2\2\2)\u01af\3\2\2\2+\u01b5\3\2\2\2-\u01b9\3\2\2\2/\u01bc\3\2\2\2\61"+ + "\u01c1\3\2\2\2\63\u01cc\3\2\2\2\65\u01d3\3\2\2\2\67\u01de\3\2\2\29\u01e2"+ + "\3\2\2\2;\u01ec\3\2\2\2=\u01f1\3\2\2\2?\u01f8\3\2\2\2A\u01fc\3\2\2\2C"+ + "\u0204\3\2\2\2E\u020c\3\2\2\2G\u0216\3\2\2\2I\u021d\3\2\2\2K\u0224\3\2"+ + "\2\2M\u022a\3\2\2\2O\u0231\3\2\2\2Q\u023a\3\2\2\2S\u0240\3\2\2\2U\u0247"+ + "\3\2\2\2W\u0254\3\2\2\2Y\u0259\3\2\2\2[\u025f\3\2\2\2]\u0266\3\2\2\2_"+ + "\u0270\3\2\2\2a\u0274\3\2\2\2c\u0279\3\2\2\2e\u0282\3\2\2\2g\u028c\3\2"+ + "\2\2i\u028e\3\2\2\2k\u0292\3\2\2\2m\u0296\3\2\2\2o\u029a\3\2\2\2q\u029e"+ + "\3\2\2\2s\u02aa\3\2\2\2u\u02ac\3\2\2\2w\u02b5\3\2\2\2y\u02b7\3\2\2\2{"+ + "\u02ba\3\2\2\2}\u02c0\3\2\2\2\177\u02c3\3\2\2\2\u0081\u02c7\3\2\2\2\u0083"+ + "\u02cb\3\2\2\2\u0085\u02d2\3\2\2\2\u0087\u02d5\3\2\2\2\u0089\u02db\3\2"+ + "\2\2\u008b\u02dd\3\2\2\2\u008d\u02e3\3\2\2\2\u008f\u02ea\3\2\2\2\u0091"+ + "\u02ed\3\2\2\2\u0093\u02f3\3\2\2\2\u0095\u02f5\3\2\2\2\u0097\u02f9\3\2"+ + "\2\2\u0099\u0300\3\2\2\2\u009b\u0303\3\2\2\2\u009d\u0309\3\2\2\2\u009f"+ + "\u030d\3\2\2\2\u00a1\u032a\3\2\2\2\u00a3\u032c\3\2\2\2\u00a5\u032f\3\2"+ + "\2\2\u00a7\u0332\3\2\2\2\u00a9\u0336\3\2\2\2\u00ab\u0338\3\2\2\2\u00ad"+ + "\u033a\3\2\2\2\u00af\u034a\3\2\2\2\u00b1\u034c\3\2\2\2\u00b3\u034f\3\2"+ + "\2\2\u00b5\u035a\3\2\2\2\u00b7\u0364\3\2\2\2\u00b9\u0366\3\2\2\2\u00bb"+ + "\u0368\3\2\2\2\u00bd\u036f\3\2\2\2\u00bf\u0375\3\2\2\2\u00c1\u037b\3\2"+ + "\2\2\u00c3\u0388\3\2\2\2\u00c5\u038a\3\2\2\2\u00c7\u038c\3\2\2\2\u00c9"+ + "\u0393\3\2\2\2\u00cb\u0398\3\2\2\2\u00cd\u039a\3\2\2\2\u00cf\u039c\3\2"+ + "\2\2\u00d1\u039e\3\2\2\2\u00d3\u03a0\3\2\2\2\u00d5\u03a2\3\2\2\2\u00d7"+ + "\u03a4\3\2\2\2\u00d9\u03a6\3\2\2\2\u00db\u03a8\3\2\2\2\u00dd\u03aa\3\2"+ + "\2\2\u00df\u03ac\3\2\2\2\u00e1\u03ae\3\2\2\2\u00e3\u03b0\3\2\2\2\u00e5"+ + "\u03b2\3\2\2\2\u00e7\u03b4\3\2\2\2\u00e9\u03b6\3\2\2\2\u00eb\u03b8\3\2"+ + "\2\2\u00ed\u03bb\3\2\2\2\u00ef\u03be\3\2\2\2\u00f1\u03c1\3\2\2\2\u00f3"+ + "\u03c4\3\2\2\2\u00f5\u03c7\3\2\2\2\u00f7\u03ca\3\2\2\2\u00f9\u03cd\3\2"+ + "\2\2\u00fb\u03d0\3\2\2\2\u00fd\u03d2\3\2\2\2\u00ff\u03d4\3\2\2\2\u0101"+ + "\u03d6\3\2\2\2\u0103\u03d8\3\2\2\2\u0105\u03da\3\2\2\2\u0107\u03dc\3\2"+ + "\2\2\u0109\u03de\3\2\2\2\u010b\u03e0\3\2\2\2\u010d\u03e3\3\2\2\2\u010f"+ + "\u03e6\3\2\2\2\u0111\u03e9\3\2\2\2\u0113\u03ec\3\2\2\2\u0115\u03ef\3\2"+ + "\2\2\u0117\u03f2\3\2\2\2\u0119\u03f5\3\2\2\2\u011b\u03f8\3\2\2\2\u011d"+ + "\u03fb\3\2\2\2\u011f\u03fe\3\2\2\2\u0121\u0402\3\2\2\2\u0123\u0406\3\2"+ + "\2\2\u0125\u040b\3\2\2\2\u0127\u0418\3\2\2\2\u0129\u0420\3\2\2\2\u012b"+ + "\u0422\3\2\2\2\u012d\u0424\3\2\2\2\u012f\u0429\3\2\2\2\u0131\u042f\3\2"+ + "\2\2\u0133\u043d\3\2\2\2\u0135\u0136\7c\2\2\u0136\u0137\7d\2\2\u0137\u0138"+ + "\7u\2\2\u0138\u0139\7v\2\2\u0139\u013a\7t\2\2\u013a\u013b\7c\2\2\u013b"+ + "\u013c\7e\2\2\u013c\u013d\7v\2\2\u013d\4\3\2\2\2\u013e\u013f\7c\2\2\u013f"+ + "\u0140\7u\2\2\u0140\u0141\7u\2\2\u0141\u0142\7g\2\2\u0142\u0143\7t\2\2"+ + "\u0143\u0144\7v\2\2\u0144\6\3\2\2\2\u0145\u0146\7d\2\2\u0146\u0147\7q"+ + "\2\2\u0147\u0148\7q\2\2\u0148\u0149\7n\2\2\u0149\u014a\7g\2\2\u014a\u014b"+ + "\7c\2\2\u014b\u014c\7p\2\2\u014c\b\3\2\2\2\u014d\u014e\7d\2\2\u014e\u014f"+ + "\7t\2\2\u014f\u0150\7g\2\2\u0150\u0151\7c\2\2\u0151\u0152\7m\2\2\u0152"+ + "\n\3\2\2\2\u0153\u0154\7d\2\2\u0154\u0155\7{\2\2\u0155\u0156\7v\2\2\u0156"+ + "\u0157\7g\2\2\u0157\f\3\2\2\2\u0158\u0159\7e\2\2\u0159\u015a\7c\2\2\u015a"+ + "\u015b\7u\2\2\u015b\u015c\7g\2\2\u015c\16\3\2\2\2\u015d\u015e\7e\2\2\u015e"+ + "\u015f\7c\2\2\u015f\u0160\7v\2\2\u0160\u0161\7e\2\2\u0161\u0162\7j\2\2"+ + "\u0162\20\3\2\2\2\u0163\u0164\7e\2\2\u0164\u0165\7j\2\2\u0165\u0166\7"+ + "c\2\2\u0166\u0167\7t\2\2\u0167\22\3\2\2\2\u0168\u0169\7e\2\2\u0169\u016a"+ + "\7n\2\2\u016a\u016b\7c\2\2\u016b\u016c\7u\2\2\u016c\u016d\7u\2\2\u016d"+ + "\24\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171\7p\2\2\u0171"+ + "\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173\26\3\2\2\2\u0174\u0175\7e\2\2\u0175"+ + "\u0176\7q\2\2\u0176\u0177\7p\2\2\u0177\u0178\7v\2\2\u0178\u0179\7k\2\2"+ + "\u0179\u017a\7p\2\2\u017a\u017b\7w\2\2\u017b\u017c\7g\2\2\u017c\30\3\2"+ + "\2\2\u017d\u017e\7f\2\2\u017e\u017f\7g\2\2\u017f\u0180\7h\2\2\u0180\u0181"+ + "\7c\2\2\u0181\u0182\7w\2\2\u0182\u0183\7n\2\2\u0183\u0184\7v\2\2\u0184"+ + "\32\3\2\2\2\u0185\u0186\7f\2\2\u0186\u0187\7q\2\2\u0187\34\3\2\2\2\u0188"+ + "\u0189\7f\2\2\u0189\u018a\7q\2\2\u018a\u018b\7w\2\2\u018b\u018c\7d\2\2"+ + "\u018c\u018d\7n\2\2\u018d\u018e\7g\2\2\u018e\36\3\2\2\2\u018f\u0190\7"+ + "g\2\2\u0190\u0191\7n\2\2\u0191\u0192\7u\2\2\u0192\u0193\7g\2\2\u0193 "+ + "\3\2\2\2\u0194\u0195\7g\2\2\u0195\u0196\7p\2\2\u0196\u0197\7w\2\2\u0197"+ + "\u0198\7o\2\2\u0198\"\3\2\2\2\u0199\u019a\7g\2\2\u019a\u019b\7z\2\2\u019b"+ + "\u019c\7v\2\2\u019c\u019d\7g\2\2\u019d\u019e\7p\2\2\u019e\u019f\7f\2\2"+ + "\u019f\u01a0\7u\2\2\u01a0$\3\2\2\2\u01a1\u01a2\7h\2\2\u01a2\u01a3\7k\2"+ + "\2\u01a3\u01a4\7p\2\2\u01a4\u01a5\7c\2\2\u01a5\u01a6\7n\2\2\u01a6&\3\2"+ + "\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7k\2\2\u01a9\u01aa\7p\2\2\u01aa\u01ab"+ + "\7c\2\2\u01ab\u01ac\7n\2\2\u01ac\u01ad\7n\2\2\u01ad\u01ae\7{\2\2\u01ae"+ + "(\3\2\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7n\2\2\u01b1\u01b2\7q\2\2\u01b2"+ + "\u01b3\7c\2\2\u01b3\u01b4\7v\2\2\u01b4*\3\2\2\2\u01b5\u01b6\7h\2\2\u01b6"+ + "\u01b7\7q\2\2\u01b7\u01b8\7t\2\2\u01b8,\3\2\2\2\u01b9\u01ba\7k\2\2\u01ba"+ + "\u01bb\7h\2\2\u01bb.\3\2\2\2\u01bc\u01bd\7i\2\2\u01bd\u01be\7q\2\2\u01be"+ + "\u01bf\7v\2\2\u01bf\u01c0\7q\2\2\u01c0\60\3\2\2\2\u01c1\u01c2\7k\2\2\u01c2"+ + "\u01c3\7o\2\2\u01c3\u01c4\7r\2\2\u01c4\u01c5\7n\2\2\u01c5\u01c6\7g\2\2"+ + "\u01c6\u01c7\7o\2\2\u01c7\u01c8\7g\2\2\u01c8\u01c9\7p\2\2\u01c9\u01ca"+ + "\7v\2\2\u01ca\u01cb\7u\2\2\u01cb\62\3\2\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce"+ + "\7o\2\2\u01ce\u01cf\7r\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7t\2\2\u01d1"+ + "\u01d2\7v\2\2\u01d2\64\3\2\2\2\u01d3\u01d4\7k\2\2\u01d4\u01d5\7p\2\2\u01d5"+ + "\u01d6\7u\2\2\u01d6\u01d7\7v\2\2\u01d7\u01d8\7c\2\2\u01d8\u01d9\7p\2\2"+ + "\u01d9\u01da\7e\2\2\u01da\u01db\7g\2\2\u01db\u01dc\7q\2\2\u01dc\u01dd"+ + "\7h\2\2\u01dd\66\3\2\2\2\u01de\u01df\7k\2\2\u01df\u01e0\7p\2\2\u01e0\u01e1"+ + "\7v\2\2\u01e18\3\2\2\2\u01e2\u01e3\7k\2\2\u01e3\u01e4\7p\2\2\u01e4\u01e5"+ + "\7v\2\2\u01e5\u01e6\7g\2\2\u01e6\u01e7\7t\2\2\u01e7\u01e8\7h\2\2\u01e8"+ + "\u01e9\7c\2\2\u01e9\u01ea\7e\2\2\u01ea\u01eb\7g\2\2\u01eb:\3\2\2\2\u01ec"+ + "\u01ed\7n\2\2\u01ed\u01ee\7q\2\2\u01ee\u01ef\7p\2\2\u01ef\u01f0\7i\2\2"+ + "\u01f0<\3\2\2\2\u01f1\u01f2\7p\2\2\u01f2\u01f3\7c\2\2\u01f3\u01f4\7v\2"+ + "\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7x\2\2\u01f6\u01f7\7g\2\2\u01f7>\3\2"+ + "\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7g\2\2\u01fa\u01fb\7y\2\2\u01fb@\3"+ + "\2\2\2\u01fc\u01fd\7r\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff\7e\2\2\u01ff"+ + "\u0200\7m\2\2\u0200\u0201\7c\2\2\u0201\u0202\7i\2\2\u0202\u0203\7g\2\2"+ + "\u0203B\3\2\2\2\u0204\u0205\7r\2\2\u0205\u0206\7t\2\2\u0206\u0207\7k\2"+ + "\2\u0207\u0208\7x\2\2\u0208\u0209\7c\2\2\u0209\u020a\7v\2\2\u020a\u020b"+ + "\7g\2\2\u020bD\3\2\2\2\u020c\u020d\7r\2\2\u020d\u020e\7t\2\2\u020e\u020f"+ + "\7q\2\2\u020f\u0210\7v\2\2\u0210\u0211\7g\2\2\u0211\u0212\7e\2\2\u0212"+ + "\u0213\7v\2\2\u0213\u0214\7g\2\2\u0214\u0215\7f\2\2\u0215F\3\2\2\2\u0216"+ + "\u0217\7r\2\2\u0217\u0218\7w\2\2\u0218\u0219\7d\2\2\u0219\u021a\7n\2\2"+ + "\u021a\u021b\7k\2\2\u021b\u021c\7e\2\2\u021cH\3\2\2\2\u021d\u021e\7t\2"+ + "\2\u021e\u021f\7g\2\2\u021f\u0220\7v\2\2\u0220\u0221\7w\2\2\u0221\u0222"+ + "\7t\2\2\u0222\u0223\7p\2\2\u0223J\3\2\2\2\u0224\u0225\7u\2\2\u0225\u0226"+ + "\7j\2\2\u0226\u0227\7q\2\2\u0227\u0228\7t\2\2\u0228\u0229\7v\2\2\u0229"+ + "L\3\2\2\2\u022a\u022b\7u\2\2\u022b\u022c\7v\2\2\u022c\u022d\7c\2\2\u022d"+ + "\u022e\7v\2\2\u022e\u022f\7k\2\2\u022f\u0230\7e\2\2\u0230N\3\2\2\2\u0231"+ + "\u0232\7u\2\2\u0232\u0233\7v\2\2\u0233\u0234\7t\2\2\u0234\u0235\7k\2\2"+ + "\u0235\u0236\7e\2\2\u0236\u0237\7v\2\2\u0237\u0238\7h\2\2\u0238\u0239"+ + "\7r\2\2\u0239P\3\2\2\2\u023a\u023b\7u\2\2\u023b\u023c\7w\2\2\u023c\u023d"+ + "\7r\2\2\u023d\u023e\7g\2\2\u023e\u023f\7t\2\2\u023fR\3\2\2\2\u0240\u0241"+ + "\7u\2\2\u0241\u0242\7y\2\2\u0242\u0243\7k\2\2\u0243\u0244\7v\2\2\u0244"+ + "\u0245\7e\2\2\u0245\u0246\7j\2\2\u0246T\3\2\2\2\u0247\u0248\7u\2\2\u0248"+ + "\u0249\7{\2\2\u0249\u024a\7p\2\2\u024a\u024b\7e\2\2\u024b\u024c\7j\2\2"+ + "\u024c\u024d\7t\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2\u024f\u0250"+ + "\7k\2\2\u0250\u0251\7|\2\2\u0251\u0252\7g\2\2\u0252\u0253\7f\2\2\u0253"+ + "V\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7j\2\2\u0256\u0257\7k\2\2\u0257"+ + "\u0258\7u\2\2\u0258X\3\2\2\2\u0259\u025a\7v\2\2\u025a\u025b\7j\2\2\u025b"+ + "\u025c\7t\2\2\u025c\u025d\7q\2\2\u025d\u025e\7y\2\2\u025eZ\3\2\2\2\u025f"+ + "\u0260\7v\2\2\u0260\u0261\7j\2\2\u0261\u0262\7t\2\2\u0262\u0263\7q\2\2"+ + "\u0263\u0264\7y\2\2\u0264\u0265\7u\2\2\u0265\\\3\2\2\2\u0266\u0267\7v"+ + "\2\2\u0267\u0268\7t\2\2\u0268\u0269\7c\2\2\u0269\u026a\7p\2\2\u026a\u026b"+ + "\7u\2\2\u026b\u026c\7k\2\2\u026c\u026d\7g\2\2\u026d\u026e\7p\2\2\u026e"+ + "\u026f\7v\2\2\u026f^\3\2\2\2\u0270\u0271\7v\2\2\u0271\u0272\7t\2\2\u0272"+ + "\u0273\7{\2\2\u0273`\3\2\2\2\u0274\u0275\7x\2\2\u0275\u0276\7q\2\2\u0276"+ + "\u0277\7k\2\2\u0277\u0278\7f\2\2\u0278b\3\2\2\2\u0279\u027a\7x\2\2\u027a"+ + "\u027b\7q\2\2\u027b\u027c\7n\2\2\u027c\u027d\7c\2\2\u027d\u027e\7v\2\2"+ + "\u027e\u027f\7k\2\2\u027f\u0280\7n\2\2\u0280\u0281\7g\2\2\u0281d\3\2\2"+ + "\2\u0282\u0283\7y\2\2\u0283\u0284\7j\2\2\u0284\u0285\7k\2\2\u0285\u0286"+ + "\7n\2\2\u0286\u0287\7g\2\2\u0287f\3\2\2\2\u0288\u028d\5i\65\2\u0289\u028d"+ + "\5k\66\2\u028a\u028d\5m\67\2\u028b\u028d\5o8\2\u028c\u0288\3\2\2\2\u028c"+ + "\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028dh\3\2\2\2"+ + "\u028e\u0290\5s:\2\u028f\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3"+ + "\2\2\2\u0291j\3\2\2\2\u0292\u0294\5\u0081A\2\u0293\u0295\5q9\2\u0294\u0293"+ + "\3\2\2\2\u0294\u0295\3\2\2\2\u0295l\3\2\2\2\u0296\u0298\5\u008bF\2\u0297"+ + "\u0299\5q9\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299n\3\2\2\2\u029a"+ + "\u029c\5\u0095K\2\u029b\u029d\5q9\2\u029c\u029b\3\2\2\2\u029c\u029d\3"+ + "\2\2\2\u029dp\3\2\2\2\u029e\u029f\t\2\2\2\u029fr\3\2\2\2\u02a0\u02ab\7"+ + "\62\2\2\u02a1\u02a8\5y=\2\u02a2\u02a4\5u;\2\u02a3\u02a2\3\2\2\2\u02a3"+ + "\u02a4\3\2\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a6\5\177@\2\u02a6\u02a7\5"+ + "u;\2\u02a7\u02a9\3\2\2\2\u02a8\u02a3\3\2\2\2\u02a8\u02a5\3\2\2\2\u02a9"+ + "\u02ab\3\2\2\2\u02aa\u02a0\3\2\2\2\u02aa\u02a1\3\2\2\2\u02abt\3\2\2\2"+ + "\u02ac\u02b1\5w<\2\u02ad\u02af\5{>\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+ + "\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\5w<\2\u02b1\u02ae\3\2\2\2\u02b1"+ + "\u02b2\3\2\2\2\u02b2v\3\2\2\2\u02b3\u02b6\7\62\2\2\u02b4\u02b6\5y=\2\u02b5"+ + "\u02b3\3\2\2\2\u02b5\u02b4\3\2\2\2\u02b6x\3\2\2\2\u02b7\u02b8\t\3\2\2"+ + "\u02b8z\3\2\2\2\u02b9\u02bb\5}?\2\u02ba\u02b9\3\2\2\2\u02bb\u02bc\3\2"+ + "\2\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd|\3\2\2\2\u02be\u02c1"+ + "\5w<\2\u02bf\u02c1\7a\2\2\u02c0\u02be\3\2\2\2\u02c0\u02bf\3\2\2\2\u02c1"+ + "~\3\2\2\2\u02c2\u02c4\7a\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+ + "\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0080\3\2\2\2\u02c7\u02c8\7\62"+ + "\2\2\u02c8\u02c9\t\4\2\2\u02c9\u02ca\5\u0083B\2\u02ca\u0082\3\2\2\2\u02cb"+ + "\u02d0\5\u0085C\2\u02cc\u02ce\5\u0087D\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce"+ + "\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\5\u0085C\2\u02d0\u02cd\3\2\2"+ + "\2\u02d0\u02d1\3\2\2\2\u02d1\u0084\3\2\2\2\u02d2\u02d3\t\5\2\2\u02d3\u0086"+ + "\3\2\2\2\u02d4\u02d6\5\u0089E\2\u02d5\u02d4\3\2\2\2\u02d6\u02d7\3\2\2"+ + "\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u0088\3\2\2\2\u02d9\u02dc"+ + "\5\u0085C\2\u02da\u02dc\7a\2\2\u02db\u02d9\3\2\2\2\u02db\u02da\3\2\2\2"+ + "\u02dc\u008a\3\2\2\2\u02dd\u02df\7\62\2\2\u02de\u02e0\5\177@\2\u02df\u02de"+ + "\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e2\5\u008dG"+ + "\2\u02e2\u008c\3\2\2\2\u02e3\u02e8\5\u008fH\2\u02e4\u02e6\5\u0091I\2\u02e5"+ + "\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\5\u008f"+ + "H\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u008e\3\2\2\2\u02ea"+ + "\u02eb\t\6\2\2\u02eb\u0090\3\2\2\2\u02ec\u02ee\5\u0093J\2\u02ed\u02ec"+ + "\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0"+ + "\u0092\3\2\2\2\u02f1\u02f4\5\u008fH\2\u02f2\u02f4\7a\2\2\u02f3\u02f1\3"+ + "\2\2\2\u02f3\u02f2\3\2\2\2\u02f4\u0094\3\2\2\2\u02f5\u02f6\7\62\2\2\u02f6"+ + "\u02f7\t\7\2\2\u02f7\u02f8\5\u0097L\2\u02f8\u0096\3\2\2\2\u02f9\u02fe"+ + "\5\u0099M\2\u02fa\u02fc\5\u009bN\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2"+ + "\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\5\u0099M\2\u02fe\u02fb\3\2\2\2\u02fe"+ + "\u02ff\3\2\2\2\u02ff\u0098\3\2\2\2\u0300\u0301\t\b\2\2\u0301\u009a\3\2"+ + "\2\2\u0302\u0304\5\u009dO\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+ + "\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u009c\3\2\2\2\u0307\u030a\5\u0099"+ + "M\2\u0308\u030a\7a\2\2\u0309\u0307\3\2\2\2\u0309\u0308\3\2\2\2\u030a\u009e"+ + "\3\2\2\2\u030b\u030e\5\u00a1Q\2\u030c\u030e\5\u00adW\2\u030d\u030b\3\2"+ + "\2\2\u030d\u030c\3\2\2\2\u030e\u00a0\3\2\2\2\u030f\u0310\5u;\2\u0310\u0312"+ + "\7\60\2\2\u0311\u0313\5u;\2\u0312\u0311\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ + "\u0315\3\2\2\2\u0314\u0316\5\u00a3R\2\u0315\u0314\3\2\2\2\u0315\u0316"+ + "\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319\5\u00abV\2\u0318\u0317\3\2\2"+ + "\2\u0318\u0319\3\2\2\2\u0319\u032b\3\2\2\2\u031a\u031b\7\60\2\2\u031b"+ + "\u031d\5u;\2\u031c\u031e\5\u00a3R\2\u031d\u031c\3\2\2\2\u031d\u031e\3"+ + "\2\2\2\u031e\u0320\3\2\2\2\u031f\u0321\5\u00abV\2\u0320\u031f\3\2\2\2"+ + "\u0320\u0321\3\2\2\2\u0321\u032b\3\2\2\2\u0322\u0323\5u;\2\u0323\u0325"+ + "\5\u00a3R\2\u0324\u0326\5\u00abV\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2"+ + "\2\2\u0326\u032b\3\2\2\2\u0327\u0328\5u;\2\u0328\u0329\5\u00abV\2\u0329"+ + "\u032b\3\2\2\2\u032a\u030f\3\2\2\2\u032a\u031a\3\2\2\2\u032a\u0322\3\2"+ + "\2\2\u032a\u0327\3\2\2\2\u032b\u00a2\3\2\2\2\u032c\u032d\5\u00a5S\2\u032d"+ + "\u032e\5\u00a7T\2\u032e\u00a4\3\2\2\2\u032f\u0330\t\t\2\2\u0330\u00a6"+ + "\3\2\2\2\u0331\u0333\5\u00a9U\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2"+ + "\2\u0333\u0334\3\2\2\2\u0334\u0335\5u;\2\u0335\u00a8\3\2\2\2\u0336\u0337"+ + "\t\n\2\2\u0337\u00aa\3\2\2\2\u0338\u0339\t\13\2\2\u0339\u00ac\3\2\2\2"+ + "\u033a\u033b\5\u00afX\2\u033b\u033d\5\u00b1Y\2\u033c\u033e\5\u00abV\2"+ + "\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u00ae\3\2\2\2\u033f\u0341"+ + "\5\u0081A\2\u0340\u0342\7\60\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2"+ + "\2\u0342\u034b\3\2\2\2\u0343\u0344\7\62\2\2\u0344\u0346\t\4\2\2\u0345"+ + "\u0347\5\u0083B\2\u0346\u0345\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348"+ + "\3\2\2\2\u0348\u0349\7\60\2\2\u0349\u034b\5\u0083B\2\u034a\u033f\3\2\2"+ + "\2\u034a\u0343\3\2\2\2\u034b\u00b0\3\2\2\2\u034c\u034d\5\u00b3Z\2\u034d"+ + "\u034e\5\u00a7T\2\u034e\u00b2\3\2\2\2\u034f\u0350\t\f\2\2\u0350\u00b4"+ + "\3\2\2\2\u0351\u0352\7v\2\2\u0352\u0353\7t\2\2\u0353\u0354\7w\2\2\u0354"+ + "\u035b\7g\2\2\u0355\u0356\7h\2\2\u0356\u0357\7c\2\2\u0357\u0358\7n\2\2"+ + "\u0358\u0359\7u\2\2\u0359\u035b\7g\2\2\u035a\u0351\3\2\2\2\u035a\u0355"+ + "\3\2\2\2\u035b\u00b6\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\5\u00b9]\2"+ + "\u035e\u035f\7)\2\2\u035f\u0365\3\2\2\2\u0360\u0361\7)\2\2\u0361\u0362"+ + "\5\u00c1a\2\u0362\u0363\7)\2\2\u0363\u0365\3\2\2\2\u0364\u035c\3\2\2\2"+ + "\u0364\u0360\3\2\2\2\u0365\u00b8\3\2\2\2\u0366\u0367\n\r\2\2\u0367\u00ba"+ + "\3\2\2\2\u0368\u036a\7$\2\2\u0369\u036b\5\u00bd_\2\u036a\u0369\3\2\2\2"+ + "\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7$\2\2\u036d\u00bc"+ + "\3\2\2\2\u036e\u0370\5\u00bf`\2\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2"+ + "\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u00be\3\2\2\2\u0373\u0376"+ + "\n\16\2\2\u0374\u0376\5\u00c1a\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2"+ + "\2\u0376\u00c0\3\2\2\2\u0377\u0378\7^\2\2\u0378\u037c\t\17\2\2\u0379\u037c"+ + "\5\u00c3b\2\u037a\u037c\5\u00c7d\2\u037b\u0377\3\2\2\2\u037b\u0379\3\2"+ + "\2\2\u037b\u037a\3\2\2\2\u037c\u00c2\3\2\2\2\u037d\u037e\7^\2\2\u037e"+ + "\u0389\5\u008fH\2\u037f\u0380\7^\2\2\u0380\u0381\5\u008fH\2\u0381\u0382"+ + "\5\u008fH\2\u0382\u0389\3\2\2\2\u0383\u0384\7^\2\2\u0384\u0385\5\u00c5"+ + "c\2\u0385\u0386\5\u008fH\2\u0386\u0387\5\u008fH\2\u0387\u0389\3\2\2\2"+ + "\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0388\u0383\3\2\2\2\u0389\u00c4"+ + "\3\2\2\2\u038a\u038b\t\20\2\2\u038b\u00c6\3\2\2\2\u038c\u038d\7^\2\2\u038d"+ + "\u038e\7w\2\2\u038e\u038f\5\u0085C\2\u038f\u0390\5\u0085C\2\u0390\u0391"+ + "\5\u0085C\2\u0391\u0392\5\u0085C\2\u0392\u00c8\3\2\2\2\u0393\u0394\7p"+ + "\2\2\u0394\u0395\7w\2\2\u0395\u0396\7n\2\2\u0396\u0397\7n\2\2\u0397\u00ca"+ + "\3\2\2\2\u0398\u0399\7*\2\2\u0399\u00cc\3\2\2\2\u039a\u039b\7+\2\2\u039b"+ + "\u00ce\3\2\2\2\u039c\u039d\7}\2\2\u039d\u00d0\3\2\2\2\u039e\u039f\7\177"+ + "\2\2\u039f\u00d2\3\2\2\2\u03a0\u03a1\7]\2\2\u03a1\u00d4\3\2\2\2\u03a2"+ + "\u03a3\7_\2\2\u03a3\u00d6\3\2\2\2\u03a4\u03a5\7=\2\2\u03a5\u00d8\3\2\2"+ + "\2\u03a6\u03a7\7.\2\2\u03a7\u00da\3\2\2\2\u03a8\u03a9\7\60\2\2\u03a9\u00dc"+ + "\3\2\2\2\u03aa\u03ab\7?\2\2\u03ab\u00de\3\2\2\2\u03ac\u03ad\7@\2\2\u03ad"+ + "\u00e0\3\2\2\2\u03ae\u03af\7>\2\2\u03af\u00e2\3\2\2\2\u03b0\u03b1\7#\2"+ + "\2\u03b1\u00e4\3\2\2\2\u03b2\u03b3\7\u0080\2\2\u03b3\u00e6\3\2\2\2\u03b4"+ + "\u03b5\7A\2\2\u03b5\u00e8\3\2\2\2\u03b6\u03b7\7<\2\2\u03b7\u00ea\3\2\2"+ + "\2\u03b8\u03b9\7?\2\2\u03b9\u03ba\7?\2\2\u03ba\u00ec\3\2\2\2\u03bb\u03bc"+ + "\7>\2\2\u03bc\u03bd\7?\2\2\u03bd\u00ee\3\2\2\2\u03be\u03bf\7@\2\2\u03bf"+ + "\u03c0\7?\2\2\u03c0\u00f0\3\2\2\2\u03c1\u03c2\7#\2\2\u03c2\u03c3\7?\2"+ + "\2\u03c3\u00f2\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u03c6\7(\2\2\u03c6\u00f4"+ + "\3\2\2\2\u03c7\u03c8\7~\2\2\u03c8\u03c9\7~\2\2\u03c9\u00f6\3\2\2\2\u03ca"+ + "\u03cb\7-\2\2\u03cb\u03cc\7-\2\2\u03cc\u00f8\3\2\2\2\u03cd\u03ce\7/\2"+ + "\2\u03ce\u03cf\7/\2\2\u03cf\u00fa\3\2\2\2\u03d0\u03d1\7-\2\2\u03d1\u00fc"+ + "\3\2\2\2\u03d2\u03d3\7/\2\2\u03d3\u00fe\3\2\2\2\u03d4\u03d5\7,\2\2\u03d5"+ + "\u0100\3\2\2\2\u03d6\u03d7\7\61\2\2\u03d7\u0102\3\2\2\2\u03d8\u03d9\7"+ + "(\2\2\u03d9\u0104\3\2\2\2\u03da\u03db\7~\2\2\u03db\u0106\3\2\2\2\u03dc"+ + "\u03dd\7`\2\2\u03dd\u0108\3\2\2\2\u03de\u03df\7\'\2\2\u03df\u010a\3\2"+ + "\2\2\u03e0\u03e1\7/\2\2\u03e1\u03e2\7@\2\2\u03e2\u010c\3\2\2\2\u03e3\u03e4"+ + "\7<\2\2\u03e4\u03e5\7<\2\2\u03e5\u010e\3\2\2\2\u03e6\u03e7\7-\2\2\u03e7"+ + "\u03e8\7?\2\2\u03e8\u0110\3\2\2\2\u03e9\u03ea\7/\2\2\u03ea\u03eb\7?\2"+ + "\2\u03eb\u0112\3\2\2\2\u03ec\u03ed\7,\2\2\u03ed\u03ee\7?\2\2\u03ee\u0114"+ + "\3\2\2\2\u03ef\u03f0\7\61\2\2\u03f0\u03f1\7?\2\2\u03f1\u0116\3\2\2\2\u03f2"+ + "\u03f3\7(\2\2\u03f3\u03f4\7?\2\2\u03f4\u0118\3\2\2\2\u03f5\u03f6\7~\2"+ + "\2\u03f6\u03f7\7?\2\2\u03f7\u011a\3\2\2\2\u03f8\u03f9\7`\2\2\u03f9\u03fa"+ + "\7?\2\2\u03fa\u011c\3\2\2\2\u03fb\u03fc\7\'\2\2\u03fc\u03fd\7?\2\2\u03fd"+ + "\u011e\3\2\2\2\u03fe\u03ff\7>\2\2\u03ff\u0400\7>\2\2\u0400\u0401\7?\2"+ + "\2\u0401\u0120\3\2\2\2\u0402\u0403\7@\2\2\u0403\u0404\7@\2\2\u0404\u0405"+ + "\7?\2\2\u0405\u0122\3\2\2\2\u0406\u0407\7@\2\2\u0407\u0408\7@\2\2\u0408"+ + "\u0409\7@\2\2\u0409\u040a\7?\2\2\u040a\u0124\3\2\2\2\u040b\u040f\5\u0127"+ + "\u0094\2\u040c\u040e\5\u0129\u0095\2\u040d\u040c\3\2\2\2\u040e\u0411\3"+ + "\2\2\2\u040f\u040d\3\2\2\2\u040f\u0410\3\2\2\2\u0410\u0126\3\2\2\2\u0411"+ + "\u040f\3\2\2\2\u0412\u0419\t\21\2\2\u0413\u0414\n\22\2\2\u0414\u0419\6"+ + "\u0094\2\2\u0415\u0416\t\23\2\2\u0416\u0417\t\24\2\2\u0417\u0419\6\u0094"+ + "\3\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418\u0415\3\2\2\2\u0419"+ + "\u0128\3\2\2\2\u041a\u0421\t\25\2\2\u041b\u041c\n\22\2\2\u041c\u0421\6"+ + "\u0095\4\2\u041d\u041e\t\23\2\2\u041e\u041f\t\24\2\2\u041f\u0421\6\u0095"+ + "\5\2\u0420\u041a\3\2\2\2\u0420\u041b\3\2\2\2\u0420\u041d\3\2\2\2\u0421"+ + "\u012a\3\2\2\2\u0422\u0423\7B\2\2\u0423\u012c\3\2\2\2\u0424\u0425\7\60"+ + "\2\2\u0425\u0426\7\60\2\2\u0426\u0427\7\60\2\2\u0427\u012e\3\2\2\2\u0428"+ + "\u042a\t\26\2\2\u0429\u0428\3\2\2\2\u042a\u042b\3\2\2\2\u042b\u0429\3"+ + "\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\b\u0098\2\2"+ + "\u042e\u0130\3\2\2\2\u042f\u0430\7\61\2\2\u0430\u0431\7,\2\2\u0431\u0435"+ + "\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434\u0437\3\2\2\2"+ + "\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2\2\2\u0437\u0435"+ + "\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a\u043b\3\2\2\2\u043b"+ + "\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+ + "\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2\2\u0441\u0440\3\2\2\2"+ + "\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u0446"+ + "\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2\2\u0447\u0134\3\2\2"+ + "\28\2\u028c\u0290\u0294\u0298\u029c\u02a3\u02a8\u02aa\u02ae\u02b1\u02b5"+ + "\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5\u02e8\u02ef\u02f3"+ + "\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d\u0320\u0325\u032a"+ + "\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371\u0375\u037b\u0388"+ + "\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2"; + 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); + } + } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens b/i18n-maven-plugin/src/main/antlr4/Java8Lexer.tokens similarity index 81% rename from i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens rename to i18n-maven-plugin/src/main/antlr4/Java8Lexer.tokens index 22c63e5..52ef1ee 100644 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens +++ b/i18n-maven-plugin/src/main/antlr4/Java8Lexer.tokens @@ -1,201 +1,205 @@ -PACKAGE=32 -LT=68 -WHILE=50 -MOD=88 -CONST=10 -MOD_ASSIGN=96 +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 CASE=6 -NEW=31 +CATCH=7 CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 DO=13 -DIV_ASSIGN=92 -BREAK=4 -Identifier=100 -NOTEQUAL=76 -MUL_ASSIGN=91 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 FINAL=18 -RPAREN=58 -INC=79 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 IMPORT=25 -CARET=87 -THIS=43 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 RETURN=36 -DOUBLE=14 -VOID=48 -SUPER=40 -GOTO=23 -COMMENT=104 -RBRACK=62 -LSHIFT_ASSIGN=97 -GE=75 -RBRACE=60 -LINE_COMMENT=105 +SHORT=37 STATIC=38 -PRIVATE=33 -ADD_ASSIGN=89 -SWITCH=41 STRICTFP=39 -ELSE=15 -ELLIPSIS=102 -NATIVE=30 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 THROWS=45 -INT=27 -ASSERT=2 -MUL=83 +TRANSIENT=46 TRY=47 -WS=103 -BITOR=86 +VOID=48 +VOLATILE=49 +WHILE=50 +IntegerLiteral=51 FloatingPointLiteral=52 -OR=78 -GT=67 -CATCH=7 -THROW=44 BooleanLiteral=53 -PROTECTED=34 -DEC=80 -CLASS=9 -NullLiteral=56 -LBRACK=61 CharacterLiteral=54 -LBRACE=59 -FOR=21 -SUB=82 -FLOAT=20 -ABSTRACT=1 -AND=77 -AND_ASSIGN=93 -BITAND=85 +StringLiteral=55 +NullLiteral=56 LPAREN=57 -IF=22 -AT=101 -SYNCHRONIZED=42 -BOOLEAN=3 -IMPLEMENTS=24 -CONTINUE=11 +RPAREN=58 +LBRACE=59 +RBRACE=60 +LBRACK=61 +RBRACK=62 +SEMI=63 COMMA=64 -TRANSIENT=46 -EQUAL=73 -XOR_ASSIGN=95 -TILDE=70 DOT=65 -ADD=81 -BYTE=5 -VOLATILE=49 -DEFAULT=12 -SHORT=37 +ASSIGN=66 +GT=67 +LT=68 BANG=69 -INSTANCEOF=26 -RSHIFT_ASSIGN=98 -SEMI=63 -StringLiteral=55 -COLON=72 -OR_ASSIGN=94 -ENUM=16 +TILDE=70 QUESTION=71 -FINALLY=19 -URSHIFT_ASSIGN=99 -ASSIGN=66 -INTERFACE=28 -IntegerLiteral=51 -DIV=84 -LONG=29 -PUBLIC=35 -EXTENDS=17 -SUB_ASSIGN=90 +COLON=72 +EQUAL=73 LE=74 -'instanceof'=26 -'>='=75 -'~'=70 -'/'=84 -'=='=73 -'/='=92 -'switch'=41 -'%='=96 -'implements'=24 -'>'=67 -'||'=78 -'this'=43 -'&&'=77 -';'=63 -'volatile'=49 -'return'=36 -'for'=21 -'protected'=34 -'+'=81 -'.'=65 -'^'=87 +GE=75 +NOTEQUAL=76 +AND=77 +OR=78 +INC=79 +DEC=80 +ADD=81 +SUB=82 +MUL=83 +DIV=84 +BITAND=85 +BITOR=86 +CARET=87 +MOD=88 +ARROW=89 +COLONCOLON=90 +ADD_ASSIGN=91 +SUB_ASSIGN=92 +MUL_ASSIGN=93 +DIV_ASSIGN=94 +AND_ASSIGN=95 +OR_ASSIGN=96 +XOR_ASSIGN=97 +MOD_ASSIGN=98 +LSHIFT_ASSIGN=99 +RSHIFT_ASSIGN=100 +URSHIFT_ASSIGN=101 +Identifier=102 +AT=103 +ELLIPSIS=104 +WS=105 +COMMENT=106 +LINE_COMMENT=107 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 'byte'=5 -'import'=25 -'++'=79 -'static'=38 -'else'=15 +'case'=6 'catch'=7 -'final'=18 -'^='=95 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 'extends'=17 -'+='=89 +'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 -'break'=4 -'...'=102 -'{'=59 -'>>='=98 +'new'=31 'package'=32 -'>>>='=99 -'void'=48 -'?'=71 -'try'=47 'private'=33 -'int'=27 -'&='=93 -'if'=22 -':'=72 -'('=57 -'-'=82 -'while'=50 -','=64 -'synchronized'=42 -'default'=12 +'protected'=34 'public'=35 -'-='=90 -'<<='=97 -']'=62 +'return'=36 'short'=37 -'long'=29 -'enum'=16 -'!'=69 -'transient'=46 -'|'=86 -'finally'=19 -'assert'=2 -'class'=9 -'new'=31 -'|='=94 +'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 'null'=56 -'const'=10 -'goto'=23 -'='=66 -'@'=101 -'throw'=44 +'('=57 ')'=58 -'*='=91 -'%'=88 -'do'=13 -'super'=40 -'case'=6 -'char'=8 -'strictfp'=39 -'float'=20 +'{'=59 '}'=60 -'boolean'=3 -'abstract'=1 -'double'=14 +'['=61 +']'=62 +';'=63 +','=64 +'.'=65 +'='=66 +'>'=67 +'<'=68 +'!'=69 +'~'=70 +'?'=71 +':'=72 +'=='=73 '<='=74 +'>='=75 '!='=76 -'continue'=11 +'&&'=77 +'||'=78 +'++'=79 '--'=80 -'<'=68 +'+'=81 +'-'=82 '*'=83 -'['=61 +'/'=84 '&'=85 -'interface'=28 +'|'=86 +'^'=87 +'%'=88 +'->'=89 +'::'=90 +'+='=91 +'-='=92 +'*='=93 +'/='=94 +'&='=95 +'|='=96 +'^='=97 +'%='=98 +'<<='=99 +'>>='=100 +'>>>='=101 +'@'=103 +'...'=104 diff --git a/i18n-maven-plugin/src/main/antlr4/Java8Parser.java b/i18n-maven-plugin/src/main/antlr4/Java8Parser.java new file mode 100644 index 0000000..1f83c38 --- /dev/null +++ b/i18n-maven-plugin/src/main/antlr4/Java8Parser.java @@ -0,0 +1,17844 @@ +// Generated from ../projets/nuiton-all/i18n/i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, + ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, + OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, + URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, + LINE_COMMENT=107; + public static final int + RULE_literal = 0, RULE_type = 1, RULE_primitiveType = 2, RULE_numericType = 3, + RULE_integralType = 4, RULE_floatingPointType = 5, RULE_referenceType = 6, + RULE_classOrInterfaceType = 7, RULE_classType = 8, RULE_classType_lf_classOrInterfaceType = 9, + RULE_classType_lfno_classOrInterfaceType = 10, RULE_interfaceType = 11, + RULE_interfaceType_lf_classOrInterfaceType = 12, RULE_interfaceType_lfno_classOrInterfaceType = 13, + RULE_typeVariable = 14, RULE_arrayType = 15, RULE_dims = 16, RULE_typeParameter = 17, + RULE_typeParameterModifier = 18, RULE_typeBound = 19, RULE_additionalBound = 20, + RULE_typeArguments = 21, RULE_typeArgumentList = 22, RULE_typeArgument = 23, + RULE_wildcard = 24, RULE_wildcardBounds = 25, RULE_packageName = 26, RULE_typeName = 27, + RULE_packageOrTypeName = 28, RULE_expressionName = 29, RULE_methodName = 30, + RULE_ambiguousName = 31, RULE_compilationUnit = 32, RULE_packageDeclaration = 33, + RULE_packageModifier = 34, RULE_importDeclaration = 35, RULE_singleTypeImportDeclaration = 36, + RULE_typeImportOnDemandDeclaration = 37, RULE_singleStaticImportDeclaration = 38, + RULE_staticImportOnDemandDeclaration = 39, RULE_typeDeclaration = 40, + RULE_classDeclaration = 41, RULE_normalClassDeclaration = 42, RULE_classModifier = 43, + RULE_typeParameters = 44, RULE_typeParameterList = 45, RULE_superclass = 46, + RULE_superinterfaces = 47, RULE_interfaceTypeList = 48, RULE_classBody = 49, + RULE_classBodyDeclaration = 50, RULE_classMemberDeclaration = 51, RULE_fieldDeclaration = 52, + RULE_fieldModifier = 53, RULE_variableDeclaratorList = 54, RULE_variableDeclarator = 55, + RULE_variableDeclaratorId = 56, RULE_variableInitializer = 57, RULE_unannType = 58, + RULE_unannPrimitiveType = 59, RULE_unannReferenceType = 60, RULE_unannClassOrInterfaceType = 61, + RULE_unannClassType = 62, RULE_unannClassType_lf_unannClassOrInterfaceType = 63, + RULE_unannClassType_lfno_unannClassOrInterfaceType = 64, RULE_unannInterfaceType = 65, + RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 66, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 67, + RULE_unannTypeVariable = 68, RULE_unannArrayType = 69, RULE_methodDeclaration = 70, + RULE_methodModifier = 71, RULE_methodHeader = 72, RULE_result = 73, RULE_methodDeclarator = 74, + RULE_formalParameterList = 75, RULE_formalParameters = 76, RULE_formalParameter = 77, + RULE_variableModifier = 78, RULE_lastFormalParameter = 79, RULE_receiverParameter = 80, + RULE_throws_ = 81, RULE_exceptionTypeList = 82, RULE_exceptionType = 83, + RULE_methodBody = 84, RULE_instanceInitializer = 85, RULE_staticInitializer = 86, + RULE_constructorDeclaration = 87, RULE_constructorModifier = 88, RULE_constructorDeclarator = 89, + RULE_simpleTypeName = 90, RULE_constructorBody = 91, RULE_explicitConstructorInvocation = 92, + RULE_enumDeclaration = 93, RULE_enumBody = 94, RULE_enumConstantList = 95, + RULE_enumConstant = 96, RULE_enumConstantModifier = 97, RULE_enumBodyDeclarations = 98, + RULE_interfaceDeclaration = 99, RULE_normalInterfaceDeclaration = 100, + RULE_interfaceModifier = 101, RULE_extendsInterfaces = 102, RULE_interfaceBody = 103, + RULE_interfaceMemberDeclaration = 104, RULE_constantDeclaration = 105, + RULE_constantModifier = 106, RULE_interfaceMethodDeclaration = 107, RULE_interfaceMethodModifier = 108, + RULE_annotationTypeDeclaration = 109, RULE_annotationTypeBody = 110, RULE_annotationTypeMemberDeclaration = 111, + RULE_annotationTypeElementDeclaration = 112, RULE_annotationTypeElementModifier = 113, + RULE_defaultValue = 114, RULE_annotation = 115, RULE_normalAnnotation = 116, + RULE_elementValuePairList = 117, RULE_elementValuePair = 118, RULE_elementValue = 119, + RULE_elementValueArrayInitializer = 120, RULE_elementValueList = 121, + RULE_markerAnnotation = 122, RULE_singleElementAnnotation = 123, RULE_arrayInitializer = 124, + RULE_variableInitializerList = 125, RULE_block = 126, RULE_blockStatements = 127, + RULE_blockStatement = 128, RULE_localVariableDeclarationStatement = 129, + RULE_localVariableDeclaration = 130, RULE_statement = 131, RULE_statementNoShortIf = 132, + RULE_statementWithoutTrailingSubstatement = 133, RULE_emptyStatement = 134, + RULE_labeledStatement = 135, RULE_labeledStatementNoShortIf = 136, RULE_expressionStatement = 137, + RULE_statementExpression = 138, RULE_ifThenStatement = 139, RULE_ifThenElseStatement = 140, + RULE_ifThenElseStatementNoShortIf = 141, RULE_assertStatement = 142, RULE_switchStatement = 143, + RULE_switchBlock = 144, RULE_switchBlockStatementGroup = 145, RULE_switchLabels = 146, + RULE_switchLabel = 147, RULE_enumConstantName = 148, RULE_whileStatement = 149, + RULE_whileStatementNoShortIf = 150, RULE_doStatement = 151, RULE_forStatement = 152, + RULE_forStatementNoShortIf = 153, RULE_basicForStatement = 154, RULE_basicForStatementNoShortIf = 155, + RULE_forInit = 156, RULE_forUpdate = 157, RULE_statementExpressionList = 158, + RULE_enhancedForStatement = 159, RULE_enhancedForStatementNoShortIf = 160, + RULE_breakStatement = 161, RULE_continueStatement = 162, RULE_returnStatement = 163, + RULE_throwStatement = 164, RULE_synchronizedStatement = 165, RULE_tryStatement = 166, + RULE_catches = 167, RULE_catchClause = 168, RULE_catchFormalParameter = 169, + RULE_catchType = 170, RULE_finally_ = 171, RULE_tryWithResourcesStatement = 172, + RULE_resourceSpecification = 173, RULE_resourceList = 174, RULE_resource = 175, + RULE_primary = 176, RULE_primaryNoNewArray = 177, RULE_primaryNoNewArray_lf_arrayAccess = 178, + RULE_primaryNoNewArray_lfno_arrayAccess = 179, RULE_primaryNoNewArray_lf_primary = 180, + RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 181, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 182, + RULE_primaryNoNewArray_lfno_primary = 183, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 184, + RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 185, + RULE_classInstanceCreationExpression = 186, RULE_classInstanceCreationExpression_lf_primary = 187, + RULE_classInstanceCreationExpression_lfno_primary = 188, RULE_typeArgumentsOrDiamond = 189, + RULE_fieldAccess = 190, RULE_fieldAccess_lf_primary = 191, RULE_fieldAccess_lfno_primary = 192, + RULE_arrayAccess = 193, RULE_arrayAccess_lf_primary = 194, RULE_arrayAccess_lfno_primary = 195, + RULE_methodInvocation = 196, RULE_methodInvocation_lf_primary = 197, RULE_methodInvocation_lfno_primary = 198, + RULE_argumentList = 199, RULE_methodReference = 200, RULE_methodReference_lf_primary = 201, + RULE_methodReference_lfno_primary = 202, RULE_arrayCreationExpression = 203, + RULE_dimExprs = 204, RULE_dimExpr = 205, RULE_constantExpression = 206, + RULE_expression = 207, RULE_lambdaExpression = 208, RULE_lambdaParameters = 209, + RULE_inferredFormalParameterList = 210, RULE_lambdaBody = 211, RULE_assignmentExpression = 212, + RULE_assignment = 213, RULE_leftHandSide = 214, RULE_assignmentOperator = 215, + RULE_conditionalExpression = 216, RULE_conditionalOrExpression = 217, + RULE_conditionalAndExpression = 218, RULE_inclusiveOrExpression = 219, + RULE_exclusiveOrExpression = 220, RULE_andExpression = 221, RULE_equalityExpression = 222, + RULE_relationalExpression = 223, RULE_shiftExpression = 224, RULE_additiveExpression = 225, + RULE_multiplicativeExpression = 226, RULE_unaryExpression = 227, RULE_preIncrementExpression = 228, + RULE_preDecrementExpression = 229, RULE_unaryExpressionNotPlusMinus = 230, + RULE_postfixExpression = 231, RULE_postIncrementExpression = 232, RULE_postIncrementExpression_lf_postfixExpression = 233, + RULE_postDecrementExpression = 234, RULE_postDecrementExpression_lf_postfixExpression = 235, + RULE_castExpression = 236; + public static final String[] ruleNames = { + "literal", "type", "primitiveType", "numericType", "integralType", "floatingPointType", + "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", + "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", + "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", + "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", + "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", + "packageName", "typeName", "packageOrTypeName", "expressionName", "methodName", + "ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier", + "importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", + "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration", + "classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters", + "typeParameterList", "superclass", "superinterfaces", "interfaceTypeList", + "classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration", + "fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", + "variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType", + "unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", + "unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType", + "unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", + "unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", + "methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", + "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", + "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", + "staticInitializer", "constructorDeclaration", "constructorModifier", + "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", + "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", + "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", + "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", + "constantDeclaration", "constantModifier", "interfaceMethodDeclaration", + "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", + "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", + "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", + "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", + "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", + "variableInitializerList", "block", "blockStatements", "blockStatement", + "localVariableDeclarationStatement", "localVariableDeclaration", "statement", + "statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement", + "labeledStatement", "labeledStatementNoShortIf", "expressionStatement", + "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", + "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", + "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", + "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", + "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", + "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", + "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", + "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", + "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", + "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", + "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", + "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", + "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", + "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression", + "classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary", + "typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", + "arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", + "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", + "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", + "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", + "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", + "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", + "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", + "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", + "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", + "unaryExpression", "preIncrementExpression", "preDecrementExpression", + "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", + "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", + "postDecrementExpression_lf_postfixExpression", "castExpression" + }; + + private static final String[] _LITERAL_NAMES = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", + "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", + "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", + "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + 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 "Java8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public Java8Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + public static class LiteralContext extends ParserRuleContext { + public TerminalNode IntegerLiteral() { return getToken(Java8Parser.IntegerLiteral, 0); } + public TerminalNode FloatingPointLiteral() { return getToken(Java8Parser.FloatingPointLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(Java8Parser.BooleanLiteral, 0); } + public TerminalNode CharacterLiteral() { return getToken(Java8Parser.CharacterLiteral, 0); } + public TerminalNode StringLiteral() { return getToken(Java8Parser.StringLiteral, 0); } + public TerminalNode NullLiteral() { return getToken(Java8Parser.NullLiteral, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(474); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public TypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitType(this); + else return visitor.visitChildren(this); + } + } + + public final TypeContext type() throws RecognitionException { + TypeContext _localctx = new TypeContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_type); + try { + setState(478); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(476); + primitiveType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(477); + referenceType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimitiveTypeContext extends ParserRuleContext { + public NumericTypeContext numericType() { + return getRuleContext(NumericTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primitiveType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimitiveType(this); + else return visitor.visitChildren(this); + } + } + + public final PrimitiveTypeContext primitiveType() throws RecognitionException { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_primitiveType); + int _la; + try { + setState(494); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(483); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(480); + annotation(); + } + } + setState(485); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(486); + numericType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(490); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(487); + annotation(); + } + } + setState(492); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(493); + match(BOOLEAN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NumericTypeContext extends ParserRuleContext { + public IntegralTypeContext integralType() { + return getRuleContext(IntegralTypeContext.class,0); + } + public FloatingPointTypeContext floatingPointType() { + return getRuleContext(FloatingPointTypeContext.class,0); + } + public NumericTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNumericType(this); + else return visitor.visitChildren(this); + } + } + + public final NumericTypeContext numericType() throws RecognitionException { + NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_numericType); + try { + setState(498); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 1); + { + setState(496); + integralType(); + } + break; + case DOUBLE: + case FLOAT: + enterOuterAlt(_localctx, 2); + { + setState(497); + floatingPointType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IntegralTypeContext extends ParserRuleContext { + public IntegralTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integralType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIntegralType(this); + else return visitor.visitChildren(this); + } + } + + public final IntegralTypeContext integralType() throws RecognitionException { + IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_integralType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(500); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FloatingPointTypeContext extends ParserRuleContext { + public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_floatingPointType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFloatingPointType(this); + else return visitor.visitChildren(this); + } + } + + public final FloatingPointTypeContext floatingPointType() throws RecognitionException { + FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_floatingPointType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(502); + _la = _input.LA(1); + if ( !(_la==DOUBLE || _la==FLOAT) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReferenceTypeContext extends ParserRuleContext { + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public ReferenceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_referenceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReferenceType(this); + else return visitor.visitChildren(this); + } + } + + public final ReferenceTypeContext referenceType() throws RecognitionException { + ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_referenceType); + try { + setState(507); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(504); + classOrInterfaceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(505); + typeVariable(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(506); + arrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() { + return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0); + } + public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() { + return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class); + } + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) { + return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i); + } + public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() { + return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class); + } + public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) { + return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i); + } + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { + ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_classOrInterfaceType); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(511); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { + case 1: + { + setState(509); + classType_lfno_classOrInterfaceType(); + } + break; + case 2: + { + setState(510); + interfaceType_lfno_classOrInterfaceType(); + } + break; + } + setState(517); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(515); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + { + setState(513); + classType_lf_classOrInterfaceType(); + } + break; + case 2: + { + setState(514); + interfaceType_lf_classOrInterfaceType(); + } + break; + } + } + } + setState(519); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public ClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassTypeContext classType() throws RecognitionException { + ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_classType); + int _la; + try { + setState(542); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(523); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(520); + annotation(); + } + } + setState(525); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(526); + match(Identifier); + setState(528); + _la = _input.LA(1); + if (_la==LT) { + { + setState(527); + typeArguments(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(530); + classOrInterfaceType(); + setState(531); + match(DOT); + setState(535); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(532); + annotation(); + } + } + setState(537); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(538); + match(Identifier); + setState(540); + _la = _input.LA(1); + if (_la==LT) { + { + setState(539); + typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType_lf_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException { + ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_classType_lf_classOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(544); + match(DOT); + setState(548); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(545); + annotation(); + } + } + setState(550); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(551); + match(Identifier); + setState(553); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { + case 1: + { + setState(552); + typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType_lfno_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException { + ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_classType_lfno_classOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(558); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(555); + annotation(); + } + } + setState(560); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(561); + match(Identifier); + setState(563); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + { + setState(562); + typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceTypeContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public InterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceTypeContext interfaceType() throws RecognitionException { + InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_interfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(565); + classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() { + return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType_lf_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException { + InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_interfaceType_lf_classOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(567); + classType_lf_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType_lfno_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException { + InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_interfaceType_lfno_classOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(569); + classType_lfno_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeVariableContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeVariable; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeVariable(this); + else return visitor.visitChildren(this); + } + } + + public final TypeVariableContext typeVariable() throws RecognitionException { + TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_typeVariable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(574); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(571); + annotation(); + } + } + setState(576); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(577); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayTypeContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ArrayTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayType(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayTypeContext arrayType() throws RecognitionException { + ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_arrayType); + try { + setState(588); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(579); + primitiveType(); + setState(580); + dims(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(582); + classOrInterfaceType(); + setState(583); + dims(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(585); + typeVariable(); + setState(586); + dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimsContext extends ParserRuleContext { + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public DimsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dims; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDims(this); + else return visitor.visitChildren(this); + } + } + + public final DimsContext dims() throws RecognitionException { + DimsContext _localctx = new DimsContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_dims); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(593); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(590); + annotation(); + } + } + setState(595); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(596); + match(LBRACK); + setState(597); + match(RBRACK); + setState(608); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,22,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(601); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(598); + annotation(); + } + } + setState(603); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(604); + match(LBRACK); + setState(605); + match(RBRACK); + } + } + } + setState(610); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,22,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<TypeParameterModifierContext> typeParameterModifier() { + return getRuleContexts(TypeParameterModifierContext.class); + } + public TypeParameterModifierContext typeParameterModifier(int i) { + return getRuleContext(TypeParameterModifierContext.class,i); + } + public TypeBoundContext typeBound() { + return getRuleContext(TypeBoundContext.class,0); + } + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(614); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(611); + typeParameterModifier(); + } + } + setState(616); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(617); + match(Identifier); + setState(619); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(618); + typeBound(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameterModifier(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { + TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_typeParameterModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeBoundContext extends ParserRuleContext { + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public List<AdditionalBoundContext> additionalBound() { + return getRuleContexts(AdditionalBoundContext.class); + } + public AdditionalBoundContext additionalBound(int i) { + return getRuleContext(AdditionalBoundContext.class,i); + } + public TypeBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeBound; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeBound(this); + else return visitor.visitChildren(this); + } + } + + public final TypeBoundContext typeBound() throws RecognitionException { + TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_typeBound); + int _la; + try { + setState(633); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(623); + match(EXTENDS); + setState(624); + typeVariable(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(625); + match(EXTENDS); + setState(626); + classOrInterfaceType(); + setState(630); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(627); + additionalBound(); + } + } + setState(632); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AdditionalBoundContext extends ParserRuleContext { + public InterfaceTypeContext interfaceType() { + return getRuleContext(InterfaceTypeContext.class,0); + } + public AdditionalBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additionalBound; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAdditionalBound(this); + else return visitor.visitChildren(this); + } + } + + public final AdditionalBoundContext additionalBound() throws RecognitionException { + AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_additionalBound); + try { + enterOuterAlt(_localctx, 1); + { + setState(635); + match(BITAND); + setState(636); + interfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentsContext extends ParserRuleContext { + public TypeArgumentListContext typeArgumentList() { + return getRuleContext(TypeArgumentListContext.class,0); + } + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArguments; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_typeArguments); + try { + enterOuterAlt(_localctx, 1); + { + setState(638); + match(LT); + setState(639); + typeArgumentList(); + setState(640); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentListContext extends ParserRuleContext { + public List<TypeArgumentContext> typeArgument() { + return getRuleContexts(TypeArgumentContext.class); + } + public TypeArgumentContext typeArgument(int i) { + return getRuleContext(TypeArgumentContext.class,i); + } + public TypeArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentListContext typeArgumentList() throws RecognitionException { + TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_typeArgumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(642); + typeArgument(); + setState(647); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(643); + match(COMMA); + setState(644); + typeArgument(); + } + } + setState(649); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentContext extends ParserRuleContext { + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public WildcardContext wildcard() { + return getRuleContext(WildcardContext.class,0); + } + public TypeArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgument; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgument(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentContext typeArgument() throws RecognitionException { + TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_typeArgument); + try { + setState(652); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(650); + referenceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(651); + wildcard(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WildcardContext extends ParserRuleContext { + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public WildcardBoundsContext wildcardBounds() { + return getRuleContext(WildcardBoundsContext.class,0); + } + public WildcardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_wildcard; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWildcard(this); + else return visitor.visitChildren(this); + } + } + + public final WildcardContext wildcard() throws RecognitionException { + WildcardContext _localctx = new WildcardContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_wildcard); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(657); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(654); + annotation(); + } + } + setState(659); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(660); + match(QUESTION); + setState(662); + _la = _input.LA(1); + if (_la==EXTENDS || _la==SUPER) { + { + setState(661); + wildcardBounds(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WildcardBoundsContext extends ParserRuleContext { + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public WildcardBoundsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_wildcardBounds; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWildcardBounds(this); + else return visitor.visitChildren(this); + } + } + + public final WildcardBoundsContext wildcardBounds() throws RecognitionException { + WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_wildcardBounds); + try { + setState(668); + switch (_input.LA(1)) { + case EXTENDS: + enterOuterAlt(_localctx, 1); + { + setState(664); + match(EXTENDS); + setState(665); + referenceType(); + } + break; + case SUPER: + enterOuterAlt(_localctx, 2); + { + setState(666); + match(SUPER); + setState(667); + referenceType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageNameContext packageName() { + return getRuleContext(PackageNameContext.class,0); + } + public PackageNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageName(this); + else return visitor.visitChildren(this); + } + } + + public final PackageNameContext packageName() throws RecognitionException { + return packageName(0); + } + + private PackageNameContext packageName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState); + PackageNameContext _prevctx = _localctx; + int _startState = 52; + enterRecursionRule(_localctx, 52, RULE_packageName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(671); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(678); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_packageName); + setState(673); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(674); + match(DOT); + setState(675); + match(Identifier); + } + } + } + setState(680); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class TypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public TypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final TypeNameContext typeName() throws RecognitionException { + TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_typeName); + try { + setState(686); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(681); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(682); + packageOrTypeName(0); + setState(683); + match(DOT); + setState(684); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageOrTypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageOrTypeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageOrTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException { + return packageOrTypeName(0); + } + + private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState); + PackageOrTypeNameContext _prevctx = _localctx; + int _startState = 56; + enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(689); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(696); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageOrTypeNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName); + setState(691); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(692); + match(DOT); + setState(693); + match(Identifier); + } + } + } + setState(698); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ExpressionNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AmbiguousNameContext ambiguousName() { + return getRuleContext(AmbiguousNameContext.class,0); + } + public ExpressionNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpressionName(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionNameContext expressionName() throws RecognitionException { + ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_expressionName); + try { + setState(704); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(699); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(700); + ambiguousName(0); + setState(701); + match(DOT); + setState(702); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public MethodNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodName(this); + else return visitor.visitChildren(this); + } + } + + public final MethodNameContext methodName() throws RecognitionException { + MethodNameContext _localctx = new MethodNameContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_methodName); + try { + enterOuterAlt(_localctx, 1); + { + setState(706); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AmbiguousNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AmbiguousNameContext ambiguousName() { + return getRuleContext(AmbiguousNameContext.class,0); + } + public AmbiguousNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ambiguousName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAmbiguousName(this); + else return visitor.visitChildren(this); + } + } + + public final AmbiguousNameContext ambiguousName() throws RecognitionException { + return ambiguousName(0); + } + + private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState); + AmbiguousNameContext _prevctx = _localctx; + int _startState = 62; + enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(709); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AmbiguousNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName); + setState(711); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(712); + match(DOT); + setState(713); + match(Identifier); + } + } + } + setState(718); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class CompilationUnitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(Java8Parser.EOF, 0); } + public PackageDeclarationContext packageDeclaration() { + return getRuleContext(PackageDeclarationContext.class,0); + } + public List<ImportDeclarationContext> importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class,i); + } + public List<TypeDeclarationContext> typeDeclaration() { + return getRuleContexts(TypeDeclarationContext.class); + } + public TypeDeclarationContext typeDeclaration(int i) { + return getRuleContext(TypeDeclarationContext.class,i); + } + public CompilationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compilationUnit; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCompilationUnit(this); + else return visitor.visitChildren(this); + } + } + + public final CompilationUnitContext compilationUnit() throws RecognitionException { + CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_compilationUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(720); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + case 1: + { + setState(719); + packageDeclaration(); + } + break; + } + setState(725); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IMPORT) { + { + { + setState(722); + importDeclaration(); + } + } + setState(727); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(731); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) { + { + { + setState(728); + typeDeclaration(); + } + } + setState(733); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(734); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageDeclarationContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public List<PackageModifierContext> packageModifier() { + return getRuleContexts(PackageModifierContext.class); + } + public PackageModifierContext packageModifier(int i) { + return getRuleContext(PackageModifierContext.class,i); + } + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final PackageDeclarationContext packageDeclaration() throws RecognitionException { + PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_packageDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(739); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(736); + packageModifier(); + } + } + setState(741); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(742); + match(PACKAGE); + setState(743); + match(Identifier); + setState(748); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(744); + match(DOT); + setState(745); + match(Identifier); + } + } + setState(750); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(751); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public PackageModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageModifier(this); + else return visitor.visitChildren(this); + } + } + + public final PackageModifierContext packageModifier() throws RecognitionException { + PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_packageModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(753); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ImportDeclarationContext extends ParserRuleContext { + public SingleTypeImportDeclarationContext singleTypeImportDeclaration() { + return getRuleContext(SingleTypeImportDeclarationContext.class,0); + } + public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() { + return getRuleContext(TypeImportOnDemandDeclarationContext.class,0); + } + public SingleStaticImportDeclarationContext singleStaticImportDeclaration() { + return getRuleContext(SingleStaticImportDeclarationContext.class,0); + } + public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() { + return getRuleContext(StaticImportOnDemandDeclarationContext.class,0); + } + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ImportDeclarationContext importDeclaration() throws RecognitionException { + ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_importDeclaration); + try { + setState(759); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(755); + singleTypeImportDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(756); + typeImportOnDemandDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(757); + singleStaticImportDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(758); + staticImportOnDemandDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleTypeImportDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleTypeImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException { + SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_singleTypeImportDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(761); + match(IMPORT); + setState(762); + typeName(); + setState(763); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext { + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeImportOnDemandDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException { + TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_typeImportOnDemandDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(765); + match(IMPORT); + setState(766); + packageOrTypeName(0); + setState(767); + match(DOT); + setState(768); + match(MUL); + setState(769); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleStaticImportDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleStaticImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException { + SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_singleStaticImportDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(771); + match(IMPORT); + setState(772); + match(STATIC); + setState(773); + typeName(); + setState(774); + match(DOT); + setState(775); + match(Identifier); + setState(776); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStaticImportOnDemandDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException { + StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_staticImportOnDemandDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(778); + match(IMPORT); + setState(779); + match(STATIC); + setState(780); + typeName(); + setState(781); + match(DOT); + setState(782); + match(MUL); + setState(783); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeDeclarationContext typeDeclaration() throws RecognitionException { + TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_typeDeclaration); + try { + setState(788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(785); + classDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(786); + interfaceDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(787); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassDeclarationContext extends ParserRuleContext { + public NormalClassDeclarationContext normalClassDeclaration() { + return getRuleContext(NormalClassDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_classDeclaration); + try { + setState(792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(790); + normalClassDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(791); + enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalClassDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public List<ClassModifierContext> classModifier() { + return getRuleContexts(ClassModifierContext.class); + } + public ClassModifierContext classModifier(int i) { + return getRuleContext(ClassModifierContext.class,i); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public SuperclassContext superclass() { + return getRuleContext(SuperclassContext.class,0); + } + public SuperinterfacesContext superinterfaces() { + return getRuleContext(SuperinterfacesContext.class,0); + } + public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalClassDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException { + NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_normalClassDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(797); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(794); + classModifier(); + } + } + setState(799); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(800); + match(CLASS); + setState(801); + match(Identifier); + setState(803); + _la = _input.LA(1); + if (_la==LT) { + { + setState(802); + typeParameters(); + } + } + + setState(806); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(805); + superclass(); + } + } + + setState(809); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(808); + superinterfaces(); + } + } + + setState(811); + classBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ClassModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ClassModifierContext classModifier() throws RecognitionException { + ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_classModifier); + try { + setState(821); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(813); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(814); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(815); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(816); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(817); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(818); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 7); + { + setState(819); + match(FINAL); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 8); + { + setState(820); + 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; + } + + public static class TypeParametersContext extends ParserRuleContext { + public TypeParameterListContext typeParameterList() { + return getRuleContext(TypeParameterListContext.class,0); + } + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_typeParameters); + try { + enterOuterAlt(_localctx, 1); + { + setState(823); + match(LT); + setState(824); + typeParameterList(); + setState(825); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterListContext extends ParserRuleContext { + public List<TypeParameterContext> typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class,i); + } + public TypeParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterListContext typeParameterList() throws RecognitionException { + TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_typeParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(827); + typeParameter(); + setState(832); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(828); + match(COMMA); + setState(829); + typeParameter(); + } + } + setState(834); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuperclassContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public SuperclassContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_superclass; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSuperclass(this); + else return visitor.visitChildren(this); + } + } + + public final SuperclassContext superclass() throws RecognitionException { + SuperclassContext _localctx = new SuperclassContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_superclass); + try { + enterOuterAlt(_localctx, 1); + { + setState(835); + match(EXTENDS); + setState(836); + classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuperinterfacesContext extends ParserRuleContext { + public InterfaceTypeListContext interfaceTypeList() { + return getRuleContext(InterfaceTypeListContext.class,0); + } + public SuperinterfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_superinterfaces; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSuperinterfaces(this); + else return visitor.visitChildren(this); + } + } + + public final SuperinterfacesContext superinterfaces() throws RecognitionException { + SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_superinterfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(838); + match(IMPLEMENTS); + setState(839); + interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceTypeListContext extends ParserRuleContext { + public List<InterfaceTypeContext> interfaceType() { + return getRuleContexts(InterfaceTypeContext.class); + } + public InterfaceTypeContext interfaceType(int i) { + return getRuleContext(InterfaceTypeContext.class,i); + } + public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceTypeList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException { + InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_interfaceTypeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(841); + interfaceType(); + setState(846); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(842); + match(COMMA); + setState(843); + interfaceType(); + } + } + setState(848); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyContext extends ParserRuleContext { + public List<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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassBody(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyContext classBody() throws RecognitionException { + ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_classBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(849); + match(LBRACE); + setState(853); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] + { + { + setState(850); + classBodyDeclaration(); + } + } + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(856); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyDeclarationContext extends ParserRuleContext { + public ClassMemberDeclarationContext classMemberDeclaration() { + return getRuleContext(ClassMemberDeclarationContext.class,0); + } + public InstanceInitializerContext instanceInitializer() { + return getRuleContext(InstanceInitializerContext.class,0); + } + public StaticInitializerContext staticInitializer() { + return getRuleContext(StaticInitializerContext.class,0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassBodyDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { + ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_classBodyDeclaration); + try { + setState(862); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(858); + classMemberDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(859); + instanceInitializer(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(860); + staticInitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(861); + constructorDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassMemberDeclarationContext extends ParserRuleContext { + public FieldDeclarationContext fieldDeclaration() { + return getRuleContext(FieldDeclarationContext.class,0); + } + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { + ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_classMemberDeclaration); + try { + setState(869); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(864); + fieldDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(865); + methodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(866); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(867); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(868); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<FieldModifierContext> fieldModifier() { + return getRuleContexts(FieldModifierContext.class); + } + public FieldModifierContext fieldModifier(int i) { + return getRuleContext(FieldModifierContext.class,i); + } + public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { + FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_fieldDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(874); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0) || _la==AT) { + { + { + setState(871); + fieldModifier(); + } + } + setState(876); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(877); + unannType(); + setState(878); + variableDeclaratorList(); + setState(879); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public FieldModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldModifier(this); + else return visitor.visitChildren(this); + } + } + + public final FieldModifierContext fieldModifier() throws RecognitionException { + FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_fieldModifier); + try { + setState(889); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(881); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(882); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(883); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(884); + match(PRIVATE); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(885); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 6); + { + setState(886); + match(FINAL); + } + break; + case TRANSIENT: + enterOuterAlt(_localctx, 7); + { + setState(887); + match(TRANSIENT); + } + break; + case VOLATILE: + enterOuterAlt(_localctx, 8); + { + setState(888); + 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; + } + + public static class VariableDeclaratorListContext extends ParserRuleContext { + public List<VariableDeclaratorContext> variableDeclarator() { + return getRuleContexts(VariableDeclaratorContext.class); + } + public VariableDeclaratorContext variableDeclarator(int i) { + return getRuleContext(VariableDeclaratorContext.class,i); + } + public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclaratorList(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException { + VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_variableDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(891); + variableDeclarator(); + setState(896); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(892); + match(COMMA); + setState(893); + variableDeclarator(); + } + } + setState(898); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorContext extends ParserRuleContext { + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { + VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_variableDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(899); + variableDeclaratorId(); + setState(902); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(900); + match(ASSIGN); + setState(901); + variableInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorIdContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclaratorId(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { + VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_variableDeclaratorId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(904); + match(Identifier); + setState(906); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(905); + dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableInitializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final VariableInitializerContext variableInitializer() throws RecognitionException { + VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_variableInitializer); + try { + setState(910); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + case AT: + enterOuterAlt(_localctx, 1); + { + setState(908); + expression(); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(909); + arrayInitializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannTypeContext extends ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public UnannReferenceTypeContext unannReferenceType() { + return getRuleContext(UnannReferenceTypeContext.class,0); + } + public UnannTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannTypeContext unannType() throws RecognitionException { + UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_unannType); + try { + setState(914); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(912); + unannPrimitiveType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(913); + unannReferenceType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannPrimitiveTypeContext extends ParserRuleContext { + public NumericTypeContext numericType() { + return getRuleContext(NumericTypeContext.class,0); + } + public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannPrimitiveType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannPrimitiveType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException { + UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_unannPrimitiveType); + try { + setState(918); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 1); + { + setState(916); + numericType(); + } + break; + case BOOLEAN: + enterOuterAlt(_localctx, 2); + { + setState(917); + match(BOOLEAN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannReferenceTypeContext extends ParserRuleContext { + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public UnannTypeVariableContext unannTypeVariable() { + return getRuleContext(UnannTypeVariableContext.class,0); + } + public UnannArrayTypeContext unannArrayType() { + return getRuleContext(UnannArrayTypeContext.class,0); + } + public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannReferenceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannReferenceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException { + UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_unannReferenceType); + try { + setState(923); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(920); + unannClassOrInterfaceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(921); + unannTypeVariable(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(922); + unannArrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() { + return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) { + return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i); + } + public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() { + return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) { + return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i); + } + public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException { + UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_unannClassOrInterfaceType); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(927); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + case 1: + { + setState(925); + unannClassType_lfno_unannClassOrInterfaceType(); + } + break; + case 2: + { + setState(926); + unannInterfaceType_lfno_unannClassOrInterfaceType(); + } + break; + } + setState(933); + _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(931); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + case 1: + { + setState(929); + unannClassType_lf_unannClassOrInterfaceType(); + } + break; + case 2: + { + setState(930); + unannInterfaceType_lf_unannClassOrInterfaceType(); + } + break; + } + } + } + setState(935); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,66,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public UnannClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassTypeContext unannClassType() throws RecognitionException { + UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_unannClassType); + int _la; + try { + setState(952); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(936); + match(Identifier); + setState(938); + _la = _input.LA(1); + if (_la==LT) { + { + setState(937); + typeArguments(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(940); + unannClassOrInterfaceType(); + setState(941); + match(DOT); + setState(945); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(942); + annotation(); + } + } + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(948); + match(Identifier); + setState(950); + _la = _input.LA(1); + if (_la==LT) { + { + setState(949); + typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType_lf_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException { + UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_unannClassType_lf_unannClassOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(954); + match(DOT); + setState(958); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(955); + annotation(); + } + } + setState(960); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(961); + match(Identifier); + setState(963); + _la = _input.LA(1); + if (_la==LT) { + { + setState(962); + typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType_lfno_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException { + UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_unannClassType_lfno_unannClassOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(965); + match(Identifier); + setState(967); + _la = _input.LA(1); + if (_la==LT) { + { + setState(966); + typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceTypeContext extends ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return getRuleContext(UnannClassTypeContext.class,0); + } + public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException { + UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_unannInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(969); + unannClassType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType_lf_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException { + UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_unannInterfaceType_lf_unannClassOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(971); + unannClassType_lf_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType_lfno_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException { + UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(973); + unannClassType_lfno_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannTypeVariableContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannTypeVariable; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannTypeVariable(this); + else return visitor.visitChildren(this); + } + } + + public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException { + UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_unannTypeVariable); + try { + enterOuterAlt(_localctx, 1); + { + setState(975); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannArrayTypeContext extends ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public UnannTypeVariableContext unannTypeVariable() { + return getRuleContext(UnannTypeVariableContext.class,0); + } + public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannArrayType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannArrayType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannArrayTypeContext unannArrayType() throws RecognitionException { + UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_unannArrayType); + try { + setState(986); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(977); + unannPrimitiveType(); + setState(978); + dims(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(980); + unannClassOrInterfaceType(); + setState(981); + dims(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(983); + unannTypeVariable(); + setState(984); + dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodDeclarationContext extends ParserRuleContext { + public MethodHeaderContext methodHeader() { + return getRuleContext(MethodHeaderContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public List<MethodModifierContext> methodModifier() { + return getRuleContexts(MethodModifierContext.class); + } + public MethodModifierContext methodModifier(int i) { + return getRuleContext(MethodModifierContext.class,i); + } + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final MethodDeclarationContext methodDeclaration() throws RecognitionException { + MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_methodDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(991); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) { + { + { + setState(988); + methodModifier(); + } + } + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(994); + methodHeader(); + setState(995); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public MethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodModifier(this); + else return visitor.visitChildren(this); + } + } + + public final MethodModifierContext methodModifier() throws RecognitionException { + MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_methodModifier); + try { + setState(1007); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(997); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(998); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(999); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1000); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(1001); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(1002); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 7); + { + setState(1003); + match(FINAL); + } + break; + case SYNCHRONIZED: + enterOuterAlt(_localctx, 8); + { + setState(1004); + match(SYNCHRONIZED); + } + break; + case NATIVE: + enterOuterAlt(_localctx, 9); + { + setState(1005); + match(NATIVE); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 10); + { + setState(1006); + 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; + } + + public static class MethodHeaderContext extends ParserRuleContext { + public ResultContext result() { + return getRuleContext(ResultContext.class,0); + } + public MethodDeclaratorContext methodDeclarator() { + return getRuleContext(MethodDeclaratorContext.class,0); + } + public Throws_Context throws_() { + return getRuleContext(Throws_Context.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public MethodHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodHeader; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodHeader(this); + else return visitor.visitChildren(this); + } + } + + public final MethodHeaderContext methodHeader() throws RecognitionException { + MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_methodHeader); + int _la; + try { + setState(1026); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1009); + result(); + setState(1010); + methodDeclarator(); + setState(1012); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1011); + throws_(); + } + } + + } + break; + case LT: + enterOuterAlt(_localctx, 2); + { + setState(1014); + typeParameters(); + setState(1018); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1015); + annotation(); + } + } + setState(1020); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1021); + result(); + setState(1022); + methodDeclarator(); + setState(1024); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1023); + throws_(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResultContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public ResultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_result; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResult(this); + else return visitor.visitChildren(this); + } + } + + public final ResultContext result() throws RecognitionException { + ResultContext _localctx = new ResultContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_result); + try { + setState(1030); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1028); + unannType(); + } + break; + case VOID: + enterOuterAlt(_localctx, 2); + { + setState(1029); + 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; + } + + public static class MethodDeclaratorContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final MethodDeclaratorContext methodDeclarator() throws RecognitionException { + MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_methodDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1032); + match(Identifier); + setState(1033); + match(LPAREN); + setState(1035); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(1034); + formalParameterList(); + } + } + + setState(1037); + match(RPAREN); + setState(1039); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(1038); + dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterListContext extends ParserRuleContext { + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public LastFormalParameterContext lastFormalParameter() { + return getRuleContext(LastFormalParameterContext.class,0); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterListContext formalParameterList() throws RecognitionException { + FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_formalParameterList); + try { + setState(1046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1041); + formalParameters(); + setState(1042); + match(COMMA); + setState(1043); + lastFormalParameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1045); + lastFormalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParametersContext extends ParserRuleContext { + public List<FormalParameterContext> formalParameter() { + return getRuleContexts(FormalParameterContext.class); + } + public FormalParameterContext formalParameter(int i) { + return getRuleContext(FormalParameterContext.class,i); + } + public ReceiverParameterContext receiverParameter() { + return getRuleContext(ReceiverParameterContext.class,0); + } + public FormalParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameters(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParametersContext formalParameters() throws RecognitionException { + FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_formalParameters); + try { + int _alt; + setState(1064); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1048); + formalParameter(); + setState(1053); + _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(1049); + match(COMMA); + setState(1050); + formalParameter(); + } + } + } + setState(1055); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,85,_ctx); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1056); + receiverParameter(); + setState(1061); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1057); + match(COMMA); + setState(1058); + formalParameter(); + } + } + } + setState(1063); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterContext formalParameter() throws RecognitionException { + FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_formalParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1066); + variableModifier(); + } + } + setState(1071); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1072); + unannType(); + setState(1073); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public VariableModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableModifier(this); + else return visitor.visitChildren(this); + } + } + + public final VariableModifierContext variableModifier() throws RecognitionException { + VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_variableModifier); + try { + setState(1077); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1075); + annotation(); + } + break; + case FINAL: + enterOuterAlt(_localctx, 2); + { + setState(1076); + match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LastFormalParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public FormalParameterContext formalParameter() { + return getRuleContext(FormalParameterContext.class,0); + } + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lastFormalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLastFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { + LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_lastFormalParameter); + int _la; + try { + setState(1096); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1082); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1079); + variableModifier(); + } + } + setState(1084); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1085); + unannType(); + setState(1089); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1086); + annotation(); + } + } + setState(1091); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1092); + match(ELLIPSIS); + setState(1093); + variableDeclaratorId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1095); + formalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReceiverParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ReceiverParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_receiverParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReceiverParameter(this); + else return visitor.visitChildren(this); + } + } + + public final ReceiverParameterContext receiverParameter() throws RecognitionException { + ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_receiverParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1101); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1098); + annotation(); + } + } + setState(1103); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1104); + unannType(); + setState(1107); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1105); + match(Identifier); + setState(1106); + match(DOT); + } + } + + setState(1109); + match(THIS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Throws_Context extends ParserRuleContext { + public ExceptionTypeListContext exceptionTypeList() { + return getRuleContext(ExceptionTypeListContext.class,0); + } + public Throws_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throws_; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitThrows_(this); + else return visitor.visitChildren(this); + } + } + + public final Throws_Context throws_() throws RecognitionException { + Throws_Context _localctx = new Throws_Context(_ctx, getState()); + enterRule(_localctx, 162, RULE_throws_); + try { + enterOuterAlt(_localctx, 1); + { + setState(1111); + match(THROWS); + setState(1112); + exceptionTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionTypeListContext extends ParserRuleContext { + public List<ExceptionTypeContext> exceptionType() { + return getRuleContexts(ExceptionTypeContext.class); + } + public ExceptionTypeContext exceptionType(int i) { + return getRuleContext(ExceptionTypeContext.class,i); + } + public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionTypeList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExceptionTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException { + ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_exceptionTypeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1114); + exceptionType(); + setState(1119); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1115); + match(COMMA); + setState(1116); + exceptionType(); + } + } + setState(1121); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionTypeContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ExceptionTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExceptionType(this); + else return visitor.visitChildren(this); + } + } + + public final ExceptionTypeContext exceptionType() throws RecognitionException { + ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_exceptionType); + try { + setState(1124); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1122); + classType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1123); + typeVariable(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodBodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public MethodBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodBody(this); + else return visitor.visitChildren(this); + } + } + + public final MethodBodyContext methodBody() throws RecognitionException { + MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_methodBody); + try { + setState(1128); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(1126); + block(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(1127); + match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InstanceInitializerContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public InstanceInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_instanceInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInstanceInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final InstanceInitializerContext instanceInitializer() throws RecognitionException { + InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_instanceInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1130); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticInitializerContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public StaticInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStaticInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final StaticInitializerContext staticInitializer() throws RecognitionException { + StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_staticInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1132); + match(STATIC); + setState(1133); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorDeclarationContext extends ParserRuleContext { + public ConstructorDeclaratorContext constructorDeclarator() { + return getRuleContext(ConstructorDeclaratorContext.class,0); + } + public ConstructorBodyContext constructorBody() { + return getRuleContext(ConstructorBodyContext.class,0); + } + public List<ConstructorModifierContext> constructorModifier() { + return getRuleContexts(ConstructorModifierContext.class); + } + public ConstructorModifierContext constructorModifier(int i) { + return getRuleContext(ConstructorModifierContext.class,i); + } + public Throws_Context throws_() { + return getRuleContext(Throws_Context.class,0); + } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { + ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_constructorDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1138); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || _la==AT) { + { + { + setState(1135); + constructorModifier(); + } + } + setState(1140); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1141); + constructorDeclarator(); + setState(1143); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1142); + throws_(); + } + } + + setState(1145); + constructorBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ConstructorModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorModifierContext constructorModifier() throws RecognitionException { + ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_constructorModifier); + try { + setState(1151); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1147); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1148); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(1149); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1150); + match(PRIVATE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorDeclaratorContext extends ParserRuleContext { + public SimpleTypeNameContext simpleTypeName() { + return getRuleContext(SimpleTypeNameContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException { + ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_constructorDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1154); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1153); + typeParameters(); + } + } + + setState(1156); + simpleTypeName(); + setState(1157); + match(LPAREN); + setState(1159); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(1158); + formalParameterList(); + } + } + + setState(1161); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleTypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleTypeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSimpleTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final SimpleTypeNameContext simpleTypeName() throws RecognitionException { + SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_simpleTypeName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1163); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorBodyContext extends ParserRuleContext { + public ExplicitConstructorInvocationContext explicitConstructorInvocation() { + return getRuleContext(ExplicitConstructorInvocationContext.class,0); + } + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public ConstructorBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorBody(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorBodyContext constructorBody() throws RecognitionException { + ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_constructorBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1165); + match(LBRACE); + setState(1167); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { + case 1: + { + setState(1166); + explicitConstructorInvocation(); + } + break; + } + setState(1170); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L < [...] + { + setState(1169); + blockStatements(); + } + } + + setState(1172); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExplicitConstructorInvocationContext extends ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExplicitConstructorInvocation(this); + else return visitor.visitChildren(this); + } + } + + public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException { + ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_explicitConstructorInvocation); + int _la; + try { + setState(1220); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1175); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1174); + typeArguments(); + } + } + + setState(1177); + match(THIS); + setState(1178); + match(LPAREN); + setState(1180); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1179); + argumentList(); + } + } + + setState(1182); + match(RPAREN); + setState(1183); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1185); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1184); + typeArguments(); + } + } + + setState(1187); + match(SUPER); + setState(1188); + match(LPAREN); + setState(1190); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1189); + argumentList(); + } + } + + setState(1192); + match(RPAREN); + setState(1193); + match(SEMI); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1194); + expressionName(); + setState(1195); + match(DOT); + setState(1197); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1196); + typeArguments(); + } + } + + setState(1199); + match(SUPER); + setState(1200); + match(LPAREN); + setState(1202); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1201); + argumentList(); + } + } + + setState(1204); + match(RPAREN); + setState(1205); + match(SEMI); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1207); + primary(); + setState(1208); + match(DOT); + setState(1210); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1209); + typeArguments(); + } + } + + setState(1212); + match(SUPER); + setState(1213); + match(LPAREN); + setState(1215); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1214); + argumentList(); + } + } + + setState(1217); + match(RPAREN); + setState(1218); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public EnumBodyContext enumBody() { + return getRuleContext(EnumBodyContext.class,0); + } + public List<ClassModifierContext> classModifier() { + return getRuleContexts(ClassModifierContext.class); + } + public ClassModifierContext classModifier(int i) { + return getRuleContext(ClassModifierContext.class,i); + } + public SuperinterfacesContext superinterfaces() { + return getRuleContext(SuperinterfacesContext.class,0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final EnumDeclarationContext enumDeclaration() throws RecognitionException { + EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_enumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1225); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1222); + classModifier(); + } + } + setState(1227); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1228); + match(ENUM); + setState(1229); + match(Identifier); + setState(1231); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(1230); + superinterfaces(); + } + } + + setState(1233); + enumBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumBodyContext extends ParserRuleContext { + public EnumConstantListContext enumConstantList() { + return getRuleContext(EnumConstantListContext.class,0); + } + public EnumBodyDeclarationsContext enumBodyDeclarations() { + return getRuleContext(EnumBodyDeclarationsContext.class,0); + } + public EnumBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumBody(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyContext enumBody() throws RecognitionException { + EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_enumBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1235); + match(LBRACE); + setState(1237); + _la = _input.LA(1); + if (_la==Identifier || _la==AT) { + { + setState(1236); + enumConstantList(); + } + } + + setState(1240); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1239); + match(COMMA); + } + } + + setState(1243); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1242); + enumBodyDeclarations(); + } + } + + setState(1245); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantListContext extends ParserRuleContext { + public List<EnumConstantContext> enumConstant() { + return getRuleContexts(EnumConstantContext.class); + } + public EnumConstantContext enumConstant(int i) { + return getRuleContext(EnumConstantContext.class,i); + } + public EnumConstantListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantList(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantListContext enumConstantList() throws RecognitionException { + EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_enumConstantList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1247); + enumConstant(); + setState(1252); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1248); + match(COMMA); + setState(1249); + enumConstant(); + } + } + } + setState(1254); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<EnumConstantModifierContext> enumConstantModifier() { + return getRuleContexts(EnumConstantModifierContext.class); + } + public EnumConstantModifierContext enumConstantModifier(int i) { + return getRuleContext(EnumConstantModifierContext.class,i); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public EnumConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstant; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstant(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantContext enumConstant() throws RecognitionException { + EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_enumConstant); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1258); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1255); + enumConstantModifier(); + } + } + setState(1260); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1261); + match(Identifier); + setState(1267); + _la = _input.LA(1); + if (_la==LPAREN) { + { + setState(1262); + match(LPAREN); + setState(1264); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1263); + argumentList(); + } + } + + setState(1266); + match(RPAREN); + } + } + + setState(1270); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(1269); + classBody(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantModifier(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException { + EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_enumConstantModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1272); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumBodyDeclarationsContext extends ParserRuleContext { + public List<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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumBodyDeclarations(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { + EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_enumBodyDeclarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1274); + match(SEMI); + setState(1278); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] + { + { + setState(1275); + classBodyDeclaration(); + } + } + setState(1280); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceDeclarationContext extends ParserRuleContext { + public NormalInterfaceDeclarationContext normalInterfaceDeclaration() { + return getRuleContext(NormalInterfaceDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { + InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_interfaceDeclaration); + try { + setState(1283); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1281); + normalInterfaceDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1282); + annotationTypeDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalInterfaceDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public InterfaceBodyContext interfaceBody() { + return getRuleContext(InterfaceBodyContext.class,0); + } + public List<InterfaceModifierContext> interfaceModifier() { + return getRuleContexts(InterfaceModifierContext.class); + } + public InterfaceModifierContext interfaceModifier(int i) { + return getRuleContext(InterfaceModifierContext.class,i); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ExtendsInterfacesContext extendsInterfaces() { + return getRuleContext(ExtendsInterfacesContext.class,0); + } + public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException { + NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_normalInterfaceDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1288); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1285); + interfaceModifier(); + } + } + setState(1290); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1291); + match(INTERFACE); + setState(1292); + match(Identifier); + setState(1294); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1293); + typeParameters(); + } + } + + setState(1297); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(1296); + extendsInterfaces(); + } + } + + setState(1299); + interfaceBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public InterfaceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceModifier(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceModifierContext interfaceModifier() throws RecognitionException { + InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_interfaceModifier); + try { + setState(1308); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1301); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1302); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(1303); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1304); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(1305); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(1306); + match(STATIC); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 7); + { + setState(1307); + 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; + } + + public static class ExtendsInterfacesContext extends ParserRuleContext { + public InterfaceTypeListContext interfaceTypeList() { + return getRuleContext(InterfaceTypeListContext.class,0); + } + public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_extendsInterfaces; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExtendsInterfaces(this); + else return visitor.visitChildren(this); + } + } + + public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException { + ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_extendsInterfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(1310); + match(EXTENDS); + setState(1311); + interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceBodyContext extends ParserRuleContext { + public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() { + return getRuleContexts(InterfaceMemberDeclarationContext.class); + } + public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) { + return getRuleContext(InterfaceMemberDeclarationContext.class,i); + } + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceBody(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceBodyContext interfaceBody() throws RecognitionException { + InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_interfaceBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1313); + match(LBRACE); + setState(1317); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << [...] + { + { + setState(1314); + interfaceMemberDeclaration(); + } + } + setState(1319); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1320); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMemberDeclarationContext extends ParserRuleContext { + public ConstantDeclarationContext constantDeclaration() { + return getRuleContext(ConstantDeclarationContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { + InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_interfaceMemberDeclaration); + try { + setState(1327); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1322); + constantDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1323); + interfaceMethodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1324); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1325); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1326); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<ConstantModifierContext> constantModifier() { + return getRuleContexts(ConstantModifierContext.class); + } + public ConstantModifierContext constantModifier(int i) { + return getRuleContext(ConstantModifierContext.class,i); + } + public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantDeclarationContext constantDeclaration() throws RecognitionException { + ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_constantDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PUBLIC) | (1L << STATIC))) != 0) || _la==AT) { + { + { + setState(1329); + constantModifier(); + } + } + setState(1334); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1335); + unannType(); + setState(1336); + variableDeclaratorList(); + setState(1337); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ConstantModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantModifierContext constantModifier() throws RecognitionException { + ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_constantModifier); + try { + setState(1343); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1339); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1340); + match(PUBLIC); + } + break; + case STATIC: + enterOuterAlt(_localctx, 3); + { + setState(1341); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 4); + { + setState(1342); + match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodDeclarationContext extends ParserRuleContext { + public MethodHeaderContext methodHeader() { + return getRuleContext(MethodHeaderContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public List<InterfaceMethodModifierContext> interfaceMethodModifier() { + return getRuleContexts(InterfaceMethodModifierContext.class); + } + public InterfaceMethodModifierContext interfaceMethodModifier(int i) { + return getRuleContext(InterfaceMethodModifierContext.class,i); + } + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { + InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_interfaceMethodDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1348); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1345); + interfaceMethodModifier(); + } + } + setState(1350); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1351); + methodHeader(); + setState(1352); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMethodModifier(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { + InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_interfaceMethodModifier); + try { + setState(1360); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1354); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1355); + match(PUBLIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 3); + { + setState(1356); + match(ABSTRACT); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 4); + { + setState(1357); + match(DEFAULT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(1358); + match(STATIC); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 6); + { + setState(1359); + 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; + } + + public static class AnnotationTypeDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AnnotationTypeBodyContext annotationTypeBody() { + return getRuleContext(AnnotationTypeBodyContext.class,0); + } + public List<InterfaceModifierContext> interfaceModifier() { + return getRuleContexts(InterfaceModifierContext.class); + } + public InterfaceModifierContext interfaceModifier(int i) { + return getRuleContext(InterfaceModifierContext.class,i); + } + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { + AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_annotationTypeDeclaration); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1365); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,136,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1362); + interfaceModifier(); + } + } + } + setState(1367); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,136,_ctx); + } + setState(1368); + match(AT); + setState(1369); + match(INTERFACE); + setState(1370); + match(Identifier); + setState(1371); + annotationTypeBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeBodyContext extends ParserRuleContext { + public List<AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() { + return getRuleContexts(AnnotationTypeMemberDeclarationContext.class); + } + public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) { + return getRuleContext(AnnotationTypeMemberDeclarationContext.class,i); + } + public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeBody(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { + AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_annotationTypeBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1373); + match(LBRACE); + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==Identifier || _la==AT) { + { + { + setState(1374); + annotationTypeMemberDeclaration(); + } + } + setState(1379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1380); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext { + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() { + return getRuleContext(AnnotationTypeElementDeclarationContext.class,0); + } + public ConstantDeclarationContext constantDeclaration() { + return getRuleContext(ConstantDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException { + AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_annotationTypeMemberDeclaration); + try { + setState(1387); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1382); + annotationTypeElementDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1383); + constantDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1384); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1385); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1386); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationTypeElementModifierContext> annotationTypeElementModifier() { + return getRuleContexts(AnnotationTypeElementModifierContext.class); + } + public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) { + return getRuleContext(AnnotationTypeElementModifierContext.class,i); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeElementDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { + AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_annotationTypeElementDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1392); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ABSTRACT || _la==PUBLIC || _la==AT) { + { + { + setState(1389); + annotationTypeElementModifier(); + } + } + setState(1394); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1395); + unannType(); + setState(1396); + match(Identifier); + setState(1397); + match(LPAREN); + setState(1398); + match(RPAREN); + setState(1400); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(1399); + dims(); + } + } + + setState(1403); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1402); + defaultValue(); + } + } + + setState(1405); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeElementModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeElementModifier(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException { + AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_annotationTypeElementModifier); + try { + setState(1410); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1407); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1408); + match(PUBLIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 3); + { + setState(1409); + match(ABSTRACT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DefaultValueContext extends ParserRuleContext { + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public DefaultValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaultValue; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDefaultValue(this); + else return visitor.visitChildren(this); + } + } + + public final DefaultValueContext defaultValue() throws RecognitionException { + DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_defaultValue); + try { + enterOuterAlt(_localctx, 1); + { + setState(1412); + match(DEFAULT); + setState(1413); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationContext extends ParserRuleContext { + public NormalAnnotationContext normalAnnotation() { + return getRuleContext(NormalAnnotationContext.class,0); + } + public MarkerAnnotationContext markerAnnotation() { + return getRuleContext(MarkerAnnotationContext.class,0); + } + public SingleElementAnnotationContext singleElementAnnotation() { + return getRuleContext(SingleElementAnnotationContext.class,0); + } + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_annotation); + try { + setState(1418); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1415); + normalAnnotation(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1416); + markerAnnotation(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1417); + singleElementAnnotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ElementValuePairListContext elementValuePairList() { + return getRuleContext(ElementValuePairListContext.class,0); + } + public NormalAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final NormalAnnotationContext normalAnnotation() throws RecognitionException { + NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_normalAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1420); + match(AT); + setState(1421); + typeName(); + setState(1422); + match(LPAREN); + setState(1424); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1423); + elementValuePairList(); + } + } + + setState(1426); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValuePairListContext extends ParserRuleContext { + public List<ElementValuePairContext> elementValuePair() { + return getRuleContexts(ElementValuePairContext.class); + } + public ElementValuePairContext elementValuePair(int i) { + return getRuleContext(ElementValuePairContext.class,i); + } + public ElementValuePairListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePairList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValuePairList(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairListContext elementValuePairList() throws RecognitionException { + ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_elementValuePairList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1428); + elementValuePair(); + setState(1433); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1429); + match(COMMA); + setState(1430); + elementValuePair(); + } + } + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValuePairContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public ElementValuePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePair; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValuePair(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairContext elementValuePair() throws RecognitionException { + ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_elementValuePair); + try { + enterOuterAlt(_localctx, 1); + { + setState(1436); + match(Identifier); + setState(1437); + match(ASSIGN); + setState(1438); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + return getRuleContext(ElementValueArrayInitializerContext.class,0); + } + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ElementValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValue; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValue(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueContext elementValue() throws RecognitionException { + ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_elementValue); + try { + setState(1443); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1440); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1441); + elementValueArrayInitializer(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1442); + annotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueArrayInitializerContext extends ParserRuleContext { + public ElementValueListContext elementValueList() { + return getRuleContext(ElementValueListContext.class,0); + } + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValueArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { + ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_elementValueArrayInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1445); + match(LBRACE); + setState(1447); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] + { + setState(1446); + elementValueList(); + } + } + + setState(1450); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1449); + match(COMMA); + } + } + + setState(1452); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueListContext extends ParserRuleContext { + public List<ElementValueContext> elementValue() { + return getRuleContexts(ElementValueContext.class); + } + public ElementValueContext elementValue(int i) { + return getRuleContext(ElementValueContext.class,i); + } + public ElementValueListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValueList(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueListContext elementValueList() throws RecognitionException { + ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_elementValueList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1454); + elementValue(); + setState(1459); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,149,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1455); + match(COMMA); + setState(1456); + elementValue(); + } + } + } + setState(1461); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,149,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MarkerAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_markerAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMarkerAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final MarkerAnnotationContext markerAnnotation() throws RecognitionException { + MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_markerAnnotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1462); + match(AT); + setState(1463); + typeName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleElementAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleElementAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleElementAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException { + SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_singleElementAnnotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1465); + match(AT); + setState(1466); + typeName(); + setState(1467); + match(LPAREN); + setState(1468); + elementValue(); + setState(1469); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayInitializerContext extends ParserRuleContext { + public VariableInitializerListContext variableInitializerList() { + return getRuleContext(VariableInitializerListContext.class,0); + } + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayInitializerContext arrayInitializer() throws RecognitionException { + ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_arrayInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1471); + match(LBRACE); + setState(1473); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] + { + setState(1472); + variableInitializerList(); + } + } + + setState(1476); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1475); + match(COMMA); + } + } + + setState(1478); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableInitializerListContext extends ParserRuleContext { + public List<VariableInitializerContext> variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public VariableInitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializerList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableInitializerList(this); + else return visitor.visitChildren(this); + } + } + + public final VariableInitializerListContext variableInitializerList() throws RecognitionException { + VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_variableInitializerList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1480); + variableInitializer(); + setState(1485); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,152,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1481); + match(COMMA); + setState(1482); + variableInitializer(); + } + } + } + setState(1487); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,152,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockContext extends ParserRuleContext { + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1488); + match(LBRACE); + setState(1490); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L < [...] + { + setState(1489); + blockStatements(); + } + } + + setState(1492); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementsContext extends ParserRuleContext { + public List<BlockStatementContext> blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class,i); + } + public BlockStatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatements; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlockStatements(this); + else return visitor.visitChildren(this); + } + } + + public final BlockStatementsContext blockStatements() throws RecognitionException { + BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_blockStatements); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1494); + blockStatement(); + setState(1498); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1 [...] + { + { + setState(1495); + blockStatement(); + } + } + setState(1500); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementContext extends ParserRuleContext { + public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { + return getRuleContext(LocalVariableDeclarationStatementContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlockStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BlockStatementContext blockStatement() throws RecognitionException { + BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_blockStatement); + try { + setState(1504); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1501); + localVariableDeclarationStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1502); + classDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1503); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalVariableDeclarationStatementContext extends ParserRuleContext { + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLocalVariableDeclarationStatement(this); + else return visitor.visitChildren(this); + } + } + + public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException { + LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_localVariableDeclarationStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1506); + localVariableDeclaration(); + setState(1507); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalVariableDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localVariableDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLocalVariableDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { + LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_localVariableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1512); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1509); + variableModifier(); + } + } + setState(1514); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1515); + unannType(); + setState(1516); + variableDeclaratorList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementContext extends ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0); + } + public LabeledStatementContext labeledStatement() { + return getRuleContext(LabeledStatementContext.class,0); + } + public IfThenStatementContext ifThenStatement() { + return getRuleContext(IfThenStatementContext.class,0); + } + public IfThenElseStatementContext ifThenElseStatement() { + return getRuleContext(IfThenElseStatementContext.class,0); + } + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class,0); + } + public ForStatementContext forStatement() { + return getRuleContext(ForStatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_statement); + try { + setState(1524); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1518); + statementWithoutTrailingSubstatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1519); + labeledStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1520); + ifThenStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1521); + ifThenElseStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1522); + whileStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1523); + forStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementNoShortIfContext extends ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0); + } + public LabeledStatementNoShortIfContext labeledStatementNoShortIf() { + return getRuleContext(LabeledStatementNoShortIfContext.class,0); + } + public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() { + return getRuleContext(IfThenElseStatementNoShortIfContext.class,0); + } + public WhileStatementNoShortIfContext whileStatementNoShortIf() { + return getRuleContext(WhileStatementNoShortIfContext.class,0); + } + public ForStatementNoShortIfContext forStatementNoShortIf() { + return getRuleContext(ForStatementNoShortIfContext.class,0); + } + public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException { + StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_statementNoShortIf); + try { + setState(1531); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1526); + statementWithoutTrailingSubstatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1527); + labeledStatementNoShortIf(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1528); + ifThenElseStatementNoShortIf(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1529); + whileStatementNoShortIf(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1530); + forStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public EmptyStatementContext emptyStatement() { + return getRuleContext(EmptyStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public AssertStatementContext assertStatement() { + return getRuleContext(AssertStatementContext.class,0); + } + public SwitchStatementContext switchStatement() { + return getRuleContext(SwitchStatementContext.class,0); + } + public DoStatementContext doStatement() { + return getRuleContext(DoStatementContext.class,0); + } + public BreakStatementContext breakStatement() { + return getRuleContext(BreakStatementContext.class,0); + } + public ContinueStatementContext continueStatement() { + return getRuleContext(ContinueStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public SynchronizedStatementContext synchronizedStatement() { + return getRuleContext(SynchronizedStatementContext.class,0); + } + public ThrowStatementContext throwStatement() { + return getRuleContext(ThrowStatementContext.class,0); + } + public TryStatementContext tryStatement() { + return getRuleContext(TryStatementContext.class,0); + } + public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementWithoutTrailingSubstatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementWithoutTrailingSubstatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException { + StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_statementWithoutTrailingSubstatement); + try { + setState(1545); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(1533); + block(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(1534); + emptyStatement(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case INC: + case DEC: + case Identifier: + case AT: + enterOuterAlt(_localctx, 3); + { + setState(1535); + expressionStatement(); + } + break; + case ASSERT: + enterOuterAlt(_localctx, 4); + { + setState(1536); + assertStatement(); + } + break; + case SWITCH: + enterOuterAlt(_localctx, 5); + { + setState(1537); + switchStatement(); + } + break; + case DO: + enterOuterAlt(_localctx, 6); + { + setState(1538); + doStatement(); + } + break; + case BREAK: + enterOuterAlt(_localctx, 7); + { + setState(1539); + breakStatement(); + } + break; + case CONTINUE: + enterOuterAlt(_localctx, 8); + { + setState(1540); + continueStatement(); + } + break; + case RETURN: + enterOuterAlt(_localctx, 9); + { + setState(1541); + returnStatement(); + } + break; + case SYNCHRONIZED: + enterOuterAlt(_localctx, 10); + { + setState(1542); + synchronizedStatement(); + } + break; + case THROW: + enterOuterAlt(_localctx, 11); + { + setState(1543); + throwStatement(); + } + break; + case TRY: + enterOuterAlt(_localctx, 12); + { + setState(1544); + tryStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EmptyStatementContext extends ParserRuleContext { + public EmptyStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEmptyStatement(this); + else return visitor.visitChildren(this); + } + } + + public final EmptyStatementContext emptyStatement() throws RecognitionException { + EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_emptyStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1547); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeledStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public LabeledStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeledStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLabeledStatement(this); + else return visitor.visitChildren(this); + } + } + + public final LabeledStatementContext labeledStatement() throws RecognitionException { + LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_labeledStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1549); + match(Identifier); + setState(1550); + match(COLON); + setState(1551); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeledStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeledStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLabeledStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException { + LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_labeledStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1553); + match(Identifier); + setState(1554); + match(COLON); + setState(1555); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionStatementContext extends ParserRuleContext { + public StatementExpressionContext statementExpression() { + return getRuleContext(StatementExpressionContext.class,0); + } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpressionStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_expressionStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1557); + statementExpression(); + setState(1558); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementExpressionContext extends ParserRuleContext { + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public PreIncrementExpressionContext preIncrementExpression() { + return getRuleContext(PreIncrementExpressionContext.class,0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return getRuleContext(PreDecrementExpressionContext.class,0); + } + public PostIncrementExpressionContext postIncrementExpression() { + return getRuleContext(PostIncrementExpressionContext.class,0); + } + public PostDecrementExpressionContext postDecrementExpression() { + return getRuleContext(PostDecrementExpressionContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public StatementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final StatementExpressionContext statementExpression() throws RecognitionException { + StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_statementExpression); + try { + setState(1567); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1560); + assignment(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1561); + preIncrementExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1562); + preDecrementExpression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1563); + postIncrementExpression(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1564); + postDecrementExpression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1565); + methodInvocation(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1566); + classInstanceCreationExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public IfThenStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenStatementContext ifThenStatement() throws RecognitionException { + IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_ifThenStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1569); + match(IF); + setState(1570); + match(LPAREN); + setState(1571); + expression(); + setState(1572); + match(RPAREN); + setState(1573); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenElseStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenElseStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenElseStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException { + IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_ifThenElseStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1575); + match(IF); + setState(1576); + match(LPAREN); + setState(1577); + expression(); + setState(1578); + match(RPAREN); + setState(1579); + statementNoShortIf(); + setState(1580); + match(ELSE); + setState(1581); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List<StatementNoShortIfContext> statementNoShortIf() { + return getRuleContexts(StatementNoShortIfContext.class); + } + public StatementNoShortIfContext statementNoShortIf(int i) { + return getRuleContext(StatementNoShortIfContext.class,i); + } + public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenElseStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenElseStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException { + IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_ifThenElseStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1583); + match(IF); + setState(1584); + match(LPAREN); + setState(1585); + expression(); + setState(1586); + match(RPAREN); + setState(1587); + statementNoShortIf(); + setState(1588); + match(ELSE); + setState(1589); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssertStatementContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public AssertStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assertStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssertStatement(this); + else return visitor.visitChildren(this); + } + } + + public final AssertStatementContext assertStatement() throws RecognitionException { + AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_assertStatement); + try { + setState(1601); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1591); + match(ASSERT); + setState(1592); + expression(); + setState(1593); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1595); + match(ASSERT); + setState(1596); + expression(); + setState(1597); + match(COLON); + setState(1598); + expression(); + setState(1599); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public SwitchBlockContext switchBlock() { + return getRuleContext(SwitchBlockContext.class,0); + } + public SwitchStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchStatement(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchStatementContext switchStatement() throws RecognitionException { + SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_switchStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1603); + match(SWITCH); + setState(1604); + match(LPAREN); + setState(1605); + expression(); + setState(1606); + match(RPAREN); + setState(1607); + switchBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockContext extends ParserRuleContext { + public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() { + return getRuleContexts(SwitchBlockStatementGroupContext.class); + } + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return getRuleContext(SwitchBlockStatementGroupContext.class,i); + } + public List<SwitchLabelContext> switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public SwitchBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlock; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchBlock(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchBlockContext switchBlock() throws RecognitionException { + SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_switchBlock); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1609); + match(LBRACE); + setState(1613); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,162,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1610); + switchBlockStatementGroup(); + } + } + } + setState(1615); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,162,_ctx); + } + setState(1619); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(1616); + switchLabel(); + } + } + setState(1621); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1622); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockStatementGroupContext extends ParserRuleContext { + public SwitchLabelsContext switchLabels() { + return getRuleContext(SwitchLabelsContext.class,0); + } + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchBlockStatementGroup(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { + SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_switchBlockStatementGroup); + try { + enterOuterAlt(_localctx, 1); + { + setState(1624); + switchLabels(); + setState(1625); + blockStatements(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelsContext extends ParserRuleContext { + public List<SwitchLabelContext> switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public SwitchLabelsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabels; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchLabels(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchLabelsContext switchLabels() throws RecognitionException { + SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_switchLabels); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1627); + switchLabel(); + setState(1631); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(1628); + switchLabel(); + } + } + setState(1633); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelContext extends ParserRuleContext { + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public EnumConstantNameContext enumConstantName() { + return getRuleContext(EnumConstantNameContext.class,0); + } + public SwitchLabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabel; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchLabel(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchLabelContext switchLabel() throws RecognitionException { + SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_switchLabel); + try { + setState(1644); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1634); + match(CASE); + setState(1635); + constantExpression(); + setState(1636); + match(COLON); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1638); + match(CASE); + setState(1639); + enumConstantName(); + setState(1640); + match(COLON); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1642); + match(DEFAULT); + setState(1643); + match(COLON); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public EnumConstantNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantName(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantNameContext enumConstantName() throws RecognitionException { + EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_enumConstantName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1646); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWhileStatement(this); + else return visitor.visitChildren(this); + } + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_whileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1648); + match(WHILE); + setState(1649); + match(LPAREN); + setState(1650); + expression(); + setState(1651); + match(RPAREN); + setState(1652); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileStatementNoShortIfContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWhileStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException { + WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_whileStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1654); + match(WHILE); + setState(1655); + match(LPAREN); + setState(1656); + expression(); + setState(1657); + match(RPAREN); + setState(1658); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DoStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DoStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_doStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDoStatement(this); + else return visitor.visitChildren(this); + } + } + + public final DoStatementContext doStatement() throws RecognitionException { + DoStatementContext _localctx = new DoStatementContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_doStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1660); + match(DO); + setState(1661); + statement(); + setState(1662); + match(WHILE); + setState(1663); + match(LPAREN); + setState(1664); + expression(); + setState(1665); + match(RPAREN); + setState(1666); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForStatementContext extends ParserRuleContext { + public BasicForStatementContext basicForStatement() { + return getRuleContext(BasicForStatementContext.class,0); + } + public EnhancedForStatementContext enhancedForStatement() { + return getRuleContext(EnhancedForStatementContext.class,0); + } + public ForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ForStatementContext forStatement() throws RecognitionException { + ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_forStatement); + try { + setState(1670); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1668); + basicForStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1669); + enhancedForStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForStatementNoShortIfContext extends ParserRuleContext { + public BasicForStatementNoShortIfContext basicForStatementNoShortIf() { + return getRuleContext(BasicForStatementNoShortIfContext.class,0); + } + public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() { + return getRuleContext(EnhancedForStatementNoShortIfContext.class,0); + } + public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException { + ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_forStatementNoShortIf); + try { + setState(1674); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1672); + basicForStatementNoShortIf(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1673); + enhancedForStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BasicForStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + public BasicForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_basicForStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBasicForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BasicForStatementContext basicForStatement() throws RecognitionException { + BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_basicForStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1676); + match(FOR); + setState(1677); + match(LPAREN); + setState(1679); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << [...] + { + setState(1678); + forInit(); + } + } + + setState(1681); + match(SEMI); + setState(1683); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1682); + expression(); + } + } + + setState(1685); + match(SEMI); + setState(1687); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (INC - 79)) | (1 [...] + { + setState(1686); + forUpdate(); + } + } + + setState(1689); + match(RPAREN); + setState(1690); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BasicForStatementNoShortIfContext extends ParserRuleContext { + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_basicForStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBasicForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException { + BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_basicForStatementNoShortIf); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1692); + match(FOR); + setState(1693); + match(LPAREN); + setState(1695); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << [...] + { + setState(1694); + forInit(); + } + } + + setState(1697); + match(SEMI); + setState(1699); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1698); + expression(); + } + } + + setState(1701); + match(SEMI); + setState(1703); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (INC - 79)) | (1 [...] + { + setState(1702); + forUpdate(); + } + } + + setState(1705); + match(RPAREN); + setState(1706); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForInitContext extends ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return getRuleContext(StatementExpressionListContext.class,0); + } + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInit; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForInit(this); + else return visitor.visitChildren(this); + } + } + + public final ForInitContext forInit() throws RecognitionException { + ForInitContext _localctx = new ForInitContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_forInit); + try { + setState(1710); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1708); + statementExpressionList(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1709); + localVariableDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForUpdateContext extends ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return getRuleContext(StatementExpressionListContext.class,0); + } + public ForUpdateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forUpdate; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForUpdate(this); + else return visitor.visitChildren(this); + } + } + + public final ForUpdateContext forUpdate() throws RecognitionException { + ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_forUpdate); + try { + enterOuterAlt(_localctx, 1); + { + setState(1712); + statementExpressionList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementExpressionListContext extends ParserRuleContext { + public List<StatementExpressionContext> statementExpression() { + return getRuleContexts(StatementExpressionContext.class); + } + public StatementExpressionContext statementExpression(int i) { + return getRuleContext(StatementExpressionContext.class,i); + } + public StatementExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementExpressionList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementExpressionList(this); + else return visitor.visitChildren(this); + } + } + + public final StatementExpressionListContext statementExpressionList() throws RecognitionException { + StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_statementExpressionList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1714); + statementExpression(); + setState(1719); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1715); + match(COMMA); + setState(1716); + statementExpression(); + } + } + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnhancedForStatementContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enhancedForStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnhancedForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException { + EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_enhancedForStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1722); + match(FOR); + setState(1723); + match(LPAREN); + setState(1727); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1724); + variableModifier(); + } + } + setState(1729); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1730); + unannType(); + setState(1731); + variableDeclaratorId(); + setState(1732); + match(COLON); + setState(1733); + expression(); + setState(1734); + match(RPAREN); + setState(1735); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enhancedForStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnhancedForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException { + EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_enhancedForStatementNoShortIf); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1737); + match(FOR); + setState(1738); + match(LPAREN); + setState(1742); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1739); + variableModifier(); + } + } + setState(1744); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1745); + unannType(); + setState(1746); + variableDeclaratorId(); + setState(1747); + match(COLON); + setState(1748); + expression(); + setState(1749); + match(RPAREN); + setState(1750); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public BreakStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBreakStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BreakStatementContext breakStatement() throws RecognitionException { + BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_breakStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1752); + match(BREAK); + setState(1754); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1753); + match(Identifier); + } + } + + setState(1756); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continueStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitContinueStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ContinueStatementContext continueStatement() throws RecognitionException { + ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_continueStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1758); + match(CONTINUE); + setState(1760); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1759); + match(Identifier); + } + } + + setState(1762); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReturnStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_returnStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1764); + match(RETURN); + setState(1766); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1765); + expression(); + } + } + + setState(1768); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ThrowStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ThrowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitThrowStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ThrowStatementContext throwStatement() throws RecognitionException { + ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_throwStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1770); + match(THROW); + setState(1771); + expression(); + setState(1772); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SynchronizedStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_synchronizedStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSynchronizedStatement(this); + else return visitor.visitChildren(this); + } + } + + public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException { + SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_synchronizedStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1774); + match(SYNCHRONIZED); + setState(1775); + match(LPAREN); + setState(1776); + expression(); + setState(1777); + match(RPAREN); + setState(1778); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryStatementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchesContext catches() { + return getRuleContext(CatchesContext.class,0); + } + public Finally_Context finally_() { + return getRuleContext(Finally_Context.class,0); + } + public TryWithResourcesStatementContext tryWithResourcesStatement() { + return getRuleContext(TryWithResourcesStatementContext.class,0); + } + public TryStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTryStatement(this); + else return visitor.visitChildren(this); + } + } + + public final TryStatementContext tryStatement() throws RecognitionException { + TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_tryStatement); + int _la; + try { + setState(1792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1780); + match(TRY); + setState(1781); + block(); + setState(1782); + catches(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1784); + match(TRY); + setState(1785); + block(); + setState(1787); + _la = _input.LA(1); + if (_la==CATCH) { + { + setState(1786); + catches(); + } + } + + setState(1789); + finally_(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1791); + tryWithResourcesStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchesContext extends ParserRuleContext { + public List<CatchClauseContext> catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public CatchesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catches; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatches(this); + else return visitor.visitChildren(this); + } + } + + public final CatchesContext catches() throws RecognitionException { + CatchesContext _localctx = new CatchesContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_catches); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1794); + catchClause(); + setState(1798); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CATCH) { + { + { + setState(1795); + catchClause(); + } + } + setState(1800); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchClauseContext extends ParserRuleContext { + public CatchFormalParameterContext catchFormalParameter() { + return getRuleContext(CatchFormalParameterContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchClause(this); + else return visitor.visitChildren(this); + } + } + + public final CatchClauseContext catchClause() throws RecognitionException { + CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_catchClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1801); + match(CATCH); + setState(1802); + match(LPAREN); + setState(1803); + catchFormalParameter(); + setState(1804); + match(RPAREN); + setState(1805); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchFormalParameterContext extends ParserRuleContext { + public CatchTypeContext catchType() { + return getRuleContext(CatchTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchFormalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException { + CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_catchFormalParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1807); + variableModifier(); + } + } + setState(1812); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1813); + catchType(); + setState(1814); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchTypeContext extends ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return getRuleContext(UnannClassTypeContext.class,0); + } + public List<ClassTypeContext> classType() { + return getRuleContexts(ClassTypeContext.class); + } + public ClassTypeContext classType(int i) { + return getRuleContext(ClassTypeContext.class,i); + } + public CatchTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchType(this); + else return visitor.visitChildren(this); + } + } + + public final CatchTypeContext catchType() throws RecognitionException { + CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_catchType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1816); + unannClassType(); + setState(1821); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITOR) { + { + { + setState(1817); + match(BITOR); + setState(1818); + classType(); + } + } + setState(1823); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Finally_Context extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Finally_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finally_; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFinally_(this); + else return visitor.visitChildren(this); + } + } + + public final Finally_Context finally_() throws RecognitionException { + Finally_Context _localctx = new Finally_Context(_ctx, getState()); + enterRule(_localctx, 342, RULE_finally_); + try { + enterOuterAlt(_localctx, 1); + { + setState(1824); + match(FINALLY); + setState(1825); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryWithResourcesStatementContext extends ParserRuleContext { + public ResourceSpecificationContext resourceSpecification() { + return getRuleContext(ResourceSpecificationContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchesContext catches() { + return getRuleContext(CatchesContext.class,0); + } + public Finally_Context finally_() { + return getRuleContext(Finally_Context.class,0); + } + public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryWithResourcesStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTryWithResourcesStatement(this); + else return visitor.visitChildren(this); + } + } + + public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException { + TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_tryWithResourcesStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1827); + match(TRY); + setState(1828); + resourceSpecification(); + setState(1829); + block(); + setState(1831); + _la = _input.LA(1); + if (_la==CATCH) { + { + setState(1830); + catches(); + } + } + + setState(1834); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(1833); + finally_(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceSpecificationContext extends ParserRuleContext { + public ResourceListContext resourceList() { + return getRuleContext(ResourceListContext.class,0); + } + public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resourceSpecification; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResourceSpecification(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { + ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_resourceSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1836); + match(LPAREN); + setState(1837); + resourceList(); + setState(1839); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1838); + match(SEMI); + } + } + + setState(1841); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceListContext extends ParserRuleContext { + public List<ResourceContext> resource() { + return getRuleContexts(ResourceContext.class); + } + public ResourceContext resource(int i) { + return getRuleContext(ResourceContext.class,i); + } + public ResourceListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resourceList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResourceList(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceListContext resourceList() throws RecognitionException { + ResourceListContext _localctx = new ResourceListContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_resourceList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1843); + resource(); + setState(1848); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1844); + match(SEMI); + setState(1845); + resource(); + } + } + } + setState(1850); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public ResourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resource; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResource(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceContext resource() throws RecognitionException { + ResourceContext _localctx = new ResourceContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_resource); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1854); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1851); + variableModifier(); + } + } + setState(1856); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1857); + unannType(); + setState(1858); + variableDeclaratorId(); + setState(1859); + match(ASSIGN); + setState(1860); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() { + return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class,0); + } + public ArrayCreationExpressionContext arrayCreationExpression() { + return getRuleContext(ArrayCreationExpressionContext.class,0); + } + public List<PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() { + return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class); + } + public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class,i); + } + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryContext primary() throws RecognitionException { + PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1864); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { + case 1: + { + setState(1862); + primaryNoNewArray_lfno_primary(); + } + break; + case 2: + { + setState(1863); + arrayCreationExpression(); + } + break; + } + setState(1869); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,192,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1866); + primaryNoNewArray_lf_primary(); + } + } + } + setState(1871); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,192,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArrayContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public ArrayAccessContext arrayAccess() { + return getRuleContext(ArrayAccessContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public MethodReferenceContext methodReference() { + return getRuleContext(MethodReferenceContext.class,0); + } + public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException { + PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_primaryNoNewArray); + int _la; + try { + setState(1901); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1872); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1873); + typeName(); + setState(1878); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1874); + match(LBRACK); + setState(1875); + match(RBRACK); + } + } + setState(1880); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1881); + match(DOT); + setState(1882); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1884); + match(VOID); + setState(1885); + match(DOT); + setState(1886); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1887); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1888); + typeName(); + setState(1889); + match(DOT); + setState(1890); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1892); + match(LPAREN); + setState(1893); + expression(); + setState(1894); + match(RPAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1896); + classInstanceCreationExpression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1897); + fieldAccess(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1898); + arrayAccess(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1899); + methodInvocation(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1900); + methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_arrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException { + PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_primaryNoNewArray_lf_arrayAccess); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public MethodReferenceContext methodReference() { + return getRuleContext(MethodReferenceContext.class,0); + } + public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_arrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException { + PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_primaryNoNewArray_lfno_arrayAccess); + int _la; + try { + setState(1933); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1905); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1906); + typeName(); + setState(1911); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1907); + match(LBRACK); + setState(1908); + match(RBRACK); + } + } + setState(1913); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1914); + match(DOT); + setState(1915); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1917); + match(VOID); + setState(1918); + match(DOT); + setState(1919); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1920); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1921); + typeName(); + setState(1922); + match(DOT); + setState(1923); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1925); + match(LPAREN); + setState(1926); + expression(); + setState(1927); + match(RPAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1929); + classInstanceCreationExpression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1930); + fieldAccess(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1931); + methodInvocation(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1932); + methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return getRuleContext(FieldAccess_lf_primaryContext.class,0); + } + public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() { + return getRuleContext(ArrayAccess_lf_primaryContext.class,0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return getRuleContext(MethodInvocation_lf_primaryContext.class,0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return getRuleContext(MethodReference_lf_primaryContext.class,0); + } + public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_primaryNoNewArray_lf_primary); + try { + setState(1940); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1935); + classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1936); + fieldAccess_lf_primary(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1937); + arrayAccess_lf_primary(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1938); + methodInvocation_lf_primary(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1939); + methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return getRuleContext(FieldAccess_lf_primaryContext.class,0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return getRuleContext(MethodInvocation_lf_primaryContext.class,0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return getRuleContext(MethodReference_lf_primaryContext.class,0); + } + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary); + try { + setState(1948); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1944); + classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1945); + fieldAccess_lf_primary(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1946); + methodInvocation_lf_primary(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1947); + methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return getRuleContext(FieldAccess_lfno_primaryContext.class,0); + } + public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() { + return getRuleContext(ArrayAccess_lfno_primaryContext.class,0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return getRuleContext(MethodInvocation_lfno_primaryContext.class,0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return getRuleContext(MethodReference_lfno_primaryContext.class,0); + } + public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_primaryNoNewArray_lfno_primary); + int _la; + try { + setState(1990); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1950); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1951); + typeName(); + setState(1956); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1952); + match(LBRACK); + setState(1953); + match(RBRACK); + } + } + setState(1958); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1959); + match(DOT); + setState(1960); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1962); + unannPrimitiveType(); + setState(1967); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1963); + match(LBRACK); + setState(1964); + match(RBRACK); + } + } + setState(1969); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1970); + match(DOT); + setState(1971); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1973); + match(VOID); + setState(1974); + match(DOT); + setState(1975); + match(CLASS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1976); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1977); + typeName(); + setState(1978); + match(DOT); + setState(1979); + match(THIS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1981); + match(LPAREN); + setState(1982); + expression(); + setState(1983); + match(RPAREN); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1985); + classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1986); + fieldAccess_lfno_primary(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1987); + arrayAccess_lfno_primary(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1988); + methodInvocation_lfno_primary(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1989); + methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return getRuleContext(FieldAccess_lfno_primaryContext.class,0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return getRuleContext(MethodInvocation_lfno_primaryContext.class,0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return getRuleContext(MethodReference_lfno_primaryContext.class,0); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary); + int _la; + try { + setState(2033); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1994); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1995); + typeName(); + setState(2000); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1996); + match(LBRACK); + setState(1997); + match(RBRACK); + } + } + setState(2002); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2003); + match(DOT); + setState(2004); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2006); + unannPrimitiveType(); + setState(2011); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(2007); + match(LBRACK); + setState(2008); + match(RBRACK); + } + } + setState(2013); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2014); + match(DOT); + setState(2015); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2017); + match(VOID); + setState(2018); + match(DOT); + setState(2019); + match(CLASS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2020); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2021); + typeName(); + setState(2022); + match(DOT); + setState(2023); + match(THIS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2025); + match(LPAREN); + setState(2026); + expression(); + setState(2027); + match(RPAREN); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2029); + classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2030); + fieldAccess_lfno_primary(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2031); + methodInvocation_lfno_primary(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2032); + methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpressionContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException { + ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_classInstanceCreationExpression); + int _la; + try { + setState(2118); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2035); + match(NEW); + setState(2037); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2036); + typeArguments(); + } + } + + setState(2042); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2039); + annotation(); + } + } + setState(2044); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2045); + match(Identifier); + setState(2056); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(2046); + match(DOT); + setState(2050); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2047); + annotation(); + } + } + setState(2052); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2053); + match(Identifier); + } + } + setState(2058); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2060); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2059); + typeArgumentsOrDiamond(); + } + } + + setState(2062); + match(LPAREN); + setState(2064); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2063); + argumentList(); + } + } + + setState(2066); + match(RPAREN); + setState(2068); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2067); + classBody(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2070); + expressionName(); + setState(2071); + match(DOT); + setState(2072); + match(NEW); + setState(2074); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2073); + typeArguments(); + } + } + + setState(2079); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2076); + annotation(); + } + } + setState(2081); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2082); + match(Identifier); + setState(2084); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2083); + typeArgumentsOrDiamond(); + } + } + + setState(2086); + match(LPAREN); + setState(2088); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2087); + argumentList(); + } + } + + setState(2090); + match(RPAREN); + setState(2092); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2091); + classBody(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2094); + primary(); + setState(2095); + match(DOT); + setState(2096); + match(NEW); + setState(2098); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2097); + typeArguments(); + } + } + + setState(2103); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2100); + annotation(); + } + } + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2106); + match(Identifier); + setState(2108); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2107); + typeArgumentsOrDiamond(); + } + } + + setState(2110); + match(LPAREN); + setState(2112); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2111); + argumentList(); + } + } + + setState(2114); + match(RPAREN); + setState(2116); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2115); + classBody(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException { + ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_classInstanceCreationExpression_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2120); + match(DOT); + setState(2121); + match(NEW); + setState(2123); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2122); + typeArguments(); + } + } + + setState(2128); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2125); + annotation(); + } + } + setState(2130); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2131); + match(Identifier); + setState(2133); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2132); + typeArgumentsOrDiamond(); + } + } + + setState(2135); + match(LPAREN); + setState(2137); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(2136); + argumentList(); + } + } + + setState(2139); + match(RPAREN); + setState(2141); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { + case 1: + { + setState(2140); + classBody(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException { + ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_classInstanceCreationExpression_lfno_primary); + int _la; + try { + setState(2202); + switch (_input.LA(1)) { + case NEW: + enterOuterAlt(_localctx, 1); + { + setState(2143); + match(NEW); + setState(2145); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2144); + typeArguments(); + } + } + + setState(2150); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2147); + annotation(); + } + } + setState(2152); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2153); + match(Identifier); + setState(2164); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(2154); + match(DOT); + setState(2158); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2155); + annotation(); + } + } + setState(2160); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2161); + match(Identifier); + } + } + setState(2166); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2168); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2167); + typeArgumentsOrDiamond(); + } + } + + setState(2170); + match(LPAREN); + setState(2172); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2171); + argumentList(); + } + } + + setState(2174); + match(RPAREN); + setState(2176); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) { + case 1: + { + setState(2175); + classBody(); + } + break; + } + } + break; + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(2178); + expressionName(); + setState(2179); + match(DOT); + setState(2180); + match(NEW); + setState(2182); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2181); + typeArguments(); + } + } + + setState(2187); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2184); + annotation(); + } + } + setState(2189); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2190); + match(Identifier); + setState(2192); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2191); + typeArgumentsOrDiamond(); + } + } + + setState(2194); + match(LPAREN); + setState(2196); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2195); + argumentList(); + } + } + + setState(2198); + match(RPAREN); + setState(2200); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) { + case 1: + { + setState(2199); + classBody(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { + TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_typeArgumentsOrDiamond); + try { + setState(2207); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,241,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2204); + typeArguments(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2205); + match(LT); + setState(2206); + match(GT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccessContext extends ParserRuleContext { + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public FieldAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccessContext fieldAccess() throws RecognitionException { + FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_fieldAccess); + try { + setState(2222); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2209); + primary(); + setState(2210); + match(DOT); + setState(2211); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2213); + match(SUPER); + setState(2214); + match(DOT); + setState(2215); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2216); + typeName(); + setState(2217); + match(DOT); + setState(2218); + match(SUPER); + setState(2219); + match(DOT); + setState(2220); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccess_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException { + FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_fieldAccess_lf_primary); + try { + enterOuterAlt(_localctx, 1); + { + setState(2224); + match(DOT); + setState(2225); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccess_lfno_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException { + FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_fieldAccess_lfno_primary); + try { + setState(2236); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(2227); + match(SUPER); + setState(2228); + match(DOT); + setState(2229); + match(Identifier); + } + break; + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(2230); + typeName(); + setState(2231); + match(DOT); + setState(2232); + match(SUPER); + setState(2233); + match(DOT); + setState(2234); + match(Identifier); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccessContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { + return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0); + } + public List<PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() { + return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class); + } + public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) { + return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class,i); + } + public ArrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccessContext arrayAccess() throws RecognitionException { + ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_arrayAccess); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2248); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) { + case 1: + { + setState(2238); + expressionName(); + setState(2239); + match(LBRACK); + setState(2240); + expression(); + setState(2241); + match(RBRACK); + } + break; + case 2: + { + setState(2243); + primaryNoNewArray_lfno_arrayAccess(); + setState(2244); + match(LBRACK); + setState(2245); + expression(); + setState(2246); + match(RBRACK); + } + break; + } + setState(2257); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(2250); + primaryNoNewArray_lf_arrayAccess(); + setState(2251); + match(LBRACK); + setState(2252); + expression(); + setState(2253); + match(RBRACK); + } + } + setState(2259); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccess_lf_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { + return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List<PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { + return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class); + } + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class,i); + } + public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException { + ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_arrayAccess_lf_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2260); + primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(); + setState(2261); + match(LBRACK); + setState(2262); + expression(); + setState(2263); + match(RBRACK); + } + setState(2272); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,246,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2265); + primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(); + setState(2266); + match(LBRACK); + setState(2267); + expression(); + setState(2268); + match(RBRACK); + } + } + } + setState(2274); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,246,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { + return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0); + } + public List<PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() { + return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class); + } + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class,i); + } + public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException { + ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_arrayAccess_lfno_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2285); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) { + case 1: + { + setState(2275); + expressionName(); + setState(2276); + match(LBRACK); + setState(2277); + expression(); + setState(2278); + match(RBRACK); + } + break; + case 2: + { + setState(2280); + primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(); + setState(2281); + match(LBRACK); + setState(2282); + expression(); + setState(2283); + match(RBRACK); + } + break; + } + setState(2294); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,248,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2287); + primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(); + setState(2288); + match(LBRACK); + setState(2289); + expression(); + setState(2290); + match(RBRACK); + } + } + } + setState(2296); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,248,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocationContext extends ParserRuleContext { + public MethodNameContext methodName() { + return getRuleContext(MethodNameContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public MethodInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocationContext methodInvocation() throws RecognitionException { + MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_methodInvocation); + int _la; + try { + setState(2365); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,260,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2297); + methodName(); + setState(2298); + match(LPAREN); + setState(2300); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2299); + argumentList(); + } + } + + setState(2302); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2304); + typeName(); + setState(2305); + match(DOT); + setState(2307); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2306); + typeArguments(); + } + } + + setState(2309); + match(Identifier); + setState(2310); + match(LPAREN); + setState(2312); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2311); + argumentList(); + } + } + + setState(2314); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2316); + expressionName(); + setState(2317); + match(DOT); + setState(2319); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2318); + typeArguments(); + } + } + + setState(2321); + match(Identifier); + setState(2322); + match(LPAREN); + setState(2324); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2323); + argumentList(); + } + } + + setState(2326); + match(RPAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2328); + primary(); + setState(2329); + match(DOT); + setState(2331); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2330); + typeArguments(); + } + } + + setState(2333); + match(Identifier); + setState(2334); + match(LPAREN); + setState(2336); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2335); + argumentList(); + } + } + + setState(2338); + match(RPAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2340); + match(SUPER); + setState(2341); + match(DOT); + setState(2343); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2342); + typeArguments(); + } + } + + setState(2345); + match(Identifier); + setState(2346); + match(LPAREN); + setState(2348); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2347); + argumentList(); + } + } + + setState(2350); + match(RPAREN); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2351); + typeName(); + setState(2352); + match(DOT); + setState(2353); + match(SUPER); + setState(2354); + match(DOT); + setState(2356); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2355); + typeArguments(); + } + } + + setState(2358); + match(Identifier); + setState(2359); + match(LPAREN); + setState(2361); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2360); + argumentList(); + } + } + + setState(2363); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocation_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException { + MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_methodInvocation_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2367); + match(DOT); + setState(2369); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2368); + typeArguments(); + } + } + + setState(2371); + match(Identifier); + setState(2372); + match(LPAREN); + setState(2374); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(2373); + argumentList(); + } + } + + setState(2376); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext { + public MethodNameContext methodName() { + return getRuleContext(MethodNameContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException { + MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_methodInvocation_lfno_primary); + int _la; + try { + setState(2434); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2378); + methodName(); + setState(2379); + match(LPAREN); + setState(2381); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2380); + argumentList(); + } + } + + setState(2383); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2385); + typeName(); + setState(2386); + match(DOT); + setState(2388); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2387); + typeArguments(); + } + } + + setState(2390); + match(Identifier); + setState(2391); + match(LPAREN); + setState(2393); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2392); + argumentList(); + } + } + + setState(2395); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2397); + expressionName(); + setState(2398); + match(DOT); + setState(2400); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2399); + typeArguments(); + } + } + + setState(2402); + match(Identifier); + setState(2403); + match(LPAREN); + setState(2405); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2404); + argumentList(); + } + } + + setState(2407); + match(RPAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2409); + match(SUPER); + setState(2410); + match(DOT); + setState(2412); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2411); + typeArguments(); + } + } + + setState(2414); + match(Identifier); + setState(2415); + match(LPAREN); + setState(2417); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2416); + argumentList(); + } + } + + setState(2419); + match(RPAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2420); + typeName(); + setState(2421); + match(DOT); + setState(2422); + match(SUPER); + setState(2423); + match(DOT); + setState(2425); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2424); + typeArguments(); + } + } + + setState(2427); + match(Identifier); + setState(2428); + match(LPAREN); + setState(2430); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2429); + argumentList(); + } + } + + setState(2432); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArgumentListContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argumentList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentListContext argumentList() throws RecognitionException { + ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_argumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2436); + expression(); + setState(2441); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2437); + match(COMMA); + setState(2438); + expression(); + } + } + setState(2443); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReferenceContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public MethodReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReferenceContext methodReference() throws RecognitionException { + MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_methodReference); + int _la; + try { + setState(2491); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2444); + expressionName(); + setState(2445); + match(COLONCOLON); + setState(2447); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2446); + typeArguments(); + } + } + + setState(2449); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2451); + referenceType(); + setState(2452); + match(COLONCOLON); + setState(2454); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2453); + typeArguments(); + } + } + + setState(2456); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2458); + primary(); + setState(2459); + match(COLONCOLON); + setState(2461); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2460); + typeArguments(); + } + } + + setState(2463); + match(Identifier); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2465); + match(SUPER); + setState(2466); + match(COLONCOLON); + setState(2468); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2467); + typeArguments(); + } + } + + setState(2470); + match(Identifier); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2471); + typeName(); + setState(2472); + match(DOT); + setState(2473); + match(SUPER); + setState(2474); + match(COLONCOLON); + setState(2476); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2475); + typeArguments(); + } + } + + setState(2478); + match(Identifier); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2480); + classType(); + setState(2481); + match(COLONCOLON); + setState(2483); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2482); + typeArguments(); + } + } + + setState(2485); + match(NEW); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2487); + arrayType(); + setState(2488); + match(COLONCOLON); + setState(2489); + match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReference_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException { + MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_methodReference_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2493); + match(COLONCOLON); + setState(2495); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2494); + typeArguments(); + } + } + + setState(2497); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReference_lfno_primaryContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException { + MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_methodReference_lfno_primary); + int _la; + try { + setState(2539); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2499); + expressionName(); + setState(2500); + match(COLONCOLON); + setState(2502); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2501); + typeArguments(); + } + } + + setState(2504); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2506); + referenceType(); + setState(2507); + match(COLONCOLON); + setState(2509); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2508); + typeArguments(); + } + } + + setState(2511); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2513); + match(SUPER); + setState(2514); + match(COLONCOLON); + setState(2516); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2515); + typeArguments(); + } + } + + setState(2518); + match(Identifier); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2519); + typeName(); + setState(2520); + match(DOT); + setState(2521); + match(SUPER); + setState(2522); + match(COLONCOLON); + setState(2524); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2523); + typeArguments(); + } + } + + setState(2526); + match(Identifier); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2528); + classType(); + setState(2529); + match(COLONCOLON); + setState(2531); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2530); + typeArguments(); + } + } + + setState(2533); + match(NEW); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2535); + arrayType(); + setState(2536); + match(COLONCOLON); + setState(2537); + match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayCreationExpressionContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public DimExprsContext dimExprs() { + return getRuleContext(DimExprsContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayCreationExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayCreationExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException { + ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_arrayCreationExpression); + try { + setState(2563); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2541); + match(NEW); + setState(2542); + primitiveType(); + setState(2543); + dimExprs(); + setState(2545); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,288,_ctx) ) { + case 1: + { + setState(2544); + dims(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2547); + match(NEW); + setState(2548); + classOrInterfaceType(); + setState(2549); + dimExprs(); + setState(2551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) { + case 1: + { + setState(2550); + dims(); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2553); + match(NEW); + setState(2554); + primitiveType(); + setState(2555); + dims(); + setState(2556); + arrayInitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2558); + match(NEW); + setState(2559); + classOrInterfaceType(); + setState(2560); + dims(); + setState(2561); + arrayInitializer(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimExprsContext extends ParserRuleContext { + public List<DimExprContext> dimExpr() { + return getRuleContexts(DimExprContext.class); + } + public DimExprContext dimExpr(int i) { + return getRuleContext(DimExprContext.class,i); + } + public DimExprsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dimExprs; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDimExprs(this); + else return visitor.visitChildren(this); + } + } + + public final DimExprsContext dimExprs() throws RecognitionException { + DimExprsContext _localctx = new DimExprsContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_dimExprs); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2565); + dimExpr(); + setState(2569); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,291,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2566); + dimExpr(); + } + } + } + setState(2571); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,291,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimExprContext extends ParserRuleContext { + 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 DimExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dimExpr; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDimExpr(this); + else return visitor.visitChildren(this); + } + } + + public final DimExprContext dimExpr() throws RecognitionException { + DimExprContext _localctx = new DimExprContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_dimExpr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2575); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2572); + annotation(); + } + } + setState(2577); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2578); + match(LBRACK); + setState(2579); + expression(); + setState(2580); + match(RBRACK); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantExpressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantExpressionContext constantExpression() throws RecognitionException { + ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_constantExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2582); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionContext extends ParserRuleContext { + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class,0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_expression); + try { + setState(2586); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2584); + lambdaExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2585); + assignmentExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaExpressionContext extends ParserRuleContext { + public LambdaParametersContext lambdaParameters() { + return getRuleContext(LambdaParametersContext.class,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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaExpression(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_lambdaExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2588); + lambdaParameters(); + setState(2589); + match(ARROW); + setState(2590); + lambdaBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaParametersContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public InferredFormalParameterListContext inferredFormalParameterList() { + return getRuleContext(InferredFormalParameterListContext.class,0); + } + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaParameters(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_lambdaParameters); + int _la; + try { + setState(2602); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2592); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2593); + match(LPAREN); + setState(2595); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(2594); + formalParameterList(); + } + } + + setState(2597); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2598); + match(LPAREN); + setState(2599); + inferredFormalParameterList(); + setState(2600); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InferredFormalParameterListContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inferredFormalParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInferredFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException { + InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_inferredFormalParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2604); + match(Identifier); + setState(2609); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2605); + match(COMMA); + setState(2606); + match(Identifier); + } + } + setState(2611); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class 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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaBody(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaBodyContext lambdaBody() throws RecognitionException { + LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_lambdaBody); + try { + setState(2614); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + case AT: + enterOuterAlt(_localctx, 1); + { + setState(2612); + expression(); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(2613); + 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; + } + + public static class AssignmentExpressionContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignmentExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentExpressionContext assignmentExpression() throws RecognitionException { + AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_assignmentExpression); + try { + setState(2618); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2616); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2617); + assignment(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentContext extends ParserRuleContext { + public LeftHandSideContext leftHandSide() { + return getRuleContext(LeftHandSideContext.class,0); + } + public AssignmentOperatorContext assignmentOperator() { + return getRuleContext(AssignmentOperatorContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignment; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignment(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(2620); + leftHandSide(); + setState(2621); + assignmentOperator(); + setState(2622); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LeftHandSideContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public ArrayAccessContext arrayAccess() { + return getRuleContext(ArrayAccessContext.class,0); + } + public LeftHandSideContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_leftHandSide; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLeftHandSide(this); + else return visitor.visitChildren(this); + } + } + + public final LeftHandSideContext leftHandSide() throws RecognitionException { + LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_leftHandSide); + try { + setState(2627); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,299,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2624); + expressionName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2625); + fieldAccess(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2626); + arrayAccess(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentOperatorContext extends ParserRuleContext { + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentOperator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignmentOperator(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2629); + _la = _input.LA(1); + if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ASSIGN - 66)) | (1L << (ADD_ASSIGN - 66)) | (1L << (SUB_ASSIGN - 66)) | (1L << (MUL_ASSIGN - 66)) | (1L << (DIV_ASSIGN - 66)) | (1L << (AND_ASSIGN - 66)) | (1L << (OR_ASSIGN - 66)) | (1L << (XOR_ASSIGN - 66)) | (1L << (MOD_ASSIGN - 66)) | (1L << (LSHIFT_ASSIGN - 66)) | (1L << (RSHIFT_ASSIGN - 66)) | (1L << (URSHIFT_ASSIGN - 66)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionalExpressionContext extends ParserRuleContext { + public ConditionalOrExpressionContext conditionalOrExpression() { + return getRuleContext(ConditionalOrExpressionContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalExpressionContext conditionalExpression() throws RecognitionException { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_conditionalExpression); + try { + setState(2638); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,300,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2631); + conditionalOrExpression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2632); + conditionalOrExpression(0); + setState(2633); + match(QUESTION); + setState(2634); + expression(); + setState(2635); + match(COLON); + setState(2636); + conditionalExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionalOrExpressionContext extends ParserRuleContext { + public ConditionalAndExpressionContext conditionalAndExpression() { + return getRuleContext(ConditionalAndExpressionContext.class,0); + } + public ConditionalOrExpressionContext conditionalOrExpression() { + return getRuleContext(ConditionalOrExpressionContext.class,0); + } + public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException { + return conditionalOrExpression(0); + } + + private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState); + ConditionalOrExpressionContext _prevctx = _localctx; + int _startState = 434; + enterRecursionRule(_localctx, 434, RULE_conditionalOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2641); + conditionalAndExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2648); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,301,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression); + setState(2643); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2644); + match(OR); + setState(2645); + conditionalAndExpression(0); + } + } + } + setState(2650); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,301,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ConditionalAndExpressionContext extends ParserRuleContext { + public InclusiveOrExpressionContext inclusiveOrExpression() { + return getRuleContext(InclusiveOrExpressionContext.class,0); + } + public ConditionalAndExpressionContext conditionalAndExpression() { + return getRuleContext(ConditionalAndExpressionContext.class,0); + } + public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalAndExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalAndExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException { + return conditionalAndExpression(0); + } + + private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState); + ConditionalAndExpressionContext _prevctx = _localctx; + int _startState = 436; + enterRecursionRule(_localctx, 436, RULE_conditionalAndExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2652); + inclusiveOrExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2659); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,302,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalAndExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression); + setState(2654); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2655); + match(AND); + setState(2656); + inclusiveOrExpression(0); + } + } + } + setState(2661); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,302,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class InclusiveOrExpressionContext extends ParserRuleContext { + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return getRuleContext(ExclusiveOrExpressionContext.class,0); + } + public InclusiveOrExpressionContext inclusiveOrExpression() { + return getRuleContext(InclusiveOrExpressionContext.class,0); + } + public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inclusiveOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException { + return inclusiveOrExpression(0); + } + + private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState); + InclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 438; + enterRecursionRule(_localctx, 438, RULE_inclusiveOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2663); + exclusiveOrExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2670); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,303,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new InclusiveOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression); + setState(2665); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2666); + match(BITOR); + setState(2667); + exclusiveOrExpression(0); + } + } + } + setState(2672); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,303,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ExclusiveOrExpressionContext extends ParserRuleContext { + public AndExpressionContext andExpression() { + return getRuleContext(AndExpressionContext.class,0); + } + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return getRuleContext(ExclusiveOrExpressionContext.class,0); + } + public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusiveOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException { + return exclusiveOrExpression(0); + } + + private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState); + ExclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 440; + enterRecursionRule(_localctx, 440, RULE_exclusiveOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2674); + andExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2681); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,304,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression); + setState(2676); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2677); + match(CARET); + setState(2678); + andExpression(0); + } + } + } + setState(2683); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,304,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AndExpressionContext extends ParserRuleContext { + public EqualityExpressionContext equalityExpression() { + return getRuleContext(EqualityExpressionContext.class,0); + } + public AndExpressionContext andExpression() { + return getRuleContext(AndExpressionContext.class,0); + } + public AndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_andExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAndExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AndExpressionContext andExpression() throws RecognitionException { + return andExpression(0); + } + + private AndExpressionContext andExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState); + AndExpressionContext _prevctx = _localctx; + int _startState = 442; + enterRecursionRule(_localctx, 442, RULE_andExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2685); + equalityExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2692); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,305,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AndExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_andExpression); + setState(2687); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2688); + match(BITAND); + setState(2689); + equalityExpression(0); + } + } + } + setState(2694); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,305,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class EqualityExpressionContext extends ParserRuleContext { + public RelationalExpressionContext relationalExpression() { + return getRuleContext(RelationalExpressionContext.class,0); + } + public EqualityExpressionContext equalityExpression() { + return getRuleContext(EqualityExpressionContext.class,0); + } + public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_equalityExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEqualityExpression(this); + else return visitor.visitChildren(this); + } + } + + public final EqualityExpressionContext equalityExpression() throws RecognitionException { + return equalityExpression(0); + } + + private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState); + EqualityExpressionContext _prevctx = _localctx; + int _startState = 444; + enterRecursionRule(_localctx, 444, RULE_equalityExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2696); + relationalExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2706); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,307,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2704); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) { + case 1: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + setState(2698); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2699); + match(EQUAL); + setState(2700); + relationalExpression(0); + } + break; + case 2: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + setState(2701); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2702); + match(NOTEQUAL); + setState(2703); + relationalExpression(0); + } + break; + } + } + } + setState(2708); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,307,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class RelationalExpressionContext extends ParserRuleContext { + public ShiftExpressionContext shiftExpression() { + return getRuleContext(ShiftExpressionContext.class,0); + } + public RelationalExpressionContext relationalExpression() { + return getRuleContext(RelationalExpressionContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public RelationalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relationalExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitRelationalExpression(this); + else return visitor.visitChildren(this); + } + } + + public final RelationalExpressionContext relationalExpression() throws RecognitionException { + return relationalExpression(0); + } + + private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState); + RelationalExpressionContext _prevctx = _localctx; + int _startState = 446; + enterRecursionRule(_localctx, 446, RULE_relationalExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2710); + shiftExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2729); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,309,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2727); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) { + case 1: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2712); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(2713); + match(LT); + setState(2714); + shiftExpression(0); + } + break; + case 2: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2715); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(2716); + match(GT); + setState(2717); + shiftExpression(0); + } + break; + case 3: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2718); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2719); + match(LE); + setState(2720); + shiftExpression(0); + } + break; + case 4: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2721); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2722); + match(GE); + setState(2723); + shiftExpression(0); + } + break; + case 5: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2724); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2725); + match(INSTANCEOF); + setState(2726); + referenceType(); + } + break; + } + } + } + setState(2731); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,309,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ShiftExpressionContext extends ParserRuleContext { + public AdditiveExpressionContext additiveExpression() { + return getRuleContext(AdditiveExpressionContext.class,0); + } + public ShiftExpressionContext shiftExpression() { + return getRuleContext(ShiftExpressionContext.class,0); + } + public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shiftExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitShiftExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ShiftExpressionContext shiftExpression() throws RecognitionException { + return shiftExpression(0); + } + + private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState); + ShiftExpressionContext _prevctx = _localctx; + int _startState = 448; + enterRecursionRule(_localctx, 448, RULE_shiftExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2733); + additiveExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2750); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2748); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) { + case 1: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2735); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2736); + match(LT); + setState(2737); + match(LT); + setState(2738); + additiveExpression(0); + } + break; + case 2: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2739); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2740); + match(GT); + setState(2741); + match(GT); + setState(2742); + additiveExpression(0); + } + break; + case 3: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2743); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2744); + match(GT); + setState(2745); + match(GT); + setState(2746); + match(GT); + setState(2747); + additiveExpression(0); + } + break; + } + } + } + setState(2752); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AdditiveExpressionContext extends ParserRuleContext { + public MultiplicativeExpressionContext multiplicativeExpression() { + return getRuleContext(MultiplicativeExpressionContext.class,0); + } + public AdditiveExpressionContext additiveExpression() { + return getRuleContext(AdditiveExpressionContext.class,0); + } + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additiveExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAdditiveExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AdditiveExpressionContext additiveExpression() throws RecognitionException { + return additiveExpression(0); + } + + private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState); + AdditiveExpressionContext _prevctx = _localctx; + int _startState = 450; + enterRecursionRule(_localctx, 450, RULE_additiveExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2754); + multiplicativeExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2764); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,313,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2762); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,312,_ctx) ) { + case 1: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + setState(2756); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2757); + match(ADD); + setState(2758); + multiplicativeExpression(0); + } + break; + case 2: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + setState(2759); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2760); + match(SUB); + setState(2761); + multiplicativeExpression(0); + } + break; + } + } + } + setState(2766); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,313,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public MultiplicativeExpressionContext multiplicativeExpression() { + return getRuleContext(MultiplicativeExpressionContext.class,0); + } + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multiplicativeExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMultiplicativeExpression(this); + else return visitor.visitChildren(this); + } + } + + public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { + return multiplicativeExpression(0); + } + + private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState); + MultiplicativeExpressionContext _prevctx = _localctx; + int _startState = 452; + enterRecursionRule(_localctx, 452, RULE_multiplicativeExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2768); + unaryExpression(); + } + _ctx.stop = _input.LT(-1); + setState(2781); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,315,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2779); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,314,_ctx) ) { + case 1: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2770); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2771); + match(MUL); + setState(2772); + unaryExpression(); + } + break; + case 2: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2773); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2774); + match(DIV); + setState(2775); + unaryExpression(); + } + break; + case 3: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2776); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2777); + match(MOD); + setState(2778); + unaryExpression(); + } + break; + } + } + } + setState(2783); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,315,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class UnaryExpressionContext extends ParserRuleContext { + public PreIncrementExpressionContext preIncrementExpression() { + return getRuleContext(PreIncrementExpressionContext.class,0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return getRuleContext(PreDecrementExpressionContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0); + } + public UnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnaryExpression(this); + else return visitor.visitChildren(this); + } + } + + public final UnaryExpressionContext unaryExpression() throws RecognitionException { + UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 454, RULE_unaryExpression); + try { + setState(2791); + switch (_input.LA(1)) { + case INC: + enterOuterAlt(_localctx, 1); + { + setState(2784); + preIncrementExpression(); + } + break; + case DEC: + enterOuterAlt(_localctx, 2); + { + setState(2785); + preDecrementExpression(); + } + break; + case ADD: + enterOuterAlt(_localctx, 3); + { + setState(2786); + match(ADD); + setState(2787); + unaryExpression(); + } + break; + case SUB: + enterOuterAlt(_localctx, 4); + { + setState(2788); + match(SUB); + setState(2789); + unaryExpression(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case Identifier: + case AT: + enterOuterAlt(_localctx, 5); + { + setState(2790); + unaryExpressionNotPlusMinus(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PreIncrementExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preIncrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPreIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException { + PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 456, RULE_preIncrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2793); + match(INC); + setState(2794); + unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PreDecrementExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preDecrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPreDecrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException { + PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 458, RULE_preDecrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2796); + match(DEC); + setState(2797); + unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public CastExpressionContext castExpression() { + return getRuleContext(CastExpressionContext.class,0); + } + public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnaryExpressionNotPlusMinus(this); + else return visitor.visitChildren(this); + } + } + + public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException { + UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState()); + enterRule(_localctx, 460, RULE_unaryExpressionNotPlusMinus); + try { + setState(2805); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,317,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2799); + postfixExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2800); + match(TILDE); + setState(2801); + unaryExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2802); + match(BANG); + setState(2803); + unaryExpression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2804); + castExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostfixExpressionContext extends ParserRuleContext { + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() { + return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class); + } + public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) { + return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class,i); + } + public List<PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() { + return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class); + } + public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) { + return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class,i); + } + public PostfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostfixExpressionContext postfixExpression() throws RecognitionException { + PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 462, RULE_postfixExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2809); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,318,_ctx) ) { + case 1: + { + setState(2807); + primary(); + } + break; + case 2: + { + setState(2808); + expressionName(); + } + break; + } + setState(2815); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,320,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(2813); + switch (_input.LA(1)) { + case INC: + { + setState(2811); + postIncrementExpression_lf_postfixExpression(); + } + break; + case DEC: + { + setState(2812); + postDecrementExpression_lf_postfixExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(2817); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,320,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostIncrementExpressionContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postIncrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException { + PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 464, RULE_postIncrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2818); + postfixExpression(); + setState(2819); + match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postIncrementExpression_lf_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostIncrementExpression_lf_postfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException { + PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 466, RULE_postIncrementExpression_lf_postfixExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2821); + match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostDecrementExpressionContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postDecrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostDecrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException { + PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 468, RULE_postDecrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2823); + postfixExpression(); + setState(2824); + match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postDecrementExpression_lf_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostDecrementExpression_lf_postfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException { + PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 470, RULE_postDecrementExpression_lf_postfixExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2826); + match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CastExpressionContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0); + } + public List<AdditionalBoundContext> additionalBound() { + return getRuleContexts(AdditionalBoundContext.class); + } + public AdditionalBoundContext additionalBound(int i) { + return getRuleContext(AdditionalBoundContext.class,i); + } + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public CastExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_castExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCastExpression(this); + else return visitor.visitChildren(this); + } + } + + public final CastExpressionContext castExpression() throws RecognitionException { + CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState()); + enterRule(_localctx, 472, RULE_castExpression); + int _la; + try { + setState(2855); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,323,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2828); + match(LPAREN); + setState(2829); + primitiveType(); + setState(2830); + match(RPAREN); + setState(2831); + unaryExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2833); + match(LPAREN); + setState(2834); + referenceType(); + setState(2838); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(2835); + additionalBound(); + } + } + setState(2840); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2841); + match(RPAREN); + setState(2842); + unaryExpressionNotPlusMinus(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2844); + match(LPAREN); + setState(2845); + referenceType(); + setState(2849); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(2846); + additionalBound(); + } + } + setState(2851); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2852); + match(RPAREN); + setState(2853); + lambdaExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 26: + return packageName_sempred((PackageNameContext)_localctx, predIndex); + case 28: + return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex); + case 31: + return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex); + case 217: + return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex); + case 218: + return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex); + case 219: + return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex); + case 220: + return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex); + case 221: + return andExpression_sempred((AndExpressionContext)_localctx, predIndex); + case 222: + return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex); + case 223: + return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex); + case 224: + return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex); + case 225: + return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex); + case 226: + return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 1); + } + return true; + } + private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 1); + } + return true; + } + private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return precpred(_ctx, 1); + } + return true; + } + private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return precpred(_ctx, 1); + } + return true; + } + private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 4: + return precpred(_ctx, 1); + } + return true; + } + private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return precpred(_ctx, 1); + } + return true; + } + private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return precpred(_ctx, 1); + } + return true; + } + private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return precpred(_ctx, 1); + } + return true; + } + private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 8: + return precpred(_ctx, 2); + case 9: + return precpred(_ctx, 1); + } + return true; + } + private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 10: + return precpred(_ctx, 5); + case 11: + return precpred(_ctx, 4); + case 12: + return precpred(_ctx, 3); + case 13: + return precpred(_ctx, 2); + case 14: + return precpred(_ctx, 1); + } + return true; + } + private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 15: + return precpred(_ctx, 3); + case 16: + return precpred(_ctx, 2); + case 17: + return precpred(_ctx, 1); + } + return true; + } + private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 18: + return precpred(_ctx, 2); + case 19: + return precpred(_ctx, 1); + } + return true; + } + private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 20: + return precpred(_ctx, 3); + case 21: + return precpred(_ctx, 2); + case 22: + return precpred(_ctx, 1); + } + return true; + } + + private static final int _serializedATNSegments = 2; + private static final String _serializedATNSegment0 = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u0b2c\4\2\t\2\4"+ + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ + "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ + "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ + "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ + "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ + "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ + "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+ + "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+ + "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+ + "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+ + "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+ + "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+ + "\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+ + "\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+ + "\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+ + "\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+ + "\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+ + "\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+ + "\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+ + "\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+ + "\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+ + "\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+ + "\4\u00ed\t\u00ed\4\u00ee\t\u00ee\3\2\3\2\3\3\3\3\5\3\u01e1\n\3\3\4\7\4"+ + "\u01e4\n\4\f\4\16\4\u01e7\13\4\3\4\3\4\7\4\u01eb\n\4\f\4\16\4\u01ee\13"+ + "\4\3\4\5\4\u01f1\n\4\3\5\3\5\5\5\u01f5\n\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b"+ + "\5\b\u01fe\n\b\3\t\3\t\5\t\u0202\n\t\3\t\3\t\7\t\u0206\n\t\f\t\16\t\u0209"+ + "\13\t\3\n\7\n\u020c\n\n\f\n\16\n\u020f\13\n\3\n\3\n\5\n\u0213\n\n\3\n"+ + "\3\n\3\n\7\n\u0218\n\n\f\n\16\n\u021b\13\n\3\n\3\n\5\n\u021f\n\n\5\n\u0221"+ + "\n\n\3\13\3\13\7\13\u0225\n\13\f\13\16\13\u0228\13\13\3\13\3\13\5\13\u022c"+ + "\n\13\3\f\7\f\u022f\n\f\f\f\16\f\u0232\13\f\3\f\3\f\5\f\u0236\n\f\3\r"+ + "\3\r\3\16\3\16\3\17\3\17\3\20\7\20\u023f\n\20\f\20\16\20\u0242\13\20\3"+ + "\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u024f\n\21"+ + "\3\22\7\22\u0252\n\22\f\22\16\22\u0255\13\22\3\22\3\22\3\22\7\22\u025a"+ + "\n\22\f\22\16\22\u025d\13\22\3\22\3\22\7\22\u0261\n\22\f\22\16\22\u0264"+ + "\13\22\3\23\7\23\u0267\n\23\f\23\16\23\u026a\13\23\3\23\3\23\5\23\u026e"+ + "\n\23\3\24\3\24\3\25\3\25\3\25\3\25\3\25\7\25\u0277\n\25\f\25\16\25\u027a"+ + "\13\25\5\25\u027c\n\25\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\30\3\30\3"+ + "\30\7\30\u0288\n\30\f\30\16\30\u028b\13\30\3\31\3\31\5\31\u028f\n\31\3"+ + "\32\7\32\u0292\n\32\f\32\16\32\u0295\13\32\3\32\3\32\5\32\u0299\n\32\3"+ + "\33\3\33\3\33\3\33\5\33\u029f\n\33\3\34\3\34\3\34\3\34\3\34\3\34\7\34"+ + "\u02a7\n\34\f\34\16\34\u02aa\13\34\3\35\3\35\3\35\3\35\3\35\5\35\u02b1"+ + "\n\35\3\36\3\36\3\36\3\36\3\36\3\36\7\36\u02b9\n\36\f\36\16\36\u02bc\13"+ + "\36\3\37\3\37\3\37\3\37\3\37\5\37\u02c3\n\37\3 \3 \3!\3!\3!\3!\3!\3!\7"+ + "!\u02cd\n!\f!\16!\u02d0\13!\3\"\5\"\u02d3\n\"\3\"\7\"\u02d6\n\"\f\"\16"+ + "\"\u02d9\13\"\3\"\7\"\u02dc\n\"\f\"\16\"\u02df\13\"\3\"\3\"\3#\7#\u02e4"+ + "\n#\f#\16#\u02e7\13#\3#\3#\3#\3#\7#\u02ed\n#\f#\16#\u02f0\13#\3#\3#\3"+ + "$\3$\3%\3%\3%\3%\5%\u02fa\n%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3"+ + "(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\5*\u0317\n*\3+\3+\5+\u031b"+ + "\n+\3,\7,\u031e\n,\f,\16,\u0321\13,\3,\3,\3,\5,\u0326\n,\3,\5,\u0329\n"+ + ",\3,\5,\u032c\n,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0338\n-\3.\3.\3.\3"+ + ".\3/\3/\3/\7/\u0341\n/\f/\16/\u0344\13/\3\60\3\60\3\60\3\61\3\61\3\61"+ + "\3\62\3\62\3\62\7\62\u034f\n\62\f\62\16\62\u0352\13\62\3\63\3\63\7\63"+ + "\u0356\n\63\f\63\16\63\u0359\13\63\3\63\3\63\3\64\3\64\3\64\3\64\5\64"+ + "\u0361\n\64\3\65\3\65\3\65\3\65\3\65\5\65\u0368\n\65\3\66\7\66\u036b\n"+ + "\66\f\66\16\66\u036e\13\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67"+ + "\3\67\3\67\3\67\5\67\u037c\n\67\38\38\38\78\u0381\n8\f8\168\u0384\138"+ + "\39\39\39\59\u0389\n9\3:\3:\5:\u038d\n:\3;\3;\5;\u0391\n;\3<\3<\5<\u0395"+ + "\n<\3=\3=\5=\u0399\n=\3>\3>\3>\5>\u039e\n>\3?\3?\5?\u03a2\n?\3?\3?\7?"+ + "\u03a6\n?\f?\16?\u03a9\13?\3@\3@\5@\u03ad\n@\3@\3@\3@\7@\u03b2\n@\f@\16"+ + "@\u03b5\13@\3@\3@\5@\u03b9\n@\5@\u03bb\n@\3A\3A\7A\u03bf\nA\fA\16A\u03c2"+ + "\13A\3A\3A\5A\u03c6\nA\3B\3B\5B\u03ca\nB\3C\3C\3D\3D\3E\3E\3F\3F\3G\3"+ + "G\3G\3G\3G\3G\3G\3G\3G\5G\u03dd\nG\3H\7H\u03e0\nH\fH\16H\u03e3\13H\3H"+ + "\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03f2\nI\3J\3J\3J\5J\u03f7\nJ"+ + "\3J\3J\7J\u03fb\nJ\fJ\16J\u03fe\13J\3J\3J\3J\5J\u0403\nJ\5J\u0405\nJ\3"+ + "K\3K\5K\u0409\nK\3L\3L\3L\5L\u040e\nL\3L\3L\5L\u0412\nL\3M\3M\3M\3M\3"+ + "M\5M\u0419\nM\3N\3N\3N\7N\u041e\nN\fN\16N\u0421\13N\3N\3N\3N\7N\u0426"+ + "\nN\fN\16N\u0429\13N\5N\u042b\nN\3O\7O\u042e\nO\fO\16O\u0431\13O\3O\3"+ + "O\3O\3P\3P\5P\u0438\nP\3Q\7Q\u043b\nQ\fQ\16Q\u043e\13Q\3Q\3Q\7Q\u0442"+ + "\nQ\fQ\16Q\u0445\13Q\3Q\3Q\3Q\3Q\5Q\u044b\nQ\3R\7R\u044e\nR\fR\16R\u0451"+ + "\13R\3R\3R\3R\5R\u0456\nR\3R\3R\3S\3S\3S\3T\3T\3T\7T\u0460\nT\fT\16T\u0463"+ + "\13T\3U\3U\5U\u0467\nU\3V\3V\5V\u046b\nV\3W\3W\3X\3X\3X\3Y\7Y\u0473\n"+ + "Y\fY\16Y\u0476\13Y\3Y\3Y\5Y\u047a\nY\3Y\3Y\3Z\3Z\3Z\3Z\5Z\u0482\nZ\3["+ + "\5[\u0485\n[\3[\3[\3[\5[\u048a\n[\3[\3[\3\\\3\\\3]\3]\5]\u0492\n]\3]\5"+ + "]\u0495\n]\3]\3]\3^\5^\u049a\n^\3^\3^\3^\5^\u049f\n^\3^\3^\3^\5^\u04a4"+ + "\n^\3^\3^\3^\5^\u04a9\n^\3^\3^\3^\3^\3^\5^\u04b0\n^\3^\3^\3^\5^\u04b5"+ + "\n^\3^\3^\3^\3^\3^\3^\5^\u04bd\n^\3^\3^\3^\5^\u04c2\n^\3^\3^\3^\5^\u04c7"+ + "\n^\3_\7_\u04ca\n_\f_\16_\u04cd\13_\3_\3_\3_\5_\u04d2\n_\3_\3_\3`\3`\5"+ + "`\u04d8\n`\3`\5`\u04db\n`\3`\5`\u04de\n`\3`\3`\3a\3a\3a\7a\u04e5\na\f"+ + "a\16a\u04e8\13a\3b\7b\u04eb\nb\fb\16b\u04ee\13b\3b\3b\3b\5b\u04f3\nb\3"+ + "b\5b\u04f6\nb\3b\5b\u04f9\nb\3c\3c\3d\3d\7d\u04ff\nd\fd\16d\u0502\13d"+ + "\3e\3e\5e\u0506\ne\3f\7f\u0509\nf\ff\16f\u050c\13f\3f\3f\3f\5f\u0511\n"+ + "f\3f\5f\u0514\nf\3f\3f\3g\3g\3g\3g\3g\3g\3g\5g\u051f\ng\3h\3h\3h\3i\3"+ + "i\7i\u0526\ni\fi\16i\u0529\13i\3i\3i\3j\3j\3j\3j\3j\5j\u0532\nj\3k\7k"+ + "\u0535\nk\fk\16k\u0538\13k\3k\3k\3k\3k\3l\3l\3l\3l\5l\u0542\nl\3m\7m\u0545"+ + "\nm\fm\16m\u0548\13m\3m\3m\3m\3n\3n\3n\3n\3n\3n\5n\u0553\nn\3o\7o\u0556"+ + "\no\fo\16o\u0559\13o\3o\3o\3o\3o\3o\3p\3p\7p\u0562\np\fp\16p\u0565\13"+ + "p\3p\3p\3q\3q\3q\3q\3q\5q\u056e\nq\3r\7r\u0571\nr\fr\16r\u0574\13r\3r"+ + "\3r\3r\3r\3r\5r\u057b\nr\3r\5r\u057e\nr\3r\3r\3s\3s\3s\5s\u0585\ns\3t"+ + "\3t\3t\3u\3u\3u\5u\u058d\nu\3v\3v\3v\3v\5v\u0593\nv\3v\3v\3w\3w\3w\7w"+ + "\u059a\nw\fw\16w\u059d\13w\3x\3x\3x\3x\3y\3y\3y\5y\u05a6\ny\3z\3z\5z\u05aa"+ + "\nz\3z\5z\u05ad\nz\3z\3z\3{\3{\3{\7{\u05b4\n{\f{\16{\u05b7\13{\3|\3|\3"+ + "|\3}\3}\3}\3}\3}\3}\3~\3~\5~\u05c4\n~\3~\5~\u05c7\n~\3~\3~\3\177\3\177"+ + "\3\177\7\177\u05ce\n\177\f\177\16\177\u05d1\13\177\3\u0080\3\u0080\5\u0080"+ + "\u05d5\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\7\u0081\u05db\n\u0081\f"+ + "\u0081\16\u0081\u05de\13\u0081\3\u0082\3\u0082\3\u0082\5\u0082\u05e3\n"+ + "\u0082\3\u0083\3\u0083\3\u0083\3\u0084\7\u0084\u05e9\n\u0084\f\u0084\16"+ + "\u0084\u05ec\13\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\3\u0085\5\u0085\u05f7\n\u0085\3\u0086\3\u0086\3\u0086"+ + "\3\u0086\3\u0086\5\u0086\u05fe\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087"+ + "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\5\u0087"+ + "\u060c\n\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u008a"+ + "\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c"+ + "\3\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u0622\n\u008c\3\u008d\3\u008d"+ + "\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+ + "\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f"+ + "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090"+ + "\3\u0090\3\u0090\3\u0090\5\u0090\u0644\n\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\7\u0092\u064e\n\u0092\f\u0092"+ + "\16\u0092\u0651\13\u0092\3\u0092\7\u0092\u0654\n\u0092\f\u0092\16\u0092"+ + "\u0657\13\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094"+ + "\7\u0094\u0660\n\u0094\f\u0094\16\u0094\u0663\13\u0094\3\u0095\3\u0095"+ + "\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\5\u0095"+ + "\u066f\n\u0095\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+ + "\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099"+ + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\5\u009a"+ + "\u0689\n\u009a\3\u009b\3\u009b\5\u009b\u068d\n\u009b\3\u009c\3\u009c\3"+ + "\u009c\5\u009c\u0692\n\u009c\3\u009c\3\u009c\5\u009c\u0696\n\u009c\3\u009c"+ + "\3\u009c\5\u009c\u069a\n\u009c\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d"+ + "\3\u009d\5\u009d\u06a2\n\u009d\3\u009d\3\u009d\5\u009d\u06a6\n\u009d\3"+ + "\u009d\3\u009d\5\u009d\u06aa\n\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3"+ + "\u009e\5\u009e\u06b1\n\u009e\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\7"+ + "\u00a0\u06b8\n\u00a0\f\u00a0\16\u00a0\u06bb\13\u00a0\3\u00a1\3\u00a1\3"+ + "\u00a1\7\u00a1\u06c0\n\u00a1\f\u00a1\16\u00a1\u06c3\13\u00a1\3\u00a1\3"+ + "\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2"+ + "\7\u00a2\u06cf\n\u00a2\f\u00a2\16\u00a2\u06d2\13\u00a2\3\u00a2\3\u00a2"+ + "\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u06dd"+ + "\n\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\5\u00a4\u06e3\n\u00a4\3\u00a4"+ + "\3\u00a4\3\u00a5\3\u00a5\5\u00a5\u06e9\n\u00a5\3\u00a5\3\u00a5\3\u00a6"+ + "\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7"+ + "\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u06fe"+ + "\n\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0703\n\u00a8\3\u00a9\3\u00a9"+ + "\7\u00a9\u0707\n\u00a9\f\u00a9\16\u00a9\u070a\13\u00a9\3\u00aa\3\u00aa"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\7\u00ab\u0713\n\u00ab\f\u00ab"+ + "\16\u00ab\u0716\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac"+ + "\7\u00ac\u071e\n\u00ac\f\u00ac\16\u00ac\u0721\13\u00ac\3\u00ad\3\u00ad"+ + "\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u072a\n\u00ae\3\u00ae"+ + "\5\u00ae\u072d\n\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u0732\n\u00af\3"+ + "\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\7\u00b0\u0739\n\u00b0\f\u00b0\16"+ + "\u00b0\u073c\13\u00b0\3\u00b1\7\u00b1\u073f\n\u00b1\f\u00b1\16\u00b1\u0742"+ + "\13\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\5\u00b2"+ + "\u074b\n\u00b2\3\u00b2\7\u00b2\u074e\n\u00b2\f\u00b2\16\u00b2\u0751\13"+ + "\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\7\u00b3\u0757\n\u00b3\f\u00b3\16"+ + "\u00b3\u075a\13\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3"+ + "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3"+ + "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u0770\n\u00b3\3\u00b4"+ + "\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u0778\n\u00b5\f\u00b5"+ + "\16\u00b5\u077b\13\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5"+ + "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5"+ + "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\5\u00b5\u0790\n\u00b5\3\u00b6\3\u00b6"+ + "\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0797\n\u00b6\3\u00b7\3\u00b7\3\u00b8"+ + "\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u079f\n\u00b8\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\7\u00b9\u07a5\n\u00b9\f\u00b9\16\u00b9\u07a8\13\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\7\u00b9\u07b0\n\u00b9\f\u00b9"+ + "\16\u00b9\u07b3\13\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07c9\n\u00b9\3\u00ba"+ + "\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\7\u00bb\u07d1\n\u00bb\f\u00bb"+ + "\16\u00bb\u07d4\13\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+ + "\7\u00bb\u07dc\n\u00bb\f\u00bb\16\u00bb\u07df\13\u00bb\3\u00bb\3\u00bb"+ + "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+ + "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb"+ + "\u07f4\n\u00bb\3\u00bc\3\u00bc\5\u00bc\u07f8\n\u00bc\3\u00bc\7\u00bc\u07fb"+ + "\n\u00bc\f\u00bc\16\u00bc\u07fe\13\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc"+ + "\u0803\n\u00bc\f\u00bc\16\u00bc\u0806\13\u00bc\3\u00bc\7\u00bc\u0809\n"+ + "\u00bc\f\u00bc\16\u00bc\u080c\13\u00bc\3\u00bc\5\u00bc\u080f\n\u00bc\3"+ + "\u00bc\3\u00bc\5\u00bc\u0813\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0817\n\u00bc"+ + "\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u081d\n\u00bc\3\u00bc\7\u00bc"+ + "\u0820\n\u00bc\f\u00bc\16\u00bc\u0823\13\u00bc\3\u00bc\3\u00bc\5\u00bc"+ + "\u0827\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u082b\n\u00bc\3\u00bc\3\u00bc\5"+ + "\u00bc\u082f\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0835\n\u00bc"+ + "\3\u00bc\7\u00bc\u0838\n\u00bc\f\u00bc\16\u00bc\u083b\13\u00bc\3\u00bc"+ + "\3\u00bc\5\u00bc\u083f\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0843\n\u00bc\3"+ + "\u00bc\3\u00bc\5\u00bc\u0847\n\u00bc\5\u00bc\u0849\n\u00bc\3\u00bd\3\u00bd"+ + "\3\u00bd\5\u00bd\u084e\n\u00bd\3\u00bd\7\u00bd\u0851\n\u00bd\f\u00bd\16"+ + "\u00bd\u0854\13\u00bd\3\u00bd\3\u00bd\5\u00bd\u0858\n\u00bd\3\u00bd\3"+ + "\u00bd\5\u00bd\u085c\n\u00bd\3\u00bd\3\u00bd\5\u00bd\u0860\n\u00bd\3\u00be"+ + "\3\u00be\5\u00be\u0864\n\u00be\3\u00be\7\u00be\u0867\n\u00be\f\u00be\16"+ + "\u00be\u086a\13\u00be\3\u00be\3\u00be\3\u00be\7\u00be\u086f\n\u00be\f"+ + "\u00be\16\u00be\u0872\13\u00be\3\u00be\7\u00be\u0875\n\u00be\f\u00be\16"+ + "\u00be\u0878\13\u00be\3\u00be\5\u00be\u087b\n\u00be\3\u00be\3\u00be\5"+ + "\u00be\u087f\n\u00be\3\u00be\3\u00be\5\u00be\u0883\n\u00be\3\u00be\3\u00be"+ + "\3\u00be\3\u00be\5\u00be\u0889\n\u00be\3\u00be\7\u00be\u088c\n\u00be\f"+ + "\u00be\16\u00be\u088f\13\u00be\3\u00be\3\u00be\5\u00be\u0893\n\u00be\3"+ + "\u00be\3\u00be\5\u00be\u0897\n\u00be\3\u00be\3\u00be\5\u00be\u089b\n\u00be"+ + "\5\u00be\u089d\n\u00be\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u08a2\n\u00bf\3"+ + "\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+ + "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u08b1\n\u00c0\3\u00c1\3\u00c1"+ + "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2"+ + "\3\u00c2\5\u00c2\u08bf\n\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3"+ + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3\u08cb\n\u00c3\3\u00c3"+ + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\7\u00c3\u08d2\n\u00c3\f\u00c3\16\u00c3"+ + "\u08d5\13\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+ + "\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u08e1\n\u00c4\f\u00c4\16\u00c4\u08e4"+ + "\13\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\3\u00c5\5\u00c5\u08f0\n\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\7\u00c5\u08f7\n\u00c5\f\u00c5\16\u00c5\u08fa\13\u00c5\3\u00c6"+ + "\3\u00c6\3\u00c6\5\u00c6\u08ff\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\3\u00c6\5\u00c6\u0906\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u090b\n"+ + "\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0912\n\u00c6\3"+ + "\u00c6\3\u00c6\3\u00c6\5\u00c6\u0917\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3"+ + "\u00c6\3\u00c6\5\u00c6\u091e\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0923"+ + "\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092a\n\u00c6"+ + "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092f\n\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0937\n\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\5\u00c6\u093c\n\u00c6\3\u00c6\3\u00c6\5\u00c6\u0940\n\u00c6\3\u00c7\3"+ + "\u00c7\5\u00c7\u0944\n\u00c7\3\u00c7\3\u00c7\3\u00c7\5\u00c7\u0949\n\u00c7"+ + "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0950\n\u00c8\3\u00c8"+ + "\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0957\n\u00c8\3\u00c8\3\u00c8"+ + "\3\u00c8\5\u00c8\u095c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8"+ + "\5\u00c8\u0963\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0968\n\u00c8\3"+ + "\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u096f\n\u00c8\3\u00c8\3"+ + "\u00c8\3\u00c8\5\u00c8\u0974\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3"+ + "\u00c8\3\u00c8\5\u00c8\u097c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0981"+ + "\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0985\n\u00c8\3\u00c9\3\u00c9\3\u00c9"+ + "\7\u00c9\u098a\n\u00c9\f\u00c9\16\u00c9\u098d\13\u00c9\3\u00ca\3\u00ca"+ + "\3\u00ca\5\u00ca\u0992\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+ + "\5\u00ca\u0999\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca"+ + "\u09a0\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09a7\n"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09af\n"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09b6\n\u00ca\3"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09be\n\u00ca\3"+ + "\u00cb\3\u00cb\5\u00cb\u09c2\n\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3"+ + "\u00cc\5\u00cc\u09c9\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5"+ + "\u00cc\u09d0\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09d7"+ + "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09df"+ + "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09e6\n\u00cc"+ + "\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09ee\n\u00cc"+ + "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u09f4\n\u00cd\3\u00cd\3\u00cd"+ + "\3\u00cd\3\u00cd\5\u00cd\u09fa\n\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd"+ + "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u0a06\n\u00cd"+ + "\3\u00ce\3\u00ce\7\u00ce\u0a0a\n\u00ce\f\u00ce\16\u00ce\u0a0d\13\u00ce"+ + "\3\u00cf\7\u00cf\u0a10\n\u00cf\f\u00cf\16\u00cf\u0a13\13\u00cf\3\u00cf"+ + "\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d1\3\u00d1\5\u00d1\u0a1d"+ + "\n\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\5\u00d3"+ + "\u0a26\n\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\5\u00d3\u0a2d\n"+ + "\u00d3\3\u00d4\3\u00d4\3\u00d4\7\u00d4\u0a32\n\u00d4\f\u00d4\16\u00d4"+ + "\u0a35\13\u00d4\3\u00d5\3\u00d5\5\u00d5\u0a39\n\u00d5\3\u00d6\3\u00d6"+ + "\5\u00d6\u0a3d\n\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8"+ + "\3\u00d8\5\u00d8\u0a46\n\u00d8\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da"+ + "\3\u00da\3\u00da\3\u00da\3\u00da\5\u00da\u0a51\n\u00da\3\u00db\3\u00db"+ + "\3\u00db\3\u00db\3\u00db\3\u00db\7\u00db\u0a59\n\u00db\f\u00db\16\u00db"+ + "\u0a5c\13\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\7\u00dc"+ + "\u0a64\n\u00dc\f\u00dc\16\u00dc\u0a67\13\u00dc\3\u00dd\3\u00dd\3\u00dd"+ + "\3\u00dd\3\u00dd\3\u00dd\7\u00dd\u0a6f\n\u00dd\f\u00dd\16\u00dd\u0a72"+ + "\13\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\7\u00de\u0a7a"+ + "\n\u00de\f\u00de\16\u00de\u0a7d\13\u00de\3\u00df\3\u00df\3\u00df\3\u00df"+ + "\3\u00df\3\u00df\7\u00df\u0a85\n\u00df\f\u00df\16\u00df\u0a88\13\u00df"+ + "\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0"+ + "\7\u00e0\u0a93\n\u00e0\f\u00e0\16\u00e0\u0a96\13\u00e0\3\u00e1\3\u00e1"+ + "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1"+ + "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\7\u00e1\u0aaa"+ + "\n\u00e1\f\u00e1\16\u00e1\u0aad\13\u00e1\3\u00e2\3\u00e2\3\u00e2\3\u00e2"+ + "\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2"+ + "\3\u00e2\3\u00e2\3\u00e2\7\u00e2\u0abf\n\u00e2\f\u00e2\16\u00e2\u0ac2"+ + "\13\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3"+ + "\3\u00e3\7\u00e3\u0acd\n\u00e3\f\u00e3\16\u00e3\u0ad0\13\u00e3\3\u00e4"+ + "\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4"+ + "\3\u00e4\3\u00e4\7\u00e4\u0ade\n\u00e4\f\u00e4\16\u00e4\u0ae1\13\u00e4"+ + "\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u0aea"+ + "\n\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8"+ + "\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u0af8\n\u00e8\3\u00e9\3\u00e9"+ + "\5\u00e9\u0afc\n\u00e9\3\u00e9\3\u00e9\7\u00e9\u0b00\n\u00e9\f\u00e9\16"+ + "\u00e9\u0b03\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00ec"+ + "\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee"+ + "\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b17\n\u00ee\f\u00ee\16\u00ee\u0b1a"+ + "\13\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b22"+ + "\n\u00ee\f\u00ee\16\u00ee\u0b25\13\u00ee\3\u00ee\3\u00ee\3\u00ee\5\u00ee"+ + "\u0b2a\n\u00ee\3\u00ee\2\17\66:@\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0"+ + "\u01c2\u01c4\u01c6\u00ef\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ + "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ + "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+ + "\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+ + "\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+ + "\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+ + "\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+ + "\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114"+ + "\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c"+ + "\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144"+ + "\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c"+ + "\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174"+ + "\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c"+ + "\u018e\u0190\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4"+ + "\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc"+ + "\u01be\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4"+ + "\u01d6\u01d8\u01da\2\6\3\2\65:\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26"+ + "\26\4\2DD]g\u0c1d\2\u01dc\3\2\2\2\4\u01e0\3\2\2\2\6\u01f0\3\2\2\2\b\u01f4"+ + "\3\2\2\2\n\u01f6\3\2\2\2\f\u01f8\3\2\2\2\16\u01fd\3\2\2\2\20\u0201\3\2"+ + "\2\2\22\u0220\3\2\2\2\24\u0222\3\2\2\2\26\u0230\3\2\2\2\30\u0237\3\2\2"+ + "\2\32\u0239\3\2\2\2\34\u023b\3\2\2\2\36\u0240\3\2\2\2 \u024e\3\2\2\2\""+ + "\u0253\3\2\2\2$\u0268\3\2\2\2&\u026f\3\2\2\2(\u027b\3\2\2\2*\u027d\3\2"+ + "\2\2,\u0280\3\2\2\2.\u0284\3\2\2\2\60\u028e\3\2\2\2\62\u0293\3\2\2\2\64"+ + "\u029e\3\2\2\2\66\u02a0\3\2\2\28\u02b0\3\2\2\2:\u02b2\3\2\2\2<\u02c2\3"+ + "\2\2\2>\u02c4\3\2\2\2@\u02c6\3\2\2\2B\u02d2\3\2\2\2D\u02e5\3\2\2\2F\u02f3"+ + "\3\2\2\2H\u02f9\3\2\2\2J\u02fb\3\2\2\2L\u02ff\3\2\2\2N\u0305\3\2\2\2P"+ + "\u030c\3\2\2\2R\u0316\3\2\2\2T\u031a\3\2\2\2V\u031f\3\2\2\2X\u0337\3\2"+ + "\2\2Z\u0339\3\2\2\2\\\u033d\3\2\2\2^\u0345\3\2\2\2`\u0348\3\2\2\2b\u034b"+ + "\3\2\2\2d\u0353\3\2\2\2f\u0360\3\2\2\2h\u0367\3\2\2\2j\u036c\3\2\2\2l"+ + "\u037b\3\2\2\2n\u037d\3\2\2\2p\u0385\3\2\2\2r\u038a\3\2\2\2t\u0390\3\2"+ + "\2\2v\u0394\3\2\2\2x\u0398\3\2\2\2z\u039d\3\2\2\2|\u03a1\3\2\2\2~\u03ba"+ + "\3\2\2\2\u0080\u03bc\3\2\2\2\u0082\u03c7\3\2\2\2\u0084\u03cb\3\2\2\2\u0086"+ + "\u03cd\3\2\2\2\u0088\u03cf\3\2\2\2\u008a\u03d1\3\2\2\2\u008c\u03dc\3\2"+ + "\2\2\u008e\u03e1\3\2\2\2\u0090\u03f1\3\2\2\2\u0092\u0404\3\2\2\2\u0094"+ + "\u0408\3\2\2\2\u0096\u040a\3\2\2\2\u0098\u0418\3\2\2\2\u009a\u042a\3\2"+ + "\2\2\u009c\u042f\3\2\2\2\u009e\u0437\3\2\2\2\u00a0\u044a\3\2\2\2\u00a2"+ + "\u044f\3\2\2\2\u00a4\u0459\3\2\2\2\u00a6\u045c\3\2\2\2\u00a8\u0466\3\2"+ + "\2\2\u00aa\u046a\3\2\2\2\u00ac\u046c\3\2\2\2\u00ae\u046e\3\2\2\2\u00b0"+ + "\u0474\3\2\2\2\u00b2\u0481\3\2\2\2\u00b4\u0484\3\2\2\2\u00b6\u048d\3\2"+ + "\2\2\u00b8\u048f\3\2\2\2\u00ba\u04c6\3\2\2\2\u00bc\u04cb\3\2\2\2\u00be"+ + "\u04d5\3\2\2\2\u00c0\u04e1\3\2\2\2\u00c2\u04ec\3\2\2\2\u00c4\u04fa\3\2"+ + "\2\2\u00c6\u04fc\3\2\2\2\u00c8\u0505\3\2\2\2\u00ca\u050a\3\2\2\2\u00cc"+ + "\u051e\3\2\2\2\u00ce\u0520\3\2\2\2\u00d0\u0523\3\2\2\2\u00d2\u0531\3\2"+ + "\2\2\u00d4\u0536\3\2\2\2\u00d6\u0541\3\2\2\2\u00d8\u0546\3\2\2\2\u00da"+ + "\u0552\3\2\2\2\u00dc\u0557\3\2\2\2\u00de\u055f\3\2\2\2\u00e0\u056d\3\2"+ + "\2\2\u00e2\u0572\3\2\2\2\u00e4\u0584\3\2\2\2\u00e6\u0586\3\2\2\2\u00e8"+ + "\u058c\3\2\2\2\u00ea\u058e\3\2\2\2\u00ec\u0596\3\2\2\2\u00ee\u059e\3\2"+ + "\2\2\u00f0\u05a5\3\2\2\2\u00f2\u05a7\3\2\2\2\u00f4\u05b0\3\2\2\2\u00f6"+ + "\u05b8\3\2\2\2\u00f8\u05bb\3\2\2\2\u00fa\u05c1\3\2\2\2\u00fc\u05ca\3\2"+ + "\2\2\u00fe\u05d2\3\2\2\2\u0100\u05d8\3\2\2\2\u0102\u05e2\3\2\2\2\u0104"+ + "\u05e4\3\2\2\2\u0106\u05ea\3\2\2\2\u0108\u05f6\3\2\2\2\u010a\u05fd\3\2"+ + "\2\2\u010c\u060b\3\2\2\2\u010e\u060d\3\2\2\2\u0110\u060f\3\2\2\2\u0112"+ + "\u0613\3\2\2\2\u0114\u0617\3\2\2\2\u0116\u0621\3\2\2\2\u0118\u0623\3\2"+ + "\2\2\u011a\u0629\3\2\2\2\u011c\u0631\3\2\2\2\u011e\u0643\3\2\2\2\u0120"+ + "\u0645\3\2\2\2\u0122\u064b\3\2\2\2\u0124\u065a\3\2\2\2\u0126\u065d\3\2"+ + "\2\2\u0128\u066e\3\2\2\2\u012a\u0670\3\2\2\2\u012c\u0672\3\2\2\2\u012e"+ + "\u0678\3\2\2\2\u0130\u067e\3\2\2\2\u0132\u0688\3\2\2\2\u0134\u068c\3\2"+ + "\2\2\u0136\u068e\3\2\2\2\u0138\u069e\3\2\2\2\u013a\u06b0\3\2\2\2\u013c"+ + "\u06b2\3\2\2\2\u013e\u06b4\3\2\2\2\u0140\u06bc\3\2\2\2\u0142\u06cb\3\2"+ + "\2\2\u0144\u06da\3\2\2\2\u0146\u06e0\3\2\2\2\u0148\u06e6\3\2\2\2\u014a"+ + "\u06ec\3\2\2\2\u014c\u06f0\3\2\2\2\u014e\u0702\3\2\2\2\u0150\u0704\3\2"+ + "\2\2\u0152\u070b\3\2\2\2\u0154\u0714\3\2\2\2\u0156\u071a\3\2\2\2\u0158"+ + "\u0722\3\2\2\2\u015a\u0725\3\2\2\2\u015c\u072e\3\2\2\2\u015e\u0735\3\2"+ + "\2\2\u0160\u0740\3\2\2\2\u0162\u074a\3\2\2\2\u0164\u076f\3\2\2\2\u0166"+ + "\u0771\3\2\2\2\u0168\u078f\3\2\2\2\u016a\u0796\3\2\2\2\u016c\u0798\3\2"+ + "\2\2\u016e\u079e\3\2\2\2\u0170\u07c8\3\2\2\2\u0172\u07ca\3\2\2\2\u0174"+ + "\u07f3\3\2\2\2\u0176\u0848\3\2\2\2\u0178\u084a\3\2\2\2\u017a\u089c\3\2"+ + "\2\2\u017c\u08a1\3\2\2\2\u017e\u08b0\3\2\2\2\u0180\u08b2\3\2\2\2\u0182"+ + "\u08be\3\2\2\2\u0184\u08ca\3\2\2\2\u0186\u08d6\3\2\2\2\u0188\u08ef\3\2"+ + "\2\2\u018a\u093f\3\2\2\2\u018c\u0941\3\2\2\2\u018e\u0984\3\2\2\2\u0190"+ + "\u0986\3\2\2\2\u0192\u09bd\3\2\2\2\u0194\u09bf\3\2\2\2\u0196\u09ed\3\2"+ + "\2\2\u0198\u0a05\3\2\2\2\u019a\u0a07\3\2\2\2\u019c\u0a11\3\2\2\2\u019e"+ + "\u0a18\3\2\2\2\u01a0\u0a1c\3\2\2\2\u01a2\u0a1e\3\2\2\2\u01a4\u0a2c\3\2"+ + "\2\2\u01a6\u0a2e\3\2\2\2\u01a8\u0a38\3\2\2\2\u01aa\u0a3c\3\2\2\2\u01ac"+ + "\u0a3e\3\2\2\2\u01ae\u0a45\3\2\2\2\u01b0\u0a47\3\2\2\2\u01b2\u0a50\3\2"+ + "\2\2\u01b4\u0a52\3\2\2\2\u01b6\u0a5d\3\2\2\2\u01b8\u0a68\3\2\2\2\u01ba"+ + "\u0a73\3\2\2\2\u01bc\u0a7e\3\2\2\2\u01be\u0a89\3\2\2\2\u01c0\u0a97\3\2"+ + "\2\2\u01c2\u0aae\3\2\2\2\u01c4\u0ac3\3\2\2\2\u01c6\u0ad1\3\2\2\2\u01c8"+ + "\u0ae9\3\2\2\2\u01ca\u0aeb\3\2\2\2\u01cc\u0aee\3\2\2\2\u01ce\u0af7\3\2"+ + "\2\2\u01d0\u0afb\3\2\2\2\u01d2\u0b04\3\2\2\2\u01d4\u0b07\3\2\2\2\u01d6"+ + "\u0b09\3\2\2\2\u01d8\u0b0c\3\2\2\2\u01da\u0b29\3\2\2\2\u01dc\u01dd\t\2"+ + "\2\2\u01dd\3\3\2\2\2\u01de\u01e1\5\6\4\2\u01df\u01e1\5\16\b\2\u01e0\u01de"+ + "\3\2\2\2\u01e0\u01df\3\2\2\2\u01e1\5\3\2\2\2\u01e2\u01e4\5\u00e8u\2\u01e3"+ + "\u01e2\3\2\2\2\u01e4\u01e7\3\2\2\2\u01e5\u01e3\3\2\2\2\u01e5\u01e6\3\2"+ + "\2\2\u01e6\u01e8\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e8\u01f1\5\b\5\2\u01e9"+ + "\u01eb\5\u00e8u\2\u01ea\u01e9\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea"+ + "\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ef\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ef"+ + "\u01f1\7\5\2\2\u01f0\u01e5\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f1\7\3\2\2\2"+ + "\u01f2\u01f5\5\n\6\2\u01f3\u01f5\5\f\7\2\u01f4\u01f2\3\2\2\2\u01f4\u01f3"+ + "\3\2\2\2\u01f5\t\3\2\2\2\u01f6\u01f7\t\3\2\2\u01f7\13\3\2\2\2\u01f8\u01f9"+ + "\t\4\2\2\u01f9\r\3\2\2\2\u01fa\u01fe\5\20\t\2\u01fb\u01fe\5\36\20\2\u01fc"+ + "\u01fe\5 \21\2\u01fd\u01fa\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fc\3\2"+ + "\2\2\u01fe\17\3\2\2\2\u01ff\u0202\5\26\f\2\u0200\u0202\5\34\17\2\u0201"+ + "\u01ff\3\2\2\2\u0201\u0200\3\2\2\2\u0202\u0207\3\2\2\2\u0203\u0206\5\24"+ + "\13\2\u0204\u0206\5\32\16\2\u0205\u0203\3\2\2\2\u0205\u0204\3\2\2\2\u0206"+ + "\u0209\3\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208\21\3\2\2"+ + "\2\u0209\u0207\3\2\2\2\u020a\u020c\5\u00e8u\2\u020b\u020a\3\2\2\2\u020c"+ + "\u020f\3\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2"+ + "\2\2\u020f\u020d\3\2\2\2\u0210\u0212\7h\2\2\u0211\u0213\5,\27\2\u0212"+ + "\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0221\3\2\2\2\u0214\u0215\5\20"+ + "\t\2\u0215\u0219\7C\2\2\u0216\u0218\5\u00e8u\2\u0217\u0216\3\2\2\2\u0218"+ + "\u021b\3\2\2\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021c\3\2"+ + "\2\2\u021b\u0219\3\2\2\2\u021c\u021e\7h\2\2\u021d\u021f\5,\27\2\u021e"+ + "\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0221\3\2\2\2\u0220\u020d\3\2"+ + "\2\2\u0220\u0214\3\2\2\2\u0221\23\3\2\2\2\u0222\u0226\7C\2\2\u0223\u0225"+ + "\5\u00e8u\2\u0224\u0223\3\2\2\2\u0225\u0228\3\2\2\2\u0226\u0224\3\2\2"+ + "\2\u0226\u0227\3\2\2\2\u0227\u0229\3\2\2\2\u0228\u0226\3\2\2\2\u0229\u022b"+ + "\7h\2\2\u022a\u022c\5,\27\2\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022c"+ + "\25\3\2\2\2\u022d\u022f\5\u00e8u\2\u022e\u022d\3\2\2\2\u022f\u0232\3\2"+ + "\2\2\u0230\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0233\3\2\2\2\u0232"+ + "\u0230\3\2\2\2\u0233\u0235\7h\2\2\u0234\u0236\5,\27\2\u0235\u0234\3\2"+ + "\2\2\u0235\u0236\3\2\2\2\u0236\27\3\2\2\2\u0237\u0238\5\22\n\2\u0238\31"+ + "\3\2\2\2\u0239\u023a\5\24\13\2\u023a\33\3\2\2\2\u023b\u023c\5\26\f\2\u023c"+ + "\35\3\2\2\2\u023d\u023f\5\u00e8u\2\u023e\u023d\3\2\2\2\u023f\u0242\3\2"+ + "\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2\u0241\u0243\3\2\2\2\u0242"+ + "\u0240\3\2\2\2\u0243\u0244\7h\2\2\u0244\37\3\2\2\2\u0245\u0246\5\6\4\2"+ + "\u0246\u0247\5\"\22\2\u0247\u024f\3\2\2\2\u0248\u0249\5\20\t\2\u0249\u024a"+ + "\5\"\22\2\u024a\u024f\3\2\2\2\u024b\u024c\5\36\20\2\u024c\u024d\5\"\22"+ + "\2\u024d\u024f\3\2\2\2\u024e\u0245\3\2\2\2\u024e\u0248\3\2\2\2\u024e\u024b"+ + "\3\2\2\2\u024f!\3\2\2\2\u0250\u0252\5\u00e8u\2\u0251\u0250\3\2\2\2\u0252"+ + "\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0256\3\2"+ + "\2\2\u0255\u0253\3\2\2\2\u0256\u0257\7?\2\2\u0257\u0262\7@\2\2\u0258\u025a"+ + "\5\u00e8u\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2"+ + "\2\u025b\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f"+ + "\7?\2\2\u025f\u0261\7@\2\2\u0260\u025b\3\2\2\2\u0261\u0264\3\2\2\2\u0262"+ + "\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263#\3\2\2\2\u0264\u0262\3\2\2\2"+ + "\u0265\u0267\5&\24\2\u0266\u0265\3\2\2\2\u0267\u026a\3\2\2\2\u0268\u0266"+ + "\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026b\3\2\2\2\u026a\u0268\3\2\2\2\u026b"+ + "\u026d\7h\2\2\u026c\u026e\5(\25\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2"+ + "\2\2\u026e%\3\2\2\2\u026f\u0270\5\u00e8u\2\u0270\'\3\2\2\2\u0271\u0272"+ + "\7\23\2\2\u0272\u027c\5\36\20\2\u0273\u0274\7\23\2\2\u0274\u0278\5\20"+ + "\t\2\u0275\u0277\5*\26\2\u0276\u0275\3\2\2\2\u0277\u027a\3\2\2\2\u0278"+ + "\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278\3\2"+ + "\2\2\u027b\u0271\3\2\2\2\u027b\u0273\3\2\2\2\u027c)\3\2\2\2\u027d\u027e"+ + "\7W\2\2\u027e\u027f\5\30\r\2\u027f+\3\2\2\2\u0280\u0281\7F\2\2\u0281\u0282"+ + "\5.\30\2\u0282\u0283\7E\2\2\u0283-\3\2\2\2\u0284\u0289\5\60\31\2\u0285"+ + "\u0286\7B\2\2\u0286\u0288\5\60\31\2\u0287\u0285\3\2\2\2\u0288\u028b\3"+ + "\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a/\3\2\2\2\u028b\u0289"+ + "\3\2\2\2\u028c\u028f\5\16\b\2\u028d\u028f\5\62\32\2\u028e\u028c\3\2\2"+ + "\2\u028e\u028d\3\2\2\2\u028f\61\3\2\2\2\u0290\u0292\5\u00e8u\2\u0291\u0290"+ + "\3\2\2\2\u0292\u0295\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294"+ + "\u0296\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u0298\7I\2\2\u0297\u0299\5\64"+ + "\33\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299\63\3\2\2\2\u029a\u029b"+ + "\7\23\2\2\u029b\u029f\5\16\b\2\u029c\u029d\7*\2\2\u029d\u029f\5\16\b\2"+ + "\u029e\u029a\3\2\2\2\u029e\u029c\3\2\2\2\u029f\65\3\2\2\2\u02a0\u02a1"+ + "\b\34\1\2\u02a1\u02a2\7h\2\2\u02a2\u02a8\3\2\2\2\u02a3\u02a4\f\3\2\2\u02a4"+ + "\u02a5\7C\2\2\u02a5\u02a7\7h\2\2\u02a6\u02a3\3\2\2\2\u02a7\u02aa\3\2\2"+ + "\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\67\3\2\2\2\u02aa\u02a8"+ + "\3\2\2\2\u02ab\u02b1\7h\2\2\u02ac\u02ad\5:\36\2\u02ad\u02ae\7C\2\2\u02ae"+ + "\u02af\7h\2\2\u02af\u02b1\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2"+ + "\2\2\u02b19\3\2\2\2\u02b2\u02b3\b\36\1\2\u02b3\u02b4\7h\2\2\u02b4\u02ba"+ + "\3\2\2\2\u02b5\u02b6\f\3\2\2\u02b6\u02b7\7C\2\2\u02b7\u02b9\7h\2\2\u02b8"+ + "\u02b5\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2\2\2\u02ba\u02bb\3\2"+ + "\2\2\u02bb;\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bd\u02c3\7h\2\2\u02be\u02bf"+ + "\5@!\2\u02bf\u02c0\7C\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c3\3\2\2\2\u02c2"+ + "\u02bd\3\2\2\2\u02c2\u02be\3\2\2\2\u02c3=\3\2\2\2\u02c4\u02c5\7h\2\2\u02c5"+ + "?\3\2\2\2\u02c6\u02c7\b!\1\2\u02c7\u02c8\7h\2\2\u02c8\u02ce\3\2\2\2\u02c9"+ + "\u02ca\f\3\2\2\u02ca\u02cb\7C\2\2\u02cb\u02cd\7h\2\2\u02cc\u02c9\3\2\2"+ + "\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cfA"+ + "\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d3\5D#\2\u02d2\u02d1\3\2\2\2\u02d2"+ + "\u02d3\3\2\2\2\u02d3\u02d7\3\2\2\2\u02d4\u02d6\5H%\2\u02d5\u02d4\3\2\2"+ + "\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02dd"+ + "\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02dc\5R*\2\u02db\u02da\3\2\2\2\u02dc"+ + "\u02df\3\2\2\2\u02dd\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e0\3\2"+ + "\2\2\u02df\u02dd\3\2\2\2\u02e0\u02e1\7\2\2\3\u02e1C\3\2\2\2\u02e2\u02e4"+ + "\5F$\2\u02e3\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5"+ + "\u02e6\3\2\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\7\""+ + "\2\2\u02e9\u02ee\7h\2\2\u02ea\u02eb\7C\2\2\u02eb\u02ed\7h\2\2\u02ec\u02ea"+ + "\3\2\2\2\u02ed\u02f0\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef"+ + "\u02f1\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f1\u02f2\7A\2\2\u02f2E\3\2\2\2\u02f3"+ + "\u02f4\5\u00e8u\2\u02f4G\3\2\2\2\u02f5\u02fa\5J&\2\u02f6\u02fa\5L\'\2"+ + "\u02f7\u02fa\5N(\2\u02f8\u02fa\5P)\2\u02f9\u02f5\3\2\2\2\u02f9\u02f6\3"+ + "\2\2\2\u02f9\u02f7\3\2\2\2\u02f9\u02f8\3\2\2\2\u02faI\3\2\2\2\u02fb\u02fc"+ + "\7\33\2\2\u02fc\u02fd\58\35\2\u02fd\u02fe\7A\2\2\u02feK\3\2\2\2\u02ff"+ + "\u0300\7\33\2\2\u0300\u0301\5:\36\2\u0301\u0302\7C\2\2\u0302\u0303\7U"+ + "\2\2\u0303\u0304\7A\2\2\u0304M\3\2\2\2\u0305\u0306\7\33\2\2\u0306\u0307"+ + "\7(\2\2\u0307\u0308\58\35\2\u0308\u0309\7C\2\2\u0309\u030a\7h\2\2\u030a"+ + "\u030b\7A\2\2\u030bO\3\2\2\2\u030c\u030d\7\33\2\2\u030d\u030e\7(\2\2\u030e"+ + "\u030f\58\35\2\u030f\u0310\7C\2\2\u0310\u0311\7U\2\2\u0311\u0312\7A\2"+ + "\2\u0312Q\3\2\2\2\u0313\u0317\5T+\2\u0314\u0317\5\u00c8e\2\u0315\u0317"+ + "\7A\2\2\u0316\u0313\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0315\3\2\2\2\u0317"+ + "S\3\2\2\2\u0318\u031b\5V,\2\u0319\u031b\5\u00bc_\2\u031a\u0318\3\2\2\2"+ + "\u031a\u0319\3\2\2\2\u031bU\3\2\2\2\u031c\u031e\5X-\2\u031d\u031c\3\2"+ + "\2\2\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+ + "\u0322\3\2\2\2\u0321\u031f\3\2\2\2\u0322\u0323\7\13\2\2\u0323\u0325\7"+ + "h\2\2\u0324\u0326\5Z.\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326"+ + "\u0328\3\2\2\2\u0327\u0329\5^\60\2\u0328\u0327\3\2\2\2\u0328\u0329\3\2"+ + "\2\2\u0329\u032b\3\2\2\2\u032a\u032c\5`\61\2\u032b\u032a\3\2\2\2\u032b"+ + "\u032c\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032e\5d\63\2\u032eW\3\2\2\2"+ + "\u032f\u0338\5\u00e8u\2\u0330\u0338\7%\2\2\u0331\u0338\7$\2\2\u0332\u0338"+ + "\7#\2\2\u0333\u0338\7\3\2\2\u0334\u0338\7(\2\2\u0335\u0338\7\24\2\2\u0336"+ + "\u0338\7)\2\2\u0337\u032f\3\2\2\2\u0337\u0330\3\2\2\2\u0337\u0331\3\2"+ + "\2\2\u0337\u0332\3\2\2\2\u0337\u0333\3\2\2\2\u0337\u0334\3\2\2\2\u0337"+ + "\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338Y\3\2\2\2\u0339\u033a\7F\2\2\u033a"+ + "\u033b\5\\/\2\u033b\u033c\7E\2\2\u033c[\3\2\2\2\u033d\u0342\5$\23\2\u033e"+ + "\u033f\7B\2\2\u033f\u0341\5$\23\2\u0340\u033e\3\2\2\2\u0341\u0344\3\2"+ + "\2\2\u0342\u0340\3\2\2\2\u0342\u0343\3\2\2\2\u0343]\3\2\2\2\u0344\u0342"+ + "\3\2\2\2\u0345\u0346\7\23\2\2\u0346\u0347\5\22\n\2\u0347_\3\2\2\2\u0348"+ + "\u0349\7\32\2\2\u0349\u034a\5b\62\2\u034aa\3\2\2\2\u034b\u0350\5\30\r"+ + "\2\u034c\u034d\7B\2\2\u034d\u034f\5\30\r\2\u034e\u034c\3\2\2\2\u034f\u0352"+ + "\3\2\2\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351c\3\2\2\2\u0352"+ + "\u0350\3\2\2\2\u0353\u0357\7=\2\2\u0354\u0356\5f\64\2\u0355\u0354\3\2"+ + "\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358"+ + "\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\7>\2\2\u035be\3\2\2\2\u035c"+ + "\u0361\5h\65\2\u035d\u0361\5\u00acW\2\u035e\u0361\5\u00aeX\2\u035f\u0361"+ + "\5\u00b0Y\2\u0360\u035c\3\2\2\2\u0360\u035d\3\2\2\2\u0360\u035e\3\2\2"+ + "\2\u0360\u035f\3\2\2\2\u0361g\3\2\2\2\u0362\u0368\5j\66\2\u0363\u0368"+ + "\5\u008eH\2\u0364\u0368\5T+\2\u0365\u0368\5\u00c8e\2\u0366\u0368\7A\2"+ + "\2\u0367\u0362\3\2\2\2\u0367\u0363\3\2\2\2\u0367\u0364\3\2\2\2\u0367\u0365"+ + "\3\2\2\2\u0367\u0366\3\2\2\2\u0368i\3\2\2\2\u0369\u036b\5l\67\2\u036a"+ + "\u0369\3\2\2\2\u036b\u036e\3\2\2\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2"+ + "\2\2\u036d\u036f\3\2\2\2\u036e\u036c\3\2\2\2\u036f\u0370\5v<\2\u0370\u0371"+ + "\5n8\2\u0371\u0372\7A\2\2\u0372k\3\2\2\2\u0373\u037c\5\u00e8u\2\u0374"+ + "\u037c\7%\2\2\u0375\u037c\7$\2\2\u0376\u037c\7#\2\2\u0377\u037c\7(\2\2"+ + "\u0378\u037c\7\24\2\2\u0379\u037c\7\60\2\2\u037a\u037c\7\63\2\2\u037b"+ + "\u0373\3\2\2\2\u037b\u0374\3\2\2\2\u037b\u0375\3\2\2\2\u037b\u0376\3\2"+ + "\2\2\u037b\u0377\3\2\2\2\u037b\u0378\3\2\2\2\u037b\u0379\3\2\2\2\u037b"+ + "\u037a\3\2\2\2\u037cm\3\2\2\2\u037d\u0382\5p9\2\u037e\u037f\7B\2\2\u037f"+ + "\u0381\5p9\2\u0380\u037e\3\2\2\2\u0381\u0384\3\2\2\2\u0382\u0380\3\2\2"+ + "\2\u0382\u0383\3\2\2\2\u0383o\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0388"+ + "\5r:\2\u0386\u0387\7D\2\2\u0387\u0389\5t;\2\u0388\u0386\3\2\2\2\u0388"+ + "\u0389\3\2\2\2\u0389q\3\2\2\2\u038a\u038c\7h\2\2\u038b\u038d\5\"\22\2"+ + "\u038c\u038b\3\2\2\2\u038c\u038d\3\2\2\2\u038ds\3\2\2\2\u038e\u0391\5"+ + "\u01a0\u00d1\2\u038f\u0391\5\u00fa~\2\u0390\u038e\3\2\2\2\u0390\u038f"+ + "\3\2\2\2\u0391u\3\2\2\2\u0392\u0395\5x=\2\u0393\u0395\5z>\2\u0394\u0392"+ + "\3\2\2\2\u0394\u0393\3\2\2\2\u0395w\3\2\2\2\u0396\u0399\5\b\5\2\u0397"+ + "\u0399\7\5\2\2\u0398\u0396\3\2\2\2\u0398\u0397\3\2\2\2\u0399y\3\2\2\2"+ + "\u039a\u039e\5|?\2\u039b\u039e\5\u008aF\2\u039c\u039e\5\u008cG\2\u039d"+ + "\u039a\3\2\2\2\u039d\u039b\3\2\2\2\u039d\u039c\3\2\2\2\u039e{\3\2\2\2"+ + "\u039f\u03a2\5\u0082B\2\u03a0\u03a2\5\u0088E\2\u03a1\u039f\3\2\2\2\u03a1"+ + "\u03a0\3\2\2\2\u03a2\u03a7\3\2\2\2\u03a3\u03a6\5\u0080A\2\u03a4\u03a6"+ + "\5\u0086D\2\u03a5\u03a3\3\2\2\2\u03a5\u03a4\3\2\2\2\u03a6\u03a9\3\2\2"+ + "\2\u03a7\u03a5\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8}\3\2\2\2\u03a9\u03a7"+ + "\3\2\2\2\u03aa\u03ac\7h\2\2\u03ab\u03ad\5,\27\2\u03ac\u03ab\3\2\2\2\u03ac"+ + "\u03ad\3\2\2\2\u03ad\u03bb\3\2\2\2\u03ae\u03af\5|?\2\u03af\u03b3\7C\2"+ + "\2\u03b0\u03b2\5\u00e8u\2\u03b1\u03b0\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3"+ + "\u03b1\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b6\3\2\2\2\u03b5\u03b3\3\2"+ + "\2\2\u03b6\u03b8\7h\2\2\u03b7\u03b9\5,\27\2\u03b8\u03b7\3\2\2\2\u03b8"+ + "\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03aa\3\2\2\2\u03ba\u03ae\3\2"+ + "\2\2\u03bb\177\3\2\2\2\u03bc\u03c0\7C\2\2\u03bd\u03bf\5\u00e8u\2\u03be"+ + "\u03bd\3\2\2\2\u03bf\u03c2\3\2\2\2\u03c0\u03be\3\2\2\2\u03c0\u03c1\3\2"+ + "\2\2\u03c1\u03c3\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c3\u03c5\7h\2\2\u03c4"+ + "\u03c6\5,\27\2\u03c5\u03c4\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u0081\3\2"+ + "\2\2\u03c7\u03c9\7h\2\2\u03c8\u03ca\5,\27\2\u03c9\u03c8\3\2\2\2\u03c9"+ + "\u03ca\3\2\2\2\u03ca\u0083\3\2\2\2\u03cb\u03cc\5~@\2\u03cc\u0085\3\2\2"+ + "\2\u03cd\u03ce\5\u0080A\2\u03ce\u0087\3\2\2\2\u03cf\u03d0\5\u0082B\2\u03d0"+ + "\u0089\3\2\2\2\u03d1\u03d2\7h\2\2\u03d2\u008b\3\2\2\2\u03d3\u03d4\5x="+ + "\2\u03d4\u03d5\5\"\22\2\u03d5\u03dd\3\2\2\2\u03d6\u03d7\5|?\2\u03d7\u03d8"+ + "\5\"\22\2\u03d8\u03dd\3\2\2\2\u03d9\u03da\5\u008aF\2\u03da\u03db\5\"\22"+ + "\2\u03db\u03dd\3\2\2\2\u03dc\u03d3\3\2\2\2\u03dc\u03d6\3\2\2\2\u03dc\u03d9"+ + "\3\2\2\2\u03dd\u008d\3\2\2\2\u03de\u03e0\5\u0090I\2\u03df\u03de\3\2\2"+ + "\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e4"+ + "\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5\u0092J\2\u03e5\u03e6\5\u00aa"+ + "V\2\u03e6\u008f\3\2\2\2\u03e7\u03f2\5\u00e8u\2\u03e8\u03f2\7%\2\2\u03e9"+ + "\u03f2\7$\2\2\u03ea\u03f2\7#\2\2\u03eb\u03f2\7\3\2\2\u03ec\u03f2\7(\2"+ + "\2\u03ed\u03f2\7\24\2\2\u03ee\u03f2\7,\2\2\u03ef\u03f2\7 \2\2\u03f0\u03f2"+ + "\7)\2\2\u03f1\u03e7\3\2\2\2\u03f1\u03e8\3\2\2\2\u03f1\u03e9\3\2\2\2\u03f1"+ + "\u03ea\3\2\2\2\u03f1\u03eb\3\2\2\2\u03f1\u03ec\3\2\2\2\u03f1\u03ed\3\2"+ + "\2\2\u03f1\u03ee\3\2\2\2\u03f1\u03ef\3\2\2\2\u03f1\u03f0\3\2\2\2\u03f2"+ + "\u0091\3\2\2\2\u03f3\u03f4\5\u0094K\2\u03f4\u03f6\5\u0096L\2\u03f5\u03f7"+ + "\5\u00a4S\2\u03f6\u03f5\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u0405\3\2\2"+ + "\2\u03f8\u03fc\5Z.\2\u03f9\u03fb\5\u00e8u\2\u03fa\u03f9\3\2\2\2\u03fb"+ + "\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\3\2"+ + "\2\2\u03fe\u03fc\3\2\2\2\u03ff\u0400\5\u0094K\2\u0400\u0402\5\u0096L\2"+ + "\u0401\u0403\5\u00a4S\2\u0402\u0401\3\2\2\2\u0402\u0403\3\2\2\2\u0403"+ + "\u0405\3\2\2\2\u0404\u03f3\3\2\2\2\u0404\u03f8\3\2\2\2\u0405\u0093\3\2"+ + "\2\2\u0406\u0409\5v<\2\u0407\u0409\7\62\2\2\u0408\u0406\3\2\2\2\u0408"+ + "\u0407\3\2\2\2\u0409\u0095\3\2\2\2\u040a\u040b\7h\2\2\u040b\u040d\7;\2"+ + "\2\u040c\u040e\5\u0098M\2\u040d\u040c\3\2\2\2\u040d\u040e\3\2\2\2\u040e"+ + "\u040f\3\2\2\2\u040f\u0411\7<\2\2\u0410\u0412\5\"\22\2\u0411\u0410\3\2"+ + "\2\2\u0411\u0412\3\2\2\2\u0412\u0097\3\2\2\2\u0413\u0414\5\u009aN\2\u0414"+ + "\u0415\7B\2\2\u0415\u0416\5\u00a0Q\2\u0416\u0419\3\2\2\2\u0417\u0419\5"+ + "\u00a0Q\2\u0418\u0413\3\2\2\2\u0418\u0417\3\2\2\2\u0419\u0099\3\2\2\2"+ + "\u041a\u041f\5\u009cO\2\u041b\u041c\7B\2\2\u041c\u041e\5\u009cO\2\u041d"+ + "\u041b\3\2\2\2\u041e\u0421\3\2\2\2\u041f\u041d\3\2\2\2\u041f\u0420\3\2"+ + "\2\2\u0420\u042b\3\2\2\2\u0421\u041f\3\2\2\2\u0422\u0427\5\u00a2R\2\u0423"+ + "\u0424\7B\2\2\u0424\u0426\5\u009cO\2\u0425\u0423\3\2\2\2\u0426\u0429\3"+ + "\2\2\2\u0427\u0425\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u042b\3\2\2\2\u0429"+ + "\u0427\3\2\2\2\u042a\u041a\3\2\2\2\u042a\u0422\3\2\2\2\u042b\u009b\3\2"+ + "\2\2\u042c\u042e\5\u009eP\2\u042d\u042c\3\2\2\2\u042e\u0431\3\2\2\2\u042f"+ + "\u042d\3\2\2\2\u042f\u0430\3\2\2\2\u0430\u0432\3\2\2\2\u0431\u042f\3\2"+ + "\2\2\u0432\u0433\5v<\2\u0433\u0434\5r:\2\u0434\u009d\3\2\2\2\u0435\u0438"+ + "\5\u00e8u\2\u0436\u0438\7\24\2\2\u0437\u0435\3\2\2\2\u0437\u0436\3\2\2"+ + "\2\u0438\u009f\3\2\2\2\u0439\u043b\5\u009eP\2\u043a\u0439\3\2\2\2\u043b"+ + "\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043f\3\2"+ + "\2\2\u043e\u043c\3\2\2\2\u043f\u0443\5v<\2\u0440\u0442\5\u00e8u\2\u0441"+ + "\u0440\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2"+ + "\2\2\u0444\u0446\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\7j\2\2\u0447"+ + "\u0448\5r:\2\u0448\u044b\3\2\2\2\u0449\u044b\5\u009cO\2\u044a\u043c\3"+ + "\2\2\2\u044a\u0449\3\2\2\2\u044b\u00a1\3\2\2\2\u044c\u044e\5\u00e8u\2"+ + "\u044d\u044c\3\2\2\2\u044e\u0451\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u0450"+ + "\3\2\2\2\u0450\u0452\3\2\2\2\u0451\u044f\3\2\2\2\u0452\u0455\5v<\2\u0453"+ + "\u0454\7h\2\2\u0454\u0456\7C\2\2\u0455\u0453\3\2\2\2\u0455\u0456\3\2\2"+ + "\2\u0456\u0457\3\2\2\2\u0457\u0458\7-\2\2\u0458\u00a3\3\2\2\2\u0459\u045a"+ + "\7/\2\2\u045a\u045b\5\u00a6T\2\u045b\u00a5\3\2\2\2\u045c\u0461\5\u00a8"+ + "U\2\u045d\u045e\7B\2\2\u045e\u0460\5\u00a8U\2\u045f\u045d\3\2\2\2\u0460"+ + "\u0463\3\2\2\2\u0461\u045f\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u00a7\3\2"+ + "\2\2\u0463\u0461\3\2\2\2\u0464\u0467\5\22\n\2\u0465\u0467\5\36\20\2\u0466"+ + "\u0464\3\2\2\2\u0466\u0465\3\2\2\2\u0467\u00a9\3\2\2\2\u0468\u046b\5\u00fe"+ + "\u0080\2\u0469\u046b\7A\2\2\u046a\u0468\3\2\2\2\u046a\u0469\3\2\2\2\u046b"+ + "\u00ab\3\2\2\2\u046c\u046d\5\u00fe\u0080\2\u046d\u00ad\3\2\2\2\u046e\u046f"+ + "\7(\2\2\u046f\u0470\5\u00fe\u0080\2\u0470\u00af\3\2\2\2\u0471\u0473\5"+ + "\u00b2Z\2\u0472\u0471\3\2\2\2\u0473\u0476\3\2\2\2\u0474\u0472\3\2\2\2"+ + "\u0474\u0475\3\2\2\2\u0475\u0477\3\2\2\2\u0476\u0474\3\2\2\2\u0477\u0479"+ + "\5\u00b4[\2\u0478\u047a\5\u00a4S\2\u0479\u0478\3\2\2\2\u0479\u047a\3\2"+ + "\2\2\u047a\u047b\3\2\2\2\u047b\u047c\5\u00b8]\2\u047c\u00b1\3\2\2\2\u047d"+ + "\u0482\5\u00e8u\2\u047e\u0482\7%\2\2\u047f\u0482\7$\2\2\u0480\u0482\7"+ + "#\2\2\u0481\u047d\3\2\2\2\u0481\u047e\3\2\2\2\u0481\u047f\3\2\2\2\u0481"+ + "\u0480\3\2\2\2\u0482\u00b3\3\2\2\2\u0483\u0485\5Z.\2\u0484\u0483\3\2\2"+ + "\2\u0484\u0485\3\2\2\2\u0485\u0486\3\2\2\2\u0486\u0487\5\u00b6\\\2\u0487"+ + "\u0489\7;\2\2\u0488\u048a\5\u0098M\2\u0489\u0488\3\2\2\2\u0489\u048a\3"+ + "\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\7<\2\2\u048c\u00b5\3\2\2\2\u048d"+ + "\u048e\7h\2\2\u048e\u00b7\3\2\2\2\u048f\u0491\7=\2\2\u0490\u0492\5\u00ba"+ + "^\2\u0491\u0490\3\2\2\2\u0491\u0492\3\2\2\2\u0492\u0494\3\2\2\2\u0493"+ + "\u0495\5\u0100\u0081\2\u0494\u0493\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0496"+ + "\3\2\2\2\u0496\u0497\7>\2\2\u0497\u00b9\3\2\2\2\u0498\u049a\5,\27\2\u0499"+ + "\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049c\7-"+ + "\2\2\u049c\u049e\7;\2\2\u049d\u049f\5\u0190\u00c9\2\u049e\u049d\3\2\2"+ + "\2\u049e\u049f\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\7<\2\2\u04a1\u04c7"+ + "\7A\2\2\u04a2\u04a4\5,\27\2\u04a3\u04a2\3\2\2\2\u04a3\u04a4\3\2\2\2\u04a4"+ + "\u04a5\3\2\2\2\u04a5\u04a6\7*\2\2\u04a6\u04a8\7;\2\2\u04a7\u04a9\5\u0190"+ + "\u00c9\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa"+ + "\u04ab\7<\2\2\u04ab\u04c7\7A\2\2\u04ac\u04ad\5<\37\2\u04ad\u04af\7C\2"+ + "\2\u04ae\u04b0\5,\27\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1"+ + "\3\2\2\2\u04b1\u04b2\7*\2\2\u04b2\u04b4\7;\2\2\u04b3\u04b5\5\u0190\u00c9"+ + "\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b7"+ + "\7<\2\2\u04b7\u04b8\7A\2\2\u04b8\u04c7\3\2\2\2\u04b9\u04ba\5\u0162\u00b2"+ + "\2\u04ba\u04bc\7C\2\2\u04bb\u04bd\5,\27\2\u04bc\u04bb\3\2\2\2\u04bc\u04bd"+ + "\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04bf\7*\2\2\u04bf\u04c1\7;\2\2\u04c0"+ + "\u04c2\5\u0190\u00c9\2\u04c1\u04c0\3\2\2\2\u04c1\u04c2\3\2\2\2\u04c2\u04c3"+ + "\3\2\2\2\u04c3\u04c4\7<\2\2\u04c4\u04c5\7A\2\2\u04c5\u04c7\3\2\2\2\u04c6"+ + "\u0499\3\2\2\2\u04c6\u04a3\3\2\2\2\u04c6\u04ac\3\2\2\2\u04c6\u04b9\3\2"+ + "\2\2\u04c7\u00bb\3\2\2\2\u04c8\u04ca\5X-\2\u04c9\u04c8\3\2\2\2\u04ca\u04cd"+ + "\3\2\2\2\u04cb\u04c9\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04ce\3\2\2\2\u04cd"+ + "\u04cb\3\2\2\2\u04ce\u04cf\7\22\2\2\u04cf\u04d1\7h\2\2\u04d0\u04d2\5`"+ + "\61\2\u04d1\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3"+ + "\u04d4\5\u00be`\2\u04d4\u00bd\3\2\2\2\u04d5\u04d7\7=\2\2\u04d6\u04d8\5"+ + "\u00c0a\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2"+ + "\u04d9\u04db\7B\2\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd"+ + "\3\2\2\2\u04dc\u04de\5\u00c6d\2\u04dd\u04dc\3\2\2\2\u04dd\u04de\3\2\2"+ + "\2\u04de\u04df\3\2\2\2\u04df\u04e0\7>\2\2\u04e0\u00bf\3\2\2\2\u04e1\u04e6"+ + "\5\u00c2b\2\u04e2\u04e3\7B\2\2\u04e3\u04e5\5\u00c2b\2\u04e4\u04e2\3\2"+ + "\2\2\u04e5\u04e8\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7"+ + "\u00c1\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e9\u04eb\5\u00c4c\2\u04ea\u04e9"+ + "\3\2\2\2\u04eb\u04ee\3\2\2\2\u04ec\u04ea\3\2\2\2\u04ec\u04ed\3\2\2\2\u04ed"+ + "\u04ef\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ef\u04f5\7h\2\2\u04f0\u04f2\7;\2"+ + "\2\u04f1\u04f3\5\u0190\u00c9\2\u04f2\u04f1\3\2\2\2\u04f2\u04f3\3\2\2\2"+ + "\u04f3\u04f4\3\2\2\2\u04f4\u04f6\7<\2\2\u04f5\u04f0\3\2\2\2\u04f5\u04f6"+ + "\3\2\2\2\u04f6\u04f8\3\2\2\2\u04f7\u04f9\5d\63\2\u04f8\u04f7\3\2\2\2\u04f8"+ + "\u04f9\3\2\2\2\u04f9\u00c3\3\2\2\2\u04fa\u04fb\5\u00e8u\2\u04fb\u00c5"+ + "\3\2\2\2\u04fc\u0500\7A\2\2\u04fd\u04ff\5f\64\2\u04fe\u04fd\3\2\2\2\u04ff"+ + "\u0502\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u0501\3\2\2\2\u0501\u00c7\3\2"+ + "\2\2\u0502\u0500\3\2\2\2\u0503\u0506\5\u00caf\2\u0504\u0506\5\u00dco\2"+ + "\u0505\u0503\3\2\2\2\u0505\u0504\3\2\2\2\u0506\u00c9\3\2\2\2\u0507\u0509"+ + "\5\u00ccg\2\u0508\u0507\3\2\2\2\u0509\u050c\3\2\2\2\u050a\u0508\3\2\2"+ + "\2\u050a\u050b\3\2\2\2\u050b\u050d\3\2\2\2\u050c\u050a\3\2\2\2\u050d\u050e"+ + "\7\36\2\2\u050e\u0510\7h\2\2\u050f\u0511\5Z.\2\u0510\u050f\3\2\2\2\u0510"+ + "\u0511\3\2\2\2\u0511\u0513\3\2\2\2\u0512\u0514\5\u00ceh\2\u0513\u0512"+ + "\3\2\2\2\u0513\u0514\3\2\2\2\u0514\u0515\3\2\2\2\u0515\u0516\5\u00d0i"+ + "\2\u0516\u00cb\3\2\2\2\u0517\u051f\5\u00e8u\2\u0518\u051f\7%\2\2\u0519"+ + "\u051f\7$\2\2\u051a\u051f\7#\2\2\u051b\u051f\7\3\2\2\u051c\u051f\7(\2"+ + "\2\u051d\u051f\7)\2\2\u051e\u0517\3\2\2\2\u051e\u0518\3\2\2\2\u051e\u0519"+ + "\3\2\2\2\u051e\u051a\3\2\2\2\u051e\u051b\3\2\2\2\u051e\u051c\3\2\2\2\u051e"+ + "\u051d\3\2\2\2\u051f\u00cd\3\2\2\2\u0520\u0521\7\23\2\2\u0521\u0522\5"+ + "b\62\2\u0522\u00cf\3\2\2\2\u0523\u0527\7=\2\2\u0524\u0526\5\u00d2j\2\u0525"+ + "\u0524\3\2\2\2\u0526\u0529\3\2\2\2\u0527\u0525\3\2\2\2\u0527\u0528\3\2"+ + "\2\2\u0528\u052a\3\2\2\2\u0529\u0527\3\2\2\2\u052a\u052b\7>\2\2\u052b"+ + "\u00d1\3\2\2\2\u052c\u0532\5\u00d4k\2\u052d\u0532\5\u00d8m\2\u052e\u0532"+ + "\5T+\2\u052f\u0532\5\u00c8e\2\u0530\u0532\7A\2\2\u0531\u052c\3\2\2\2\u0531"+ + "\u052d\3\2\2\2\u0531\u052e\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0530\3\2"+ + "\2\2\u0532\u00d3\3\2\2\2\u0533\u0535\5\u00d6l\2\u0534\u0533\3\2\2\2\u0535"+ + "\u0538\3\2\2\2\u0536\u0534\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2"+ + "\2\2\u0538\u0536\3\2\2\2\u0539\u053a\5v<\2\u053a\u053b\5n8\2\u053b\u053c"+ + "\7A\2\2\u053c\u00d5\3\2\2\2\u053d\u0542\5\u00e8u\2\u053e\u0542\7%\2\2"+ + "\u053f\u0542\7(\2\2\u0540\u0542\7\24\2\2\u0541\u053d\3\2\2\2\u0541\u053e"+ + "\3\2\2\2\u0541\u053f\3\2\2\2\u0541\u0540\3\2\2\2\u0542\u00d7\3\2\2\2\u0543"+ + "\u0545\5\u00dan\2\u0544\u0543\3\2\2\2\u0545\u0548\3\2\2\2\u0546\u0544"+ + "\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u0549\3\2\2\2\u0548\u0546\3\2\2\2\u0549"+ + "\u054a\5\u0092J\2\u054a\u054b\5\u00aaV\2\u054b\u00d9\3\2\2\2\u054c\u0553"+ + "\5\u00e8u\2\u054d\u0553\7%\2\2\u054e\u0553\7\3\2\2\u054f\u0553\7\16\2"+ + "\2\u0550\u0553\7(\2\2\u0551\u0553\7)\2\2\u0552\u054c\3\2\2\2\u0552\u054d"+ + "\3\2\2\2\u0552\u054e\3\2\2\2\u0552\u054f\3\2\2\2\u0552\u0550\3\2\2\2\u0552"+ + "\u0551\3\2\2\2\u0553\u00db\3\2\2\2\u0554\u0556\5\u00ccg\2\u0555\u0554"+ + "\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555\3\2\2\2\u0557\u0558\3\2\2\2\u0558"+ + "\u055a\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u055b\7i\2\2\u055b\u055c\7\36"+ + "\2\2\u055c\u055d\7h\2\2\u055d\u055e\5\u00dep\2\u055e\u00dd\3\2\2\2\u055f"+ + "\u0563\7=\2\2\u0560\u0562\5\u00e0q\2\u0561\u0560\3\2\2\2\u0562\u0565\3"+ + "\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2\2\2\u0565"+ + "\u0563\3\2\2\2\u0566\u0567\7>\2\2\u0567\u00df\3\2\2\2\u0568\u056e\5\u00e2"+ + "r\2\u0569\u056e\5\u00d4k\2\u056a\u056e\5T+\2\u056b\u056e\5\u00c8e\2\u056c"+ + "\u056e\7A\2\2\u056d\u0568\3\2\2\2\u056d\u0569\3\2\2\2\u056d\u056a\3\2"+ + "\2\2\u056d\u056b\3\2\2\2\u056d\u056c\3\2\2\2\u056e\u00e1\3\2\2\2\u056f"+ + "\u0571\5\u00e4s\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2\2\2\u0572\u0570"+ + "\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574\u0572\3\2\2\2\u0575"+ + "\u0576\5v<\2\u0576\u0577\7h\2\2\u0577\u0578\7;\2\2\u0578\u057a\7<\2\2"+ + "\u0579\u057b\5\"\22\2\u057a\u0579\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d"+ + "\3\2\2\2\u057c\u057e\5\u00e6t\2\u057d\u057c\3\2\2\2\u057d\u057e\3\2\2"+ + "\2\u057e\u057f\3\2\2\2\u057f\u0580\7A\2\2\u0580\u00e3\3\2\2\2\u0581\u0585"+ + "\5\u00e8u\2\u0582\u0585\7%\2\2\u0583\u0585\7\3\2\2\u0584\u0581\3\2\2\2"+ + "\u0584\u0582\3\2\2\2\u0584\u0583\3\2\2\2\u0585\u00e5\3\2\2\2\u0586\u0587"+ + "\7\16\2\2\u0587\u0588\5\u00f0y\2\u0588\u00e7\3\2\2\2\u0589\u058d\5\u00ea"+ + "v\2\u058a\u058d\5\u00f6|\2\u058b\u058d\5\u00f8}\2\u058c\u0589\3\2\2\2"+ + "\u058c\u058a\3\2\2\2\u058c\u058b\3\2\2\2\u058d\u00e9\3\2\2\2\u058e\u058f"+ + "\7i\2\2\u058f\u0590\58\35\2\u0590\u0592\7;\2\2\u0591\u0593\5\u00ecw\2"+ + "\u0592\u0591\3\2\2\2\u0592\u0593\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0595"+ + "\7<\2\2\u0595\u00eb\3\2\2\2\u0596\u059b\5\u00eex\2\u0597\u0598\7B\2\2"+ + "\u0598\u059a\5\u00eex\2\u0599\u0597\3\2\2\2\u059a\u059d\3\2\2\2\u059b"+ + "\u0599\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u00ed\3\2\2\2\u059d\u059b\3\2"+ + "\2\2\u059e\u059f\7h\2\2\u059f\u05a0\7D\2\2\u05a0\u05a1\5\u00f0y\2\u05a1"+ + "\u00ef\3\2\2\2\u05a2\u05a6\5\u01b2\u00da\2\u05a3\u05a6\5\u00f2z\2\u05a4"+ + "\u05a6\5\u00e8u\2\u05a5\u05a2\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a4"+ + "\3\2\2\2\u05a6\u00f1\3\2\2\2\u05a7\u05a9\7=\2\2\u05a8\u05aa\5\u00f4{\2"+ + "\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ac\3\2\2\2\u05ab\u05ad"+ + "\7B\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae"+ + "\u05af\7>\2\2\u05af\u00f3\3\2\2\2\u05b0\u05b5\5\u00f0y\2\u05b1\u05b2\7"+ + "B\2\2\u05b2\u05b4\5\u00f0y\2\u05b3\u05b1\3\2\2\2\u05b4\u05b7\3\2\2\2\u05b5"+ + "\u05b3\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u00f5\3\2\2\2\u05b7\u05b5\3\2"+ + "\2\2\u05b8\u05b9\7i\2\2\u05b9\u05ba\58\35\2\u05ba\u00f7\3\2\2\2\u05bb"+ + "\u05bc\7i\2\2\u05bc\u05bd\58\35\2\u05bd\u05be\7;\2\2\u05be\u05bf\5\u00f0"+ + "y\2\u05bf\u05c0\7<\2\2\u05c0\u00f9\3\2\2\2\u05c1\u05c3\7=\2\2\u05c2\u05c4"+ + "\5\u00fc\177\2\u05c3\u05c2\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u05c6\3\2"+ + "\2\2\u05c5\u05c7\7B\2\2\u05c6\u05c5\3\2\2\2\u05c6\u05c7\3\2\2\2\u05c7"+ + "\u05c8\3\2\2\2\u05c8\u05c9\7>\2\2\u05c9\u00fb\3\2\2\2\u05ca\u05cf\5t;"+ + "\2\u05cb\u05cc\7B\2\2\u05cc\u05ce\5t;\2\u05cd\u05cb\3\2\2\2\u05ce\u05d1"+ + "\3\2\2\2\u05cf\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u00fd\3\2\2\2\u05d1"+ + "\u05cf\3\2\2\2\u05d2\u05d4\7=\2\2\u05d3\u05d5\5\u0100\u0081\2\u05d4\u05d3"+ + "\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05d7\7>\2\2\u05d7"+ + "\u00ff\3\2\2\2\u05d8\u05dc\5\u0102\u0082\2\u05d9\u05db\5\u0102\u0082\2"+ + "\u05da\u05d9\3\2\2\2\u05db\u05de\3\2\2\2\u05dc\u05da\3\2\2\2\u05dc\u05dd"+ + "\3\2\2\2\u05dd\u0101\3\2\2\2\u05de\u05dc\3\2\2\2\u05df\u05e3\5\u0104\u0083"+ + "\2\u05e0\u05e3\5T+\2\u05e1\u05e3\5\u0108\u0085\2\u05e2\u05df\3\2\2\2\u05e2"+ + "\u05e0\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3\u0103\3\2\2\2\u05e4\u05e5\5\u0106"+ + "\u0084\2\u05e5\u05e6\7A\2\2\u05e6\u0105\3\2\2\2\u05e7\u05e9\5\u009eP\2"+ + "\u05e8\u05e7\3\2\2\2\u05e9\u05ec\3\2\2\2\u05ea\u05e8\3\2\2\2\u05ea\u05eb"+ + "\3\2\2\2\u05eb\u05ed\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ed\u05ee\5v<\2\u05ee"+ + "\u05ef\5n8\2\u05ef\u0107\3\2\2\2\u05f0\u05f7\5\u010c\u0087\2\u05f1\u05f7"+ + "\5\u0110\u0089\2\u05f2\u05f7\5\u0118\u008d\2\u05f3\u05f7\5\u011a\u008e"+ + "\2\u05f4\u05f7\5\u012c\u0097\2\u05f5\u05f7\5\u0132\u009a\2\u05f6\u05f0"+ + "\3\2\2\2\u05f6\u05f1\3\2\2\2\u05f6\u05f2\3\2\2\2\u05f6\u05f3\3\2\2\2\u05f6"+ + "\u05f4\3\2\2\2\u05f6\u05f5\3\2\2\2\u05f7\u0109\3\2\2\2\u05f8\u05fe\5\u010c"+ + "\u0087\2\u05f9\u05fe\5\u0112\u008a\2\u05fa\u05fe\5\u011c\u008f\2\u05fb"+ + "\u05fe\5\u012e\u0098\2\u05fc\u05fe\5\u0134\u009b\2\u05fd\u05f8\3\2\2\2"+ + "\u05fd\u05f9\3\2\2\2\u05fd\u05fa\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fd\u05fc"+ + "\3\2\2\2\u05fe\u010b\3\2\2\2\u05ff\u060c\5\u00fe\u0080\2\u0600\u060c\5"+ + "\u010e\u0088\2\u0601\u060c\5\u0114\u008b\2\u0602\u060c\5\u011e\u0090\2"+ + "\u0603\u060c\5\u0120\u0091\2\u0604\u060c\5\u0130\u0099\2\u0605\u060c\5"+ + "\u0144\u00a3\2\u0606\u060c\5\u0146\u00a4\2\u0607\u060c\5\u0148\u00a5\2"+ + "\u0608\u060c\5\u014c\u00a7\2\u0609\u060c\5\u014a\u00a6\2\u060a\u060c\5"+ + "\u014e\u00a8\2\u060b\u05ff\3\2\2\2\u060b\u0600\3\2\2\2\u060b\u0601\3\2"+ + "\2\2\u060b\u0602\3\2\2\2\u060b\u0603\3\2\2\2\u060b\u0604\3\2\2\2\u060b"+ + "\u0605\3\2\2\2\u060b\u0606\3\2\2\2\u060b\u0607\3\2\2\2\u060b\u0608\3\2"+ + "\2\2\u060b\u0609\3\2\2\2\u060b\u060a\3\2\2\2\u060c\u010d\3\2\2\2\u060d"+ + "\u060e\7A\2\2\u060e\u010f\3\2\2\2\u060f\u0610\7h\2\2\u0610\u0611\7J\2"+ + "\2\u0611\u0612\5\u0108\u0085\2\u0612\u0111\3\2\2\2\u0613\u0614\7h\2\2"+ + "\u0614\u0615\7J\2\2\u0615\u0616\5\u010a\u0086\2\u0616\u0113\3\2\2\2\u0617"+ + "\u0618\5\u0116\u008c\2\u0618\u0619\7A\2\2\u0619\u0115\3\2\2\2\u061a\u0622"+ + "\5\u01ac\u00d7\2\u061b\u0622\5\u01ca\u00e6\2\u061c\u0622\5\u01cc\u00e7"+ + "\2\u061d\u0622\5\u01d2\u00ea\2\u061e\u0622\5\u01d6\u00ec\2\u061f\u0622"+ + "\5\u018a\u00c6\2\u0620\u0622\5\u0176\u00bc\2\u0621\u061a\3\2\2\2\u0621"+ + "\u061b\3\2\2\2\u0621\u061c\3\2\2\2\u0621\u061d\3\2\2\2\u0621\u061e\3\2"+ + "\2\2\u0621\u061f\3\2\2\2\u0621\u0620\3\2\2\2\u0622\u0117\3\2\2\2\u0623"+ + "\u0624\7\30\2\2\u0624\u0625\7;\2\2\u0625\u0626\5\u01a0\u00d1\2\u0626\u0627"+ + "\7<\2\2\u0627\u0628\5\u0108\u0085\2\u0628\u0119\3\2\2\2\u0629\u062a\7"+ + "\30\2\2\u062a\u062b\7;\2\2\u062b\u062c\5\u01a0\u00d1\2\u062c\u062d\7<"+ + "\2\2\u062d\u062e\5\u010a\u0086\2\u062e\u062f\7\21\2\2\u062f\u0630\5\u0108"+ + "\u0085\2\u0630\u011b\3\2\2\2\u0631\u0632\7\30\2\2\u0632\u0633\7;\2\2\u0633"+ + "\u0634\5\u01a0\u00d1\2\u0634\u0635\7<\2\2\u0635\u0636\5\u010a\u0086\2"+ + "\u0636\u0637\7\21\2\2\u0637\u0638\5\u010a\u0086\2\u0638\u011d\3\2\2\2"+ + "\u0639\u063a\7\4\2\2\u063a\u063b\5\u01a0\u00d1\2\u063b\u063c\7A\2\2\u063c"+ + "\u0644\3\2\2\2\u063d\u063e\7\4\2\2\u063e\u063f\5\u01a0\u00d1\2\u063f\u0640"+ + "\7J\2\2\u0640\u0641\5\u01a0\u00d1\2\u0641\u0642\7A\2\2\u0642\u0644\3\2"+ + "\2\2\u0643\u0639\3\2\2\2\u0643\u063d\3\2\2\2\u0644\u011f\3\2\2\2\u0645"+ + "\u0646\7+\2\2\u0646\u0647\7;\2\2\u0647\u0648\5\u01a0\u00d1\2\u0648\u0649"+ + "\7<\2\2\u0649\u064a\5\u0122\u0092\2\u064a\u0121\3\2\2\2\u064b\u064f\7"+ + "=\2\2\u064c\u064e\5\u0124\u0093\2\u064d\u064c\3\2\2\2\u064e\u0651\3\2"+ + "\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u0655\3\2\2\2\u0651"+ + "\u064f\3\2\2\2\u0652\u0654\5\u0128\u0095\2\u0653\u0652\3\2\2\2\u0654\u0657"+ + "\3\2\2\2\u0655\u0653\3\2\2\2\u0655\u0656\3\2\2\2\u0656\u0658\3\2\2\2\u0657"+ + "\u0655\3\2\2\2\u0658\u0659\7>\2\2\u0659\u0123\3\2\2\2\u065a\u065b\5\u0126"+ + "\u0094\2\u065b\u065c\5\u0100\u0081\2\u065c\u0125\3\2\2\2\u065d\u0661\5"+ + "\u0128\u0095\2\u065e\u0660\5\u0128\u0095\2\u065f\u065e\3\2\2\2\u0660\u0663"+ + "\3\2\2\2\u0661\u065f\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u0127\3\2\2\2\u0663"+ + "\u0661\3\2\2\2\u0664\u0665\7\b\2\2\u0665\u0666\5\u019e\u00d0\2\u0666\u0667"+ + "\7J\2\2\u0667\u066f\3\2\2\2\u0668\u0669\7\b\2\2\u0669\u066a\5\u012a\u0096"+ + "\2\u066a\u066b\7J\2\2\u066b\u066f\3\2\2\2\u066c\u066d\7\16\2\2\u066d\u066f"+ + "\7J\2\2\u066e\u0664\3\2\2\2\u066e\u0668\3\2\2\2\u066e\u066c\3\2\2\2\u066f"+ + "\u0129\3\2\2\2\u0670\u0671\7h\2\2\u0671\u012b\3\2\2\2\u0672\u0673\7\64"+ + "\2\2\u0673\u0674\7;\2\2\u0674\u0675\5\u01a0\u00d1\2\u0675\u0676\7<\2\2"+ + "\u0676\u0677\5\u0108\u0085\2\u0677\u012d\3\2\2\2\u0678\u0679\7\64\2\2"+ + "\u0679\u067a\7;\2\2\u067a\u067b\5\u01a0\u00d1\2\u067b\u067c\7<\2\2\u067c"+ + "\u067d\5\u010a\u0086\2\u067d\u012f\3\2\2\2\u067e\u067f\7\17\2\2\u067f"+ + "\u0680\5\u0108\u0085\2\u0680\u0681\7\64\2\2\u0681\u0682\7;\2\2\u0682\u0683"+ + "\5\u01a0\u00d1\2\u0683\u0684\7<\2\2\u0684\u0685\7A\2\2\u0685\u0131\3\2"+ + "\2\2\u0686\u0689\5\u0136\u009c\2\u0687\u0689\5\u0140\u00a1\2\u0688\u0686"+ + "\3\2\2\2\u0688\u0687\3\2\2\2\u0689\u0133\3\2\2\2\u068a\u068d\5\u0138\u009d"+ + "\2\u068b\u068d\5\u0142\u00a2\2\u068c\u068a\3\2\2\2\u068c\u068b\3\2\2\2"+ + "\u068d\u0135\3\2\2\2\u068e\u068f\7\27\2\2\u068f\u0691\7;\2\2\u0690\u0692"+ + "\5\u013a\u009e\2\u0691\u0690\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u0693\3"+ + "\2\2\2\u0693\u0695\7A\2\2\u0694\u0696\5\u01a0\u00d1\2\u0695\u0694\3\2"+ + "\2\2\u0695\u0696\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0699\7A\2\2\u0698"+ + "\u069a\5\u013c\u009f\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069b"+ + "\3\2\2\2\u069b\u069c\7<\2\2\u069c\u069d\5\u0108\u0085\2\u069d\u0137\3"+ + "\2\2\2\u069e\u069f\7\27\2\2\u069f\u06a1\7;\2\2\u06a0\u06a2\5\u013a\u009e"+ + "\2\u06a1\u06a0\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a5"+ + "\7A\2\2\u06a4\u06a6\5\u01a0\u00d1\2\u06a5\u06a4\3\2\2\2\u06a5\u06a6\3"+ + "\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u06a9\7A\2\2\u06a8\u06aa\5\u013c\u009f"+ + "\2\u06a9\u06a8\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab\u06ac"+ + "\7<\2\2\u06ac\u06ad\5\u010a\u0086\2\u06ad\u0139\3\2\2\2\u06ae\u06b1\5"+ + "\u013e\u00a0\2\u06af\u06b1\5\u0106\u0084\2\u06b0\u06ae\3\2\2\2\u06b0\u06af"+ + "\3\2\2\2\u06b1\u013b\3\2\2\2\u06b2\u06b3\5\u013e\u00a0\2\u06b3\u013d\3"+ + "\2\2\2\u06b4\u06b9\5\u0116\u008c\2\u06b5\u06b6\7B\2\2\u06b6\u06b8\5\u0116"+ + "\u008c\2\u06b7\u06b5\3\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9"+ + "\u06ba\3\2\2\2\u06ba\u013f\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06bd\7\27"+ + "\2\2\u06bd\u06c1\7;\2\2\u06be\u06c0\5\u009eP\2\u06bf\u06be\3\2\2\2\u06c0"+ + "\u06c3\3\2\2\2\u06c1\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c4\3\2"+ + "\2\2\u06c3\u06c1\3\2\2\2\u06c4\u06c5\5v<\2\u06c5\u06c6\5r:\2\u06c6\u06c7"+ + "\7J\2\2\u06c7\u06c8\5\u01a0\u00d1\2\u06c8\u06c9\7<\2\2\u06c9\u06ca\5\u0108"+ + "\u0085\2\u06ca\u0141\3\2\2\2\u06cb\u06cc\7\27\2\2\u06cc\u06d0\7;\2\2\u06cd"+ + "\u06cf\5\u009eP\2\u06ce\u06cd\3\2\2\2\u06cf\u06d2\3\2\2\2\u06d0\u06ce"+ + "\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06d3\3\2\2\2\u06d2\u06d0\3\2\2\2\u06d3"+ + "\u06d4\5v<\2\u06d4\u06d5\5r:\2\u06d5\u06d6\7J\2\2\u06d6\u06d7\5\u01a0"+ + "\u00d1\2\u06d7\u06d8\7<\2\2\u06d8\u06d9\5\u010a\u0086\2\u06d9\u0143\3"+ + "\2\2\2\u06da\u06dc\7\6\2\2\u06db\u06dd\7h\2\2\u06dc\u06db\3\2\2\2\u06dc"+ + "\u06dd\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06df\7A\2\2\u06df\u0145\3\2"+ + "\2\2\u06e0\u06e2\7\r\2\2\u06e1\u06e3\7h\2\2\u06e2\u06e1\3\2\2\2\u06e2"+ + "\u06e3\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\7A\2\2\u06e5\u0147\3\2"+ + "\2\2\u06e6\u06e8\7&\2\2\u06e7\u06e9\5\u01a0\u00d1\2\u06e8\u06e7\3\2\2"+ + "\2\u06e8\u06e9\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7A\2\2\u06eb\u0149"+ + "\3\2\2\2\u06ec\u06ed\7.\2\2\u06ed\u06ee\5\u01a0\u00d1\2\u06ee\u06ef\7"+ + "A\2\2\u06ef\u014b\3\2\2\2\u06f0\u06f1\7,\2\2\u06f1\u06f2\7;\2\2\u06f2"+ + "\u06f3\5\u01a0\u00d1\2\u06f3\u06f4\7<\2\2\u06f4\u06f5\5\u00fe\u0080\2"+ + "\u06f5\u014d\3\2\2\2\u06f6\u06f7\7\61\2\2\u06f7\u06f8\5\u00fe\u0080\2"+ + "\u06f8\u06f9\5\u0150\u00a9\2\u06f9\u0703\3\2\2\2\u06fa\u06fb\7\61\2\2"+ + "\u06fb\u06fd\5\u00fe\u0080\2\u06fc\u06fe\5\u0150\u00a9\2\u06fd\u06fc\3"+ + "\2\2\2\u06fd\u06fe\3\2\2\2\u06fe\u06ff\3\2\2\2\u06ff\u0700\5\u0158\u00ad"+ + "\2\u0700\u0703\3\2\2\2\u0701\u0703\5\u015a\u00ae\2\u0702\u06f6\3\2\2\2"+ + "\u0702\u06fa\3\2\2\2\u0702\u0701\3\2\2\2\u0703\u014f\3\2\2\2\u0704\u0708"+ + "\5\u0152\u00aa\2\u0705\u0707\5\u0152\u00aa\2\u0706\u0705\3\2\2\2\u0707"+ + "\u070a\3\2\2\2\u0708\u0706\3\2\2\2\u0708\u0709\3\2\2\2\u0709\u0151\3\2"+ + "\2\2\u070a\u0708\3\2\2\2\u070b\u070c\7\t\2\2\u070c\u070d\7;\2\2\u070d"+ + "\u070e\5\u0154\u00ab\2\u070e\u070f\7<\2\2\u070f\u0710\5\u00fe\u0080\2"+ + "\u0710\u0153\3\2\2\2\u0711\u0713\5\u009eP\2\u0712\u0711\3\2\2\2\u0713"+ + "\u0716\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0717\3\2"+ + "\2\2\u0716\u0714\3\2\2\2\u0717\u0718\5\u0156\u00ac\2\u0718\u0719\5r:\2"+ + "\u0719\u0155\3\2\2\2\u071a\u071f\5~@\2\u071b\u071c\7X\2\2\u071c\u071e"+ + "\5\22\n\2\u071d\u071b\3\2\2\2\u071e\u0721\3\2\2\2\u071f\u071d\3\2\2\2"+ + "\u071f\u0720\3\2\2\2\u0720\u0157\3\2\2\2\u0721\u071f\3\2\2\2\u0722\u0723"+ + "\7\25\2\2\u0723\u0724\5\u00fe\u0080\2\u0724\u0159\3\2\2\2\u0725\u0726"+ + "\7\61\2\2\u0726\u0727\5\u015c\u00af\2\u0727\u0729\5\u00fe\u0080\2\u0728"+ + "\u072a\5\u0150\u00a9\2\u0729\u0728\3\2\2\2\u0729\u072a\3\2\2\2\u072a\u072c"+ + "\3\2\2\2\u072b\u072d\5\u0158\u00ad\2\u072c\u072b\3\2\2\2\u072c\u072d\3"+ + "\2\2\2\u072d\u015b\3\2\2\2\u072e\u072f\7;\2\2\u072f\u0731\5\u015e\u00b0"+ + "\2\u0730\u0732\7A\2\2\u0731\u0730\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u0733"+ + "\3\2\2\2\u0733\u0734\7<\2\2\u0734\u015d\3\2\2\2\u0735\u073a\5\u0160\u00b1"+ + "\2\u0736\u0737\7A\2\2\u0737\u0739\5\u0160\u00b1\2\u0738\u0736\3\2\2\2"+ + "\u0739\u073c\3\2\2\2\u073a\u0738\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u015f"+ + "\3\2\2\2\u073c\u073a\3\2\2\2\u073d\u073f\5\u009eP\2\u073e\u073d\3\2\2"+ + "\2\u073f\u0742\3\2\2\2\u0740\u073e\3\2\2\2\u0740\u0741\3\2\2\2\u0741\u0743"+ + "\3\2\2\2\u0742\u0740\3\2\2\2\u0743\u0744\5v<\2\u0744\u0745\5r:\2\u0745"+ + "\u0746\7D\2\2\u0746\u0747\5\u01a0\u00d1\2\u0747\u0161\3\2\2\2\u0748\u074b"+ + "\5\u0170\u00b9\2\u0749\u074b\5\u0198\u00cd\2\u074a\u0748\3\2\2\2\u074a"+ + "\u0749\3\2\2\2\u074b\u074f\3\2\2\2\u074c\u074e\5\u016a\u00b6\2\u074d\u074c"+ + "\3\2\2\2\u074e\u0751\3\2\2\2\u074f\u074d\3\2\2\2\u074f\u0750\3\2\2\2\u0750"+ + "\u0163\3\2\2\2\u0751\u074f\3\2\2\2\u0752\u0770\5\2\2\2\u0753\u0758\58"+ + "\35\2\u0754\u0755\7?\2\2\u0755\u0757\7@\2\2\u0756\u0754\3\2\2\2\u0757"+ + "\u075a\3\2\2\2\u0758\u0756\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075b\3\2"+ + "\2\2\u075a\u0758\3\2\2\2\u075b\u075c\7C\2\2\u075c\u075d\7\13\2\2\u075d"+ + "\u0770\3\2\2\2\u075e\u075f\7\62\2\2\u075f\u0760\7C\2\2\u0760\u0770\7\13"+ + "\2\2\u0761\u0770\7-\2\2\u0762\u0763\58\35\2\u0763\u0764\7C\2\2\u0764\u0765"+ + "\7-\2\2\u0765\u0770\3\2\2\2\u0766\u0767\7;\2\2\u0767\u0768\5\u01a0\u00d1"+ + "\2\u0768\u0769\7<\2\2\u0769\u0770\3\2\2\2\u076a\u0770\5\u0176\u00bc\2"+ + "\u076b\u0770\5\u017e\u00c0\2\u076c\u0770\5\u0184\u00c3\2\u076d\u0770\5"+ + "\u018a\u00c6\2\u076e\u0770\5\u0192\u00ca\2\u076f\u0752\3\2\2\2\u076f\u0753"+ + "\3\2\2\2\u076f\u075e\3\2\2\2\u076f\u0761\3\2\2\2\u076f\u0762\3\2\2\2\u076f"+ + "\u0766\3\2\2\2\u076f\u076a\3\2\2\2\u076f\u076b\3\2\2\2\u076f\u076c\3\2"+ + "\2\2\u076f\u076d\3\2\2\2\u076f\u076e\3\2\2\2\u0770\u0165\3\2\2\2\u0771"+ + "\u0772\3\2\2\2\u0772\u0167\3\2\2\2\u0773\u0790\5\2\2\2\u0774\u0779\58"+ + "\35\2\u0775\u0776\7?\2\2\u0776\u0778\7@\2\2\u0777\u0775\3\2\2\2\u0778"+ + "\u077b\3\2\2\2\u0779\u0777\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077c\3\2"+ + "\2\2\u077b\u0779\3\2\2\2\u077c\u077d\7C\2\2\u077d\u077e\7\13\2\2\u077e"+ + "\u0790\3\2\2\2\u077f\u0780\7\62\2\2\u0780\u0781\7C\2\2\u0781\u0790\7\13"+ + "\2\2\u0782\u0790\7-\2\2\u0783\u0784\58\35\2\u0784\u0785\7C\2\2\u0785\u0786"+ + "\7-\2\2\u0786\u0790\3\2\2\2\u0787\u0788\7;\2\2\u0788\u0789\5\u01a0\u00d1"+ + "\2\u0789\u078a\7<\2\2\u078a\u0790\3\2\2\2\u078b\u0790\5\u0176\u00bc\2"+ + "\u078c\u0790\5\u017e\u00c0\2\u078d\u0790\5\u018a\u00c6\2\u078e\u0790\5"+ + "\u0192\u00ca\2\u078f\u0773\3\2\2\2\u078f\u0774\3\2\2\2\u078f\u077f\3\2"+ + "\2\2\u078f\u0782\3\2\2\2\u078f\u0783\3\2\2\2\u078f\u0787\3\2\2\2\u078f"+ + "\u078b\3\2\2\2\u078f\u078c\3\2\2\2\u078f\u078d\3\2\2\2\u078f\u078e\3\2"+ + "\2\2\u0790\u0169\3\2\2\2\u0791\u0797\5\u0178\u00bd\2\u0792\u0797\5\u0180"+ + "\u00c1\2\u0793\u0797\5\u0186\u00c4\2\u0794\u0797\5\u018c\u00c7\2\u0795"+ + "\u0797\5\u0194\u00cb\2\u0796\u0791\3\2\2\2\u0796\u0792\3\2\2\2\u0796\u0793"+ + "\3\2\2\2\u0796\u0794\3\2\2\2\u0796\u0795\3\2\2\2\u0797\u016b\3\2\2\2\u0798"+ + "\u0799\3\2\2\2\u0799\u016d\3\2\2\2\u079a\u079f\5\u0178\u00bd\2\u079b\u079f"+ + "\5\u0180\u00c1\2\u079c\u079f\5\u018c\u00c7\2\u079d\u079f\5\u0194\u00cb"+ + "\2\u079e\u079a\3\2\2\2\u079e\u079b\3\2\2\2\u079e\u079c\3\2\2\2\u079e\u079d"+ + "\3\2\2\2\u079f\u016f\3\2\2\2\u07a0\u07c9\5\2\2\2\u07a1\u07a6\58\35\2\u07a2"+ + "\u07a3\7?\2\2\u07a3\u07a5\7@\2\2\u07a4\u07a2\3\2\2\2\u07a5\u07a8\3\2\2"+ + "\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07a9\3\2\2\2\u07a8\u07a6"+ + "\3\2\2\2\u07a9\u07aa\7C\2\2\u07aa\u07ab\7\13\2\2\u07ab\u07c9\3\2\2\2\u07ac"+ + "\u07b1\5x=\2\u07ad\u07ae\7?\2\2\u07ae\u07b0\7@\2\2\u07af\u07ad\3\2\2\2"+ + "\u07b0\u07b3\3\2\2\2\u07b1\u07af\3\2\2\2\u07b1\u07b2\3\2\2\2\u07b2\u07b4"+ + "\3\2\2\2\u07b3\u07b1\3\2\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7\13\2\2\u07b6"+ + "\u07c9\3\2\2\2\u07b7\u07b8\7\62\2\2\u07b8\u07b9\7C\2\2\u07b9\u07c9\7\13"+ + "\2\2\u07ba\u07c9\7-\2\2\u07bb\u07bc\58\35\2\u07bc\u07bd\7C\2\2\u07bd\u07be"+ + "\7-\2\2\u07be\u07c9\3\2\2\2\u07bf\u07c0\7;\2\2\u07c0\u07c1\5\u01a0\u00d1"+ + "\2\u07c1\u07c2\7<\2\2\u07c2\u07c9\3\2\2\2\u07c3\u07c9\5\u017a\u00be\2"+ + "\u07c4\u07c9\5\u0182\u00c2\2\u07c5\u07c9\5\u0188\u00c5\2\u07c6\u07c9\5"+ + "\u018e\u00c8\2\u07c7\u07c9\5\u0196\u00cc\2\u07c8\u07a0\3\2\2\2\u07c8\u07a1"+ + "\3\2\2\2\u07c8\u07ac\3\2\2\2\u07c8\u07b7\3\2\2\2\u07c8\u07ba\3\2\2\2\u07c8"+ + "\u07bb\3\2\2\2\u07c8\u07bf\3\2\2\2\u07c8\u07c3\3\2\2\2\u07c8\u07c4\3\2"+ + "\2\2\u07c8\u07c5\3\2\2\2\u07c8\u07c6\3\2\2\2\u07c8\u07c7\3\2\2\2\u07c9"+ + "\u0171\3\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u0173\3\2\2\2\u07cc\u07f4\5\2"+ + "\2\2\u07cd\u07d2\58\35\2\u07ce\u07cf\7?\2\2\u07cf\u07d1\7@\2\2\u07d0\u07ce"+ + "\3\2\2\2\u07d1\u07d4\3\2\2\2\u07d2\u07d0\3\2\2\2\u07d2\u07d3\3\2\2\2\u07d3"+ + "\u07d5\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d5\u07d6\7C\2\2\u07d6\u07d7\7\13"+ + "\2\2\u07d7\u07f4\3\2\2\2\u07d8\u07dd\5x=\2\u07d9\u07da\7?\2\2\u07da\u07dc"+ + "\7@\2\2\u07db\u07d9\3\2\2\2\u07dc\u07df\3\2\2\2\u07dd\u07db\3\2\2\2\u07dd"+ + "\u07de\3\2\2\2\u07de\u07e0\3\2\2\2\u07df\u07dd\3\2\2\2\u07e0\u07e1\7C"+ + "\2\2\u07e1\u07e2\7\13\2\2\u07e2\u07f4\3\2\2\2\u07e3\u07e4\7\62\2\2\u07e4"+ + "\u07e5\7C\2\2\u07e5\u07f4\7\13\2\2\u07e6\u07f4\7-\2\2\u07e7\u07e8\58\35"+ + "\2\u07e8\u07e9\7C\2\2\u07e9\u07ea\7-\2\2\u07ea\u07f4\3\2\2\2\u07eb\u07ec"+ + "\7;\2\2\u07ec\u07ed\5\u01a0\u00d1\2\u07ed\u07ee\7<\2\2\u07ee\u07f4\3\2"+ + "\2\2\u07ef\u07f4\5\u017a\u00be\2\u07f0\u07f4\5\u0182\u00c2\2\u07f1\u07f4"+ + "\5\u018e\u00c8\2\u07f2\u07f4\5\u0196\u00cc\2\u07f3\u07cc\3\2\2\2\u07f3"+ + "\u07cd\3\2\2\2\u07f3\u07d8\3\2\2\2\u07f3\u07e3\3\2\2\2\u07f3\u07e6\3\2"+ + "\2\2\u07f3\u07e7\3\2\2\2\u07f3\u07eb\3\2\2\2\u07f3\u07ef\3\2\2\2\u07f3"+ + "\u07f0\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f2\3\2\2\2\u07f4\u0175\3\2"+ + "\2\2\u07f5\u07f7\7!\2\2\u07f6\u07f8\5,\27\2\u07f7\u07f6\3\2\2\2\u07f7"+ + "\u07f8\3\2\2\2\u07f8\u07fc\3\2\2\2\u07f9\u07fb\5\u00e8u\2\u07fa\u07f9"+ + "\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd"+ + "\u07ff\3\2\2\2\u07fe\u07fc\3\2\2\2\u07ff\u080a\7h\2\2\u0800\u0804\7C\2"+ + "\2\u0801\u0803\5\u00e8u\2\u0802\u0801\3\2\2\2\u0803\u0806\3\2\2\2\u0804"+ + "\u0802\3\2\2\2\u0804\u0805\3\2\2\2\u0805\u0807\3\2\2\2\u0806\u0804\3\2"+ + "\2\2\u0807\u0809\7h\2\2\u0808\u0800\3\2\2\2\u0809\u080c\3\2\2\2\u080a"+ + "\u0808\3\2\2\2\u080a\u080b\3\2\2\2\u080b\u080e\3\2\2\2\u080c\u080a\3\2"+ + "\2\2\u080d\u080f\5\u017c\u00bf\2\u080e\u080d\3\2\2\2\u080e\u080f\3\2\2"+ + "\2\u080f\u0810\3\2\2\2\u0810\u0812\7;\2\2\u0811\u0813\5\u0190\u00c9\2"+ + "\u0812\u0811\3\2\2\2\u0812\u0813\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0816"+ + "\7<\2\2\u0815\u0817\5d\63\2\u0816\u0815\3\2\2\2\u0816\u0817\3\2\2\2\u0817"+ + "\u0849\3\2\2\2\u0818\u0819\5<\37\2\u0819\u081a\7C\2\2\u081a\u081c\7!\2"+ + "\2\u081b\u081d\5,\27\2\u081c\u081b\3\2\2\2\u081c\u081d\3\2\2\2\u081d\u0821"+ + "\3\2\2\2\u081e\u0820\5\u00e8u\2\u081f\u081e\3\2\2\2\u0820\u0823\3\2\2"+ + "\2\u0821\u081f\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0824\3\2\2\2\u0823\u0821"+ + "\3\2\2\2\u0824\u0826\7h\2\2\u0825\u0827\5\u017c\u00bf\2\u0826\u0825\3"+ + "\2\2\2\u0826\u0827\3\2\2\2\u0827\u0828\3\2\2\2\u0828\u082a\7;\2\2\u0829"+ + "\u082b\5\u0190\u00c9\2\u082a\u0829\3\2\2\2\u082a\u082b\3\2\2\2\u082b\u082c"+ + "\3\2\2\2\u082c\u082e\7<\2\2\u082d\u082f\5d\63\2\u082e\u082d\3\2\2\2\u082e"+ + "\u082f\3\2\2\2\u082f\u0849\3\2\2\2\u0830\u0831\5\u0162\u00b2\2\u0831\u0832"+ + "\7C\2\2\u0832\u0834\7!\2\2\u0833\u0835\5,\27\2\u0834\u0833\3\2\2\2\u0834"+ + "\u0835\3\2\2\2\u0835\u0839\3\2\2\2\u0836\u0838\5\u00e8u\2\u0837\u0836"+ + "\3\2\2\2\u0838\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a"+ + "\u083c\3\2\2\2\u083b\u0839\3\2\2\2\u083c\u083e\7h\2\2\u083d\u083f\5\u017c"+ + "\u00bf\2\u083e\u083d\3\2\2\2\u083e\u083f\3\2\2\2\u083f\u0840\3\2\2\2\u0840"+ + "\u0842\7;\2\2\u0841\u0843\5\u0190\u00c9\2\u0842\u0841\3\2\2\2\u0842\u0843"+ + "\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0846\7<\2\2\u0845\u0847\5d\63\2\u0846"+ + "\u0845\3\2\2\2\u0846\u0847\3\2\2\2\u0847\u0849\3\2\2\2\u0848\u07f5\3\2"+ + "\2\2\u0848\u0818\3\2\2\2\u0848\u0830\3\2\2\2\u0849\u0177\3\2\2\2\u084a"+ + "\u084b\7C\2\2\u084b\u084d\7!\2\2\u084c\u084e\5,\27\2\u084d\u084c\3\2\2"+ + "\2\u084d\u084e\3\2\2\2\u084e\u0852\3\2\2\2\u084f\u0851\5\u00e8u\2\u0850"+ + "\u084f\3\2\2\2\u0851\u0854\3\2\2\2\u0852\u0850\3\2\2\2\u0852\u0853\3\2"+ + "\2\2\u0853\u0855\3\2\2\2\u0854\u0852\3\2\2\2\u0855\u0857\7h\2\2\u0856"+ + "\u0858\5\u017c\u00bf\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0859"+ + "\3\2\2\2\u0859\u085b\7;\2\2\u085a\u085c\5\u0190\u00c9\2\u085b\u085a\3"+ + "\2\2\2\u085b\u085c\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085f\7<\2\2\u085e"+ + "\u0860\5d\63\2\u085f\u085e\3\2\2\2\u085f\u0860\3\2\2\2\u0860\u0179\3\2"+ + "\2\2\u0861\u0863\7!\2\2\u0862\u0864\5,\27\2\u0863\u0862\3\2\2\2\u0863"+ + "\u0864\3\2\2\2\u0864\u0868\3\2\2\2\u0865\u0867\5\u00e8u\2\u0866\u0865"+ + "\3\2\2\2\u0867\u086a\3\2\2\2\u0868\u0866\3\2\2\2\u0868\u0869\3\2\2\2\u0869"+ + "\u086b\3\2\2\2\u086a\u0868\3\2\2\2\u086b\u0876\7h\2\2\u086c\u0870\7C\2"+ + "\2\u086d\u086f\5\u00e8u\2\u086e\u086d\3\2\2\2\u086f\u0872\3\2\2\2\u0870"+ + "\u086e\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0873\3\2\2\2\u0872\u0870\3\2"+ + "\2\2\u0873\u0875\7h\2\2\u0874\u086c\3\2\2\2\u0875\u0878\3\2\2\2\u0876"+ + "\u0874\3\2\2\2\u0876\u0877\3\2\2\2\u0877\u087a\3\2\2\2\u0878\u0876\3\2"+ + "\2\2\u0879\u087b\5\u017c\u00bf\2\u087a\u0879\3\2\2\2\u087a\u087b\3\2\2"+ + "\2\u087b\u087c\3\2\2\2\u087c\u087e\7;\2\2\u087d\u087f\5\u0190\u00c9\2"+ + "\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0882"+ + "\7<\2\2\u0881\u0883\5d\63\2\u0882\u0881\3\2\2\2\u0882\u0883\3\2\2\2\u0883"+ + "\u089d\3\2\2\2\u0884\u0885\5<\37\2\u0885\u0886\7C\2\2\u0886\u0888\7!\2"+ + "\2\u0887\u0889\5,\27\2\u0888\u0887\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u088d"+ + "\3\2\2\2\u088a\u088c\5\u00e8u\2\u088b\u088a\3\2\2\2\u088c\u088f\3\2\2"+ + "\2\u088d\u088b\3\2\2\2\u088d\u088e\3\2\2\2\u088e\u0890\3\2\2\2\u088f\u088d"+ + "\3\2\2\2\u0890\u0892\7h\2\2\u0891\u0893\5\u017c\u00bf\2\u0892\u0891\3"+ + "\2\2\2\u0892\u0893\3\2\2\2\u0893\u0894\3\2\2\2\u0894\u0896\7;\2\2\u0895"+ + "\u0897\5\u0190\u00c9\2\u0896\u0895\3\2\2\2\u0896\u0897\3\2\2\2\u0897\u0898"+ + "\3\2\2\2\u0898\u089a\7<\2\2\u0899\u089b\5d\63\2\u089a\u0899\3\2\2\2\u089a"+ + "\u089b\3\2\2\2\u089b\u089d\3\2\2\2\u089c\u0861\3\2\2\2\u089c\u0884\3\2"+ + "\2\2\u089d\u017b\3\2\2\2\u089e\u08a2\5,\27\2\u089f\u08a0\7F\2\2\u08a0"+ + "\u08a2\7E\2\2\u08a1\u089e\3\2\2\2\u08a1\u089f\3\2\2\2\u08a2\u017d\3\2"+ + "\2\2\u08a3\u08a4\5\u0162\u00b2\2\u08a4\u08a5\7C\2\2\u08a5\u08a6\7h\2\2"+ + "\u08a6\u08b1\3\2\2\2\u08a7\u08a8\7*\2\2\u08a8\u08a9\7C\2\2\u08a9\u08b1"+ + "\7h\2\2\u08aa\u08ab\58\35\2\u08ab\u08ac\7C\2\2\u08ac\u08ad\7*\2\2\u08ad"+ + "\u08ae\7C\2\2\u08ae\u08af\7h\2\2\u08af\u08b1\3\2\2\2\u08b0\u08a3\3\2\2"+ + "\2\u08b0\u08a7\3\2\2\2\u08b0\u08aa\3\2\2\2\u08b1\u017f\3\2\2\2\u08b2\u08b3"+ + "\7C\2\2\u08b3\u08b4\7h\2\2\u08b4\u0181\3\2\2\2\u08b5\u08b6\7*\2\2\u08b6"+ + "\u08b7\7C\2\2\u08b7\u08bf\7h\2\2\u08b8\u08b9\58\35\2\u08b9\u08ba\7C\2"+ + "\2\u08ba\u08bb\7*\2\2\u08bb\u08bc\7C\2\2\u08bc\u08bd\7h\2\2\u08bd\u08bf"+ + "\3\2\2\2\u08be\u08b5\3\2\2\2\u08be\u08b8\3\2\2\2\u08bf\u0183\3\2\2\2\u08c0"+ + "\u08c1\5<\37\2\u08c1\u08c2\7?\2\2\u08c2\u08c3\5\u01a0\u00d1\2\u08c3\u08c4"+ + "\7@\2\2\u08c4\u08cb\3\2\2\2\u08c5\u08c6\5\u0168\u00b5\2\u08c6\u08c7\7"+ + "?\2\2\u08c7\u08c8\5\u01a0\u00d1\2\u08c8\u08c9\7@\2\2\u08c9\u08cb\3\2\2"+ + "\2\u08ca\u08c0\3\2\2\2\u08ca\u08c5\3\2\2\2\u08cb\u08d3\3\2\2\2\u08cc\u08cd"+ + "\5\u0166\u00b4\2\u08cd\u08ce\7?\2\2\u08ce\u08cf\5\u01a0\u00d1\2\u08cf"+ + "\u08d0\7@\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cc\3\2\2\2\u08d2\u08d5\3\2"+ + "\2\2\u08d3\u08d1\3\2\2\2\u08d3\u08d4\3\2\2\2\u08d4\u0185\3\2\2\2\u08d5"+ + "\u08d3\3\2\2\2\u08d6\u08d7\5\u016e\u00b8\2\u08d7\u08d8\7?\2\2\u08d8\u08d9"+ + "\5\u01a0\u00d1\2\u08d9\u08da\7@\2\2\u08da\u08e2\3\2\2\2\u08db\u08dc\5"+ + "\u016c\u00b7\2\u08dc\u08dd\7?\2\2\u08dd\u08de\5\u01a0\u00d1\2\u08de\u08df"+ + "\7@\2\2\u08df\u08e1\3\2\2\2\u08e0\u08db\3\2\2\2\u08e1\u08e4\3\2\2\2\u08e2"+ + "\u08e0\3\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u0187\3\2\2\2\u08e4\u08e2\3\2"+ + "\2\2\u08e5\u08e6\5<\37\2\u08e6\u08e7\7?\2\2\u08e7\u08e8\5\u01a0\u00d1"+ + "\2\u08e8\u08e9\7@\2\2\u08e9\u08f0\3\2\2\2\u08ea\u08eb\5\u0174\u00bb\2"+ + "\u08eb\u08ec\7?\2\2\u08ec\u08ed\5\u01a0\u00d1\2\u08ed\u08ee\7@\2\2\u08ee"+ + "\u08f0\3\2\2\2\u08ef\u08e5\3\2\2\2\u08ef\u08ea\3\2\2\2\u08f0\u08f8\3\2"+ + "\2\2\u08f1\u08f2\5\u0172\u00ba\2\u08f2\u08f3\7?\2\2\u08f3\u08f4\5\u01a0"+ + "\u00d1\2\u08f4\u08f5\7@\2\2\u08f5\u08f7\3\2\2\2\u08f6\u08f1\3\2\2\2\u08f7"+ + "\u08fa\3\2\2\2\u08f8\u08f6\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u0189\3\2"+ + "\2\2\u08fa\u08f8\3\2\2\2\u08fb\u08fc\5> \2\u08fc\u08fe\7;\2\2\u08fd\u08ff"+ + "\5\u0190\u00c9\2\u08fe\u08fd\3\2\2\2\u08fe\u08ff\3\2\2\2\u08ff\u0900\3"+ + "\2\2\2\u0900\u0901\7<\2\2\u0901\u0940\3\2\2\2\u0902\u0903\58\35\2\u0903"+ + "\u0905\7C\2\2\u0904\u0906\5,\27\2\u0905\u0904\3\2\2\2\u0905\u0906\3\2"+ + "\2\2\u0906\u0907\3\2\2\2\u0907\u0908\7h\2\2\u0908\u090a\7;\2\2\u0909\u090b"+ + "\5\u0190\u00c9\2\u090a\u0909\3\2\2\2\u090a\u090b\3\2\2\2\u090b\u090c\3"+ + "\2\2\2\u090c\u090d\7<\2\2\u090d\u0940\3\2\2\2\u090e\u090f\5<\37\2\u090f"+ + "\u0911\7C\2\2\u0910\u0912\5,\27\2\u0911\u0910\3\2\2\2\u0911\u0912\3\2"+ + "\2\2\u0912\u0913\3\2\2\2\u0913\u0914\7h\2\2\u0914\u0916\7;\2\2\u0915\u0917"+ + "\5\u0190\u00c9\2\u0916\u0915\3\2\2\2\u0916\u0917\3\2\2\2\u0917\u0918\3"+ + "\2\2\2\u0918\u0919\7<\2\2\u0919\u0940\3\2\2\2\u091a\u091b\5\u0162\u00b2"+ + "\2\u091b\u091d\7C\2\2\u091c\u091e\5,\27\2\u091d\u091c\3\2\2\2\u091d\u091e"+ + "\3\2\2\2\u091e\u091f\3\2\2\2\u091f\u0920\7h\2\2\u0920\u0922\7;\2\2\u0921"+ + "\u0923\5\u0190\u00c9\2\u0922\u0921\3\2\2\2\u0922\u0923\3\2\2\2\u0923\u0924"+ + "\3\2\2\2\u0924\u0925\7<\2\2\u0925\u0940\3\2\2\2\u0926\u0927\7*\2\2\u0927"+ + "\u0929\7C\2\2\u0928\u092a\5,\27\2\u0929\u0928\3\2\2\2\u0929\u092a\3\2"+ + "\2\2\u092a\u092b\3\2\2\2\u092b\u092c\7h\2\2\u092c\u092e\7;\2\2\u092d\u092f"+ + "\5\u0190\u00c9\2\u092e\u092d\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0930\3"+ + "\2\2\2\u0930\u0940\7<\2\2\u0931\u0932\58\35\2\u0932\u0933\7C\2\2\u0933"+ + "\u0934\7*\2\2\u0934\u0936\7C\2\2\u0935\u0937\5,\27\2\u0936\u0935\3\2\2"+ + "\2\u0936\u0937\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\7h\2\2\u0939\u093b"+ + "\7;\2\2\u093a\u093c\5\u0190\u00c9\2\u093b\u093a\3\2\2\2\u093b\u093c\3"+ + "\2\2\2\u093c\u093d\3\2\2\2\u093d\u093e\7<\2\2\u093e\u0940\3\2\2\2\u093f"+ + "\u08fb\3\2\2\2\u093f\u0902\3\2\2\2\u093f\u090e\3\2\2\2\u093f\u091a\3\2"+ + "\2\2\u093f\u0926\3\2\2\2\u093f\u0931\3\2\2\2\u0940\u018b\3\2\2\2\u0941"+ + "\u0943\7C\2\2\u0942\u0944\5,\27\2\u0943\u0942\3\2\2\2\u0943\u0944\3\2"+ + "\2\2\u0944\u0945\3\2\2\2\u0945\u0946\7h\2\2\u0946\u0948\7;\2\2\u0947\u0949"+ + "\5\u0190\u00c9\2\u0948\u0947\3\2\2\2\u0948\u0949\3\2\2\2\u0949\u094a\3"+ + "\2\2\2\u094a\u094b\7<\2\2\u094b\u018d\3\2\2\2\u094c\u094d\5> \2\u094d"+ + "\u094f\7;\2\2\u094e\u0950\5\u0190\u00c9\2\u094f\u094e\3\2\2\2\u094f\u0950"+ + "\3\2\2\2\u0950\u0951\3\2\2\2\u0951\u0952\7<\2\2\u0952\u0985\3\2\2\2\u0953"+ + "\u0954\58\35\2\u0954\u0956\7C\2\2\u0955\u0957\5,\27\2\u0956\u0955\3\2"+ + "\2\2\u0956\u0957\3\2\2\2\u0957\u0958\3\2\2\2\u0958\u0959\7h\2\2\u0959"+ + "\u095b\7;\2\2\u095a\u095c\5\u0190\u00c9\2\u095b\u095a\3\2\2\2\u095b\u095c"+ + "\3\2\2\2\u095c\u095d\3\2\2\2\u095d\u095e\7<\2\2\u095e\u0985\3\2\2\2\u095f"+ + "\u0960\5<\37\2\u0960\u0962\7C\2\2\u0961\u0963\5,\27\2\u0962\u0961\3\2"+ + "\2\2\u0962\u0963\3\2\2\2\u0963\u0964\3\2\2\2\u0964\u0965\7h\2\2\u0965"+ + "\u0967\7;\2\2\u0966\u0968\5\u0190\u00c9\2\u0967\u0966\3\2\2\2\u0967\u0968"+ + "\3\2\2\2\u0968\u0969\3\2\2\2\u0969\u096a\7<\2\2\u096a\u0985\3\2\2\2\u096b"+ + "\u096c\7*"; + private static final String _serializedATNSegment1 = + "\2\2\u096c\u096e\7C\2\2\u096d\u096f\5,\27\2\u096e\u096d\3\2\2\2\u096e"+ + "\u096f\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0971\7h\2\2\u0971\u0973\7;\2"+ + "\2\u0972\u0974\5\u0190\u00c9\2\u0973\u0972\3\2\2\2\u0973\u0974\3\2\2\2"+ + "\u0974\u0975\3\2\2\2\u0975\u0985\7<\2\2\u0976\u0977\58\35\2\u0977\u0978"+ + "\7C\2\2\u0978\u0979\7*\2\2\u0979\u097b\7C\2\2\u097a\u097c\5,\27\2\u097b"+ + "\u097a\3\2\2\2\u097b\u097c\3\2\2\2\u097c\u097d\3\2\2\2\u097d\u097e\7h"+ + "\2\2\u097e\u0980\7;\2\2\u097f\u0981\5\u0190\u00c9\2\u0980\u097f\3\2\2"+ + "\2\u0980\u0981\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0983\7<\2\2\u0983\u0985"+ + "\3\2\2\2\u0984\u094c\3\2\2\2\u0984\u0953\3\2\2\2\u0984\u095f\3\2\2\2\u0984"+ + "\u096b\3\2\2\2\u0984\u0976\3\2\2\2\u0985\u018f\3\2\2\2\u0986\u098b\5\u01a0"+ + "\u00d1\2\u0987\u0988\7B\2\2\u0988\u098a\5\u01a0\u00d1\2\u0989\u0987\3"+ + "\2\2\2\u098a\u098d\3\2\2\2\u098b\u0989\3\2\2\2\u098b\u098c\3\2\2\2\u098c"+ + "\u0191\3\2\2\2\u098d\u098b\3\2\2\2\u098e\u098f\5<\37\2\u098f\u0991\7\\"+ + "\2\2\u0990\u0992\5,\27\2\u0991\u0990\3\2\2\2\u0991\u0992\3\2\2\2\u0992"+ + "\u0993\3\2\2\2\u0993\u0994\7h\2\2\u0994\u09be\3\2\2\2\u0995\u0996\5\16"+ + "\b\2\u0996\u0998\7\\\2\2\u0997\u0999\5,\27\2\u0998\u0997\3\2\2\2\u0998"+ + "\u0999\3\2\2\2\u0999\u099a\3\2\2\2\u099a\u099b\7h\2\2\u099b\u09be\3\2"+ + "\2\2\u099c\u099d\5\u0162\u00b2\2\u099d\u099f\7\\\2\2\u099e\u09a0\5,\27"+ + "\2\u099f\u099e\3\2\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a1\3\2\2\2\u09a1\u09a2"+ + "\7h\2\2\u09a2\u09be\3\2\2\2\u09a3\u09a4\7*\2\2\u09a4\u09a6\7\\\2\2\u09a5"+ + "\u09a7\5,\27\2\u09a6\u09a5\3\2\2\2\u09a6\u09a7\3\2\2\2\u09a7\u09a8\3\2"+ + "\2\2\u09a8\u09be\7h\2\2\u09a9\u09aa\58\35\2\u09aa\u09ab\7C\2\2\u09ab\u09ac"+ + "\7*\2\2\u09ac\u09ae\7\\\2\2\u09ad\u09af\5,\27\2\u09ae\u09ad\3\2\2\2\u09ae"+ + "\u09af\3\2\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1\7h\2\2\u09b1\u09be\3\2"+ + "\2\2\u09b2\u09b3\5\22\n\2\u09b3\u09b5\7\\\2\2\u09b4\u09b6\5,\27\2\u09b5"+ + "\u09b4\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\3\2\2\2\u09b7\u09b8\7!"+ + "\2\2\u09b8\u09be\3\2\2\2\u09b9\u09ba\5 \21\2\u09ba\u09bb\7\\\2\2\u09bb"+ + "\u09bc\7!\2\2\u09bc\u09be\3\2\2\2\u09bd\u098e\3\2\2\2\u09bd\u0995\3\2"+ + "\2\2\u09bd\u099c\3\2\2\2\u09bd\u09a3\3\2\2\2\u09bd\u09a9\3\2\2\2\u09bd"+ + "\u09b2\3\2\2\2\u09bd\u09b9\3\2\2\2\u09be\u0193\3\2\2\2\u09bf\u09c1\7\\"+ + "\2\2\u09c0\u09c2\5,\27\2\u09c1\u09c0\3\2\2\2\u09c1\u09c2\3\2\2\2\u09c2"+ + "\u09c3\3\2\2\2\u09c3\u09c4\7h\2\2\u09c4\u0195\3\2\2\2\u09c5\u09c6\5<\37"+ + "\2\u09c6\u09c8\7\\\2\2\u09c7\u09c9\5,\27\2\u09c8\u09c7\3\2\2\2\u09c8\u09c9"+ + "\3\2\2\2\u09c9\u09ca\3\2\2\2\u09ca\u09cb\7h\2\2\u09cb\u09ee\3\2\2\2\u09cc"+ + "\u09cd\5\16\b\2\u09cd\u09cf\7\\\2\2\u09ce\u09d0\5,\27\2\u09cf\u09ce\3"+ + "\2\2\2\u09cf\u09d0\3\2\2\2\u09d0\u09d1\3\2\2\2\u09d1\u09d2\7h\2\2\u09d2"+ + "\u09ee\3\2\2\2\u09d3\u09d4\7*\2\2\u09d4\u09d6\7\\\2\2\u09d5\u09d7\5,\27"+ + "\2\u09d6\u09d5\3\2\2\2\u09d6\u09d7\3\2\2\2\u09d7\u09d8\3\2\2\2\u09d8\u09ee"+ + "\7h\2\2\u09d9\u09da\58\35\2\u09da\u09db\7C\2\2\u09db\u09dc\7*\2\2\u09dc"+ + "\u09de\7\\\2\2\u09dd\u09df\5,\27\2\u09de\u09dd\3\2\2\2\u09de\u09df\3\2"+ + "\2\2\u09df\u09e0\3\2\2\2\u09e0\u09e1\7h\2\2\u09e1\u09ee\3\2\2\2\u09e2"+ + "\u09e3\5\22\n\2\u09e3\u09e5\7\\\2\2\u09e4\u09e6\5,\27\2\u09e5\u09e4\3"+ + "\2\2\2\u09e5\u09e6\3\2\2\2\u09e6\u09e7\3\2\2\2\u09e7\u09e8\7!\2\2\u09e8"+ + "\u09ee\3\2\2\2\u09e9\u09ea\5 \21\2\u09ea\u09eb\7\\\2\2\u09eb\u09ec\7!"+ + "\2\2\u09ec\u09ee\3\2\2\2\u09ed\u09c5\3\2\2\2\u09ed\u09cc\3\2\2\2\u09ed"+ + "\u09d3\3\2\2\2\u09ed\u09d9\3\2\2\2\u09ed\u09e2\3\2\2\2\u09ed\u09e9\3\2"+ + "\2\2\u09ee\u0197\3\2\2\2\u09ef\u09f0\7!\2\2\u09f0\u09f1\5\6\4\2\u09f1"+ + "\u09f3\5\u019a\u00ce\2\u09f2\u09f4\5\"\22\2\u09f3\u09f2\3\2\2\2\u09f3"+ + "\u09f4\3\2\2\2\u09f4\u0a06\3\2\2\2\u09f5\u09f6\7!\2\2\u09f6\u09f7\5\20"+ + "\t\2\u09f7\u09f9\5\u019a\u00ce\2\u09f8\u09fa\5\"\22\2\u09f9\u09f8\3\2"+ + "\2\2\u09f9\u09fa\3\2\2\2\u09fa\u0a06\3\2\2\2\u09fb\u09fc\7!\2\2\u09fc"+ + "\u09fd\5\6\4\2\u09fd\u09fe\5\"\22\2\u09fe\u09ff\5\u00fa~\2\u09ff\u0a06"+ + "\3\2\2\2\u0a00\u0a01\7!\2\2\u0a01\u0a02\5\20\t\2\u0a02\u0a03\5\"\22\2"+ + "\u0a03\u0a04\5\u00fa~\2\u0a04\u0a06\3\2\2\2\u0a05\u09ef\3\2\2\2\u0a05"+ + "\u09f5\3\2\2\2\u0a05\u09fb\3\2\2\2\u0a05\u0a00\3\2\2\2\u0a06\u0199\3\2"+ + "\2\2\u0a07\u0a0b\5\u019c\u00cf\2\u0a08\u0a0a\5\u019c\u00cf\2\u0a09\u0a08"+ + "\3\2\2\2\u0a0a\u0a0d\3\2\2\2\u0a0b\u0a09\3\2\2\2\u0a0b\u0a0c\3\2\2\2\u0a0c"+ + "\u019b\3\2\2\2\u0a0d\u0a0b\3\2\2\2\u0a0e\u0a10\5\u00e8u\2\u0a0f\u0a0e"+ + "\3\2\2\2\u0a10\u0a13\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a11\u0a12\3\2\2\2\u0a12"+ + "\u0a14\3\2\2\2\u0a13\u0a11\3\2\2\2\u0a14\u0a15\7?\2\2\u0a15\u0a16\5\u01a0"+ + "\u00d1\2\u0a16\u0a17\7@\2\2\u0a17\u019d\3\2\2\2\u0a18\u0a19\5\u01a0\u00d1"+ + "\2\u0a19\u019f\3\2\2\2\u0a1a\u0a1d\5\u01a2\u00d2\2\u0a1b\u0a1d\5\u01aa"+ + "\u00d6\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1b\3\2\2\2\u0a1d\u01a1\3\2\2\2\u0a1e"+ + "\u0a1f\5\u01a4\u00d3\2\u0a1f\u0a20\7[\2\2\u0a20\u0a21\5\u01a8\u00d5\2"+ + "\u0a21\u01a3\3\2\2\2\u0a22\u0a2d\7h\2\2\u0a23\u0a25\7;\2\2\u0a24\u0a26"+ + "\5\u0098M\2\u0a25\u0a24\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\3\2\2"+ + "\2\u0a27\u0a2d\7<\2\2\u0a28\u0a29\7;\2\2\u0a29\u0a2a\5\u01a6\u00d4\2\u0a2a"+ + "\u0a2b\7<\2\2\u0a2b\u0a2d\3\2\2\2\u0a2c\u0a22\3\2\2\2\u0a2c\u0a23\3\2"+ + "\2\2\u0a2c\u0a28\3\2\2\2\u0a2d\u01a5\3\2\2\2\u0a2e\u0a33\7h\2\2\u0a2f"+ + "\u0a30\7B\2\2\u0a30\u0a32\7h\2\2\u0a31\u0a2f\3\2\2\2\u0a32\u0a35\3\2\2"+ + "\2\u0a33\u0a31\3\2\2\2\u0a33\u0a34\3\2\2\2\u0a34\u01a7\3\2\2\2\u0a35\u0a33"+ + "\3\2\2\2\u0a36\u0a39\5\u01a0\u00d1\2\u0a37\u0a39\5\u00fe\u0080\2\u0a38"+ + "\u0a36\3\2\2\2\u0a38\u0a37\3\2\2\2\u0a39\u01a9\3\2\2\2\u0a3a\u0a3d\5\u01b2"+ + "\u00da\2\u0a3b\u0a3d\5\u01ac\u00d7\2\u0a3c\u0a3a\3\2\2\2\u0a3c\u0a3b\3"+ + "\2\2\2\u0a3d\u01ab\3\2\2\2\u0a3e\u0a3f\5\u01ae\u00d8\2\u0a3f\u0a40\5\u01b0"+ + "\u00d9\2\u0a40\u0a41\5\u01a0\u00d1\2\u0a41\u01ad\3\2\2\2\u0a42\u0a46\5"+ + "<\37\2\u0a43\u0a46\5\u017e\u00c0\2\u0a44\u0a46\5\u0184\u00c3\2\u0a45\u0a42"+ + "\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a44\3\2\2\2\u0a46\u01af\3\2\2\2\u0a47"+ + "\u0a48\t\5\2\2\u0a48\u01b1\3\2\2\2\u0a49\u0a51\5\u01b4\u00db\2\u0a4a\u0a4b"+ + "\5\u01b4\u00db\2\u0a4b\u0a4c\7I\2\2\u0a4c\u0a4d\5\u01a0\u00d1\2\u0a4d"+ + "\u0a4e\7J\2\2\u0a4e\u0a4f\5\u01b2\u00da\2\u0a4f\u0a51\3\2\2\2\u0a50\u0a49"+ + "\3\2\2\2\u0a50\u0a4a\3\2\2\2\u0a51\u01b3\3\2\2\2\u0a52\u0a53\b\u00db\1"+ + "\2\u0a53\u0a54\5\u01b6\u00dc\2\u0a54\u0a5a\3\2\2\2\u0a55\u0a56\f\3\2\2"+ + "\u0a56\u0a57\7P\2\2\u0a57\u0a59\5\u01b6\u00dc\2\u0a58\u0a55\3\2\2\2\u0a59"+ + "\u0a5c\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5a\u0a5b\3\2\2\2\u0a5b\u01b5\3\2"+ + "\2\2\u0a5c\u0a5a\3\2\2\2\u0a5d\u0a5e\b\u00dc\1\2\u0a5e\u0a5f\5\u01b8\u00dd"+ + "\2\u0a5f\u0a65\3\2\2\2\u0a60\u0a61\f\3\2\2\u0a61\u0a62\7O\2\2\u0a62\u0a64"+ + "\5\u01b8\u00dd\2\u0a63\u0a60\3\2\2\2\u0a64\u0a67\3\2\2\2\u0a65\u0a63\3"+ + "\2\2\2\u0a65\u0a66\3\2\2\2\u0a66\u01b7\3\2\2\2\u0a67\u0a65\3\2\2\2\u0a68"+ + "\u0a69\b\u00dd\1\2\u0a69\u0a6a\5\u01ba\u00de\2\u0a6a\u0a70\3\2\2\2\u0a6b"+ + "\u0a6c\f\3\2\2\u0a6c\u0a6d\7X\2\2\u0a6d\u0a6f\5\u01ba\u00de\2\u0a6e\u0a6b"+ + "\3\2\2\2\u0a6f\u0a72\3\2\2\2\u0a70\u0a6e\3\2\2\2\u0a70\u0a71\3\2\2\2\u0a71"+ + "\u01b9\3\2\2\2\u0a72\u0a70\3\2\2\2\u0a73\u0a74\b\u00de\1\2\u0a74\u0a75"+ + "\5\u01bc\u00df\2\u0a75\u0a7b\3\2\2\2\u0a76\u0a77\f\3\2\2\u0a77\u0a78\7"+ + "Y\2\2\u0a78\u0a7a\5\u01bc\u00df\2\u0a79\u0a76\3\2\2\2\u0a7a\u0a7d\3\2"+ + "\2\2\u0a7b\u0a79\3\2\2\2\u0a7b\u0a7c\3\2\2\2\u0a7c\u01bb\3\2\2\2\u0a7d"+ + "\u0a7b\3\2\2\2\u0a7e\u0a7f\b\u00df\1\2\u0a7f\u0a80\5\u01be\u00e0\2\u0a80"+ + "\u0a86\3\2\2\2\u0a81\u0a82\f\3\2\2\u0a82\u0a83\7W\2\2\u0a83\u0a85\5\u01be"+ + "\u00e0\2\u0a84\u0a81\3\2\2\2\u0a85\u0a88\3\2\2\2\u0a86\u0a84\3\2\2\2\u0a86"+ + "\u0a87\3\2\2\2\u0a87\u01bd\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a89\u0a8a\b\u00e0"+ + "\1\2\u0a8a\u0a8b\5\u01c0\u00e1\2\u0a8b\u0a94\3\2\2\2\u0a8c\u0a8d\f\4\2"+ + "\2\u0a8d\u0a8e\7K\2\2\u0a8e\u0a93\5\u01c0\u00e1\2\u0a8f\u0a90\f\3\2\2"+ + "\u0a90\u0a91\7N\2\2\u0a91\u0a93\5\u01c0\u00e1\2\u0a92\u0a8c\3\2\2\2\u0a92"+ + "\u0a8f\3\2\2\2\u0a93\u0a96\3\2\2\2\u0a94\u0a92\3\2\2\2\u0a94\u0a95\3\2"+ + "\2\2\u0a95\u01bf\3\2\2\2\u0a96\u0a94\3\2\2\2\u0a97\u0a98\b\u00e1\1\2\u0a98"+ + "\u0a99\5\u01c2\u00e2\2\u0a99\u0aab\3\2\2\2\u0a9a\u0a9b\f\7\2\2\u0a9b\u0a9c"+ + "\7F\2\2\u0a9c\u0aaa\5\u01c2\u00e2\2\u0a9d\u0a9e\f\6\2\2\u0a9e\u0a9f\7"+ + "E\2\2\u0a9f\u0aaa\5\u01c2\u00e2\2\u0aa0\u0aa1\f\5\2\2\u0aa1\u0aa2\7L\2"+ + "\2\u0aa2\u0aaa\5\u01c2\u00e2\2\u0aa3\u0aa4\f\4\2\2\u0aa4\u0aa5\7M\2\2"+ + "\u0aa5\u0aaa\5\u01c2\u00e2\2\u0aa6\u0aa7\f\3\2\2\u0aa7\u0aa8\7\34\2\2"+ + "\u0aa8\u0aaa\5\16\b\2\u0aa9\u0a9a\3\2\2\2\u0aa9\u0a9d\3\2\2\2\u0aa9\u0aa0"+ + "\3\2\2\2\u0aa9\u0aa3\3\2\2\2\u0aa9\u0aa6\3\2\2\2\u0aaa\u0aad\3\2\2\2\u0aab"+ + "\u0aa9\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u01c1\3\2\2\2\u0aad\u0aab\3\2"+ + "\2\2\u0aae\u0aaf\b\u00e2\1\2\u0aaf\u0ab0\5\u01c4\u00e3\2\u0ab0\u0ac0\3"+ + "\2\2\2\u0ab1\u0ab2\f\5\2\2\u0ab2\u0ab3\7F\2\2\u0ab3\u0ab4\7F\2\2\u0ab4"+ + "\u0abf\5\u01c4\u00e3\2\u0ab5\u0ab6\f\4\2\2\u0ab6\u0ab7\7E\2\2\u0ab7\u0ab8"+ + "\7E\2\2\u0ab8\u0abf\5\u01c4\u00e3\2\u0ab9\u0aba\f\3\2\2\u0aba\u0abb\7"+ + "E\2\2\u0abb\u0abc\7E\2\2\u0abc\u0abd\7E\2\2\u0abd\u0abf\5\u01c4\u00e3"+ + "\2\u0abe\u0ab1\3\2\2\2\u0abe\u0ab5\3\2\2\2\u0abe\u0ab9\3\2\2\2\u0abf\u0ac2"+ + "\3\2\2\2\u0ac0\u0abe\3\2\2\2\u0ac0\u0ac1\3\2\2\2\u0ac1\u01c3\3\2\2\2\u0ac2"+ + "\u0ac0\3\2\2\2\u0ac3\u0ac4\b\u00e3\1\2\u0ac4\u0ac5\5\u01c6\u00e4\2\u0ac5"+ + "\u0ace\3\2\2\2\u0ac6\u0ac7\f\4\2\2\u0ac7\u0ac8\7S\2\2\u0ac8\u0acd\5\u01c6"+ + "\u00e4\2\u0ac9\u0aca\f\3\2\2\u0aca\u0acb\7T\2\2\u0acb\u0acd\5\u01c6\u00e4"+ + "\2\u0acc\u0ac6\3\2\2\2\u0acc\u0ac9\3\2\2\2\u0acd\u0ad0\3\2\2\2\u0ace\u0acc"+ + "\3\2\2\2\u0ace\u0acf\3\2\2\2\u0acf\u01c5\3\2\2\2\u0ad0\u0ace\3\2\2\2\u0ad1"+ + "\u0ad2\b\u00e4\1\2\u0ad2\u0ad3\5\u01c8\u00e5\2\u0ad3\u0adf\3\2\2\2\u0ad4"+ + "\u0ad5\f\5\2\2\u0ad5\u0ad6\7U\2\2\u0ad6\u0ade\5\u01c8\u00e5\2\u0ad7\u0ad8"+ + "\f\4\2\2\u0ad8\u0ad9\7V\2\2\u0ad9\u0ade\5\u01c8\u00e5\2\u0ada\u0adb\f"+ + "\3\2\2\u0adb\u0adc\7Z\2\2\u0adc\u0ade\5\u01c8\u00e5\2\u0add\u0ad4\3\2"+ + "\2\2\u0add\u0ad7\3\2\2\2\u0add\u0ada\3\2\2\2\u0ade\u0ae1\3\2\2\2\u0adf"+ + "\u0add\3\2\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u01c7\3\2\2\2\u0ae1\u0adf\3\2"+ + "\2\2\u0ae2\u0aea\5\u01ca\u00e6\2\u0ae3\u0aea\5\u01cc\u00e7\2\u0ae4\u0ae5"+ + "\7S\2\2\u0ae5\u0aea\5\u01c8\u00e5\2\u0ae6\u0ae7\7T\2\2\u0ae7\u0aea\5\u01c8"+ + "\u00e5\2\u0ae8\u0aea\5\u01ce\u00e8\2\u0ae9\u0ae2\3\2\2\2\u0ae9\u0ae3\3"+ + "\2\2\2\u0ae9\u0ae4\3\2\2\2\u0ae9\u0ae6\3\2\2\2\u0ae9\u0ae8\3\2\2\2\u0aea"+ + "\u01c9\3\2\2\2\u0aeb\u0aec\7Q\2\2\u0aec\u0aed\5\u01c8\u00e5\2\u0aed\u01cb"+ + "\3\2\2\2\u0aee\u0aef\7R\2\2\u0aef\u0af0\5\u01c8\u00e5\2\u0af0\u01cd\3"+ + "\2\2\2\u0af1\u0af8\5\u01d0\u00e9\2\u0af2\u0af3\7H\2\2\u0af3\u0af8\5\u01c8"+ + "\u00e5\2\u0af4\u0af5\7G\2\2\u0af5\u0af8\5\u01c8\u00e5\2\u0af6\u0af8\5"+ + "\u01da\u00ee\2\u0af7\u0af1\3\2\2\2\u0af7\u0af2\3\2\2\2\u0af7\u0af4\3\2"+ + "\2\2\u0af7\u0af6\3\2\2\2\u0af8\u01cf\3\2\2\2\u0af9\u0afc\5\u0162\u00b2"+ + "\2\u0afa\u0afc\5<\37\2\u0afb\u0af9\3\2\2\2\u0afb\u0afa\3\2\2\2\u0afc\u0b01"+ + "\3\2\2\2\u0afd\u0b00\5\u01d4\u00eb\2\u0afe\u0b00\5\u01d8\u00ed\2\u0aff"+ + "\u0afd\3\2\2\2\u0aff\u0afe\3\2\2\2\u0b00\u0b03\3\2\2\2\u0b01\u0aff\3\2"+ + "\2\2\u0b01\u0b02\3\2\2\2\u0b02\u01d1\3\2\2\2\u0b03\u0b01\3\2\2\2\u0b04"+ + "\u0b05\5\u01d0\u00e9\2\u0b05\u0b06\7Q\2\2\u0b06\u01d3\3\2\2\2\u0b07\u0b08"+ + "\7Q\2\2\u0b08\u01d5\3\2\2\2\u0b09\u0b0a\5\u01d0\u00e9\2\u0b0a\u0b0b\7"+ + "R\2\2\u0b0b\u01d7\3\2\2\2\u0b0c\u0b0d\7R\2\2\u0b0d\u01d9\3\2\2\2\u0b0e"+ + "\u0b0f\7;\2\2\u0b0f\u0b10\5\6\4\2\u0b10\u0b11\7<\2\2\u0b11\u0b12\5\u01c8"+ + "\u00e5\2\u0b12\u0b2a\3\2\2\2\u0b13\u0b14\7;\2\2\u0b14\u0b18\5\16\b\2\u0b15"+ + "\u0b17\5*\26\2\u0b16\u0b15\3\2\2\2\u0b17\u0b1a\3\2\2\2\u0b18\u0b16\3\2"+ + "\2\2\u0b18\u0b19\3\2\2\2\u0b19\u0b1b\3\2\2\2\u0b1a\u0b18\3\2\2\2\u0b1b"+ + "\u0b1c\7<\2\2\u0b1c\u0b1d\5\u01ce\u00e8\2\u0b1d\u0b2a\3\2\2\2\u0b1e\u0b1f"+ + "\7;\2\2\u0b1f\u0b23\5\16\b\2\u0b20\u0b22\5*\26\2\u0b21\u0b20\3\2\2\2\u0b22"+ + "\u0b25\3\2\2\2\u0b23\u0b21\3\2\2\2\u0b23\u0b24\3\2\2\2\u0b24\u0b26\3\2"+ + "\2\2\u0b25\u0b23\3\2\2\2\u0b26\u0b27\7<\2\2\u0b27\u0b28\5\u01a2\u00d2"+ + "\2\u0b28\u0b2a\3\2\2\2\u0b29\u0b0e\3\2\2\2\u0b29\u0b13\3\2\2\2\u0b29\u0b1e"+ + "\3\2\2\2\u0b2a\u01db\3\2\2\2\u0146\u01e0\u01e5\u01ec\u01f0\u01f4\u01fd"+ + "\u0201\u0205\u0207\u020d\u0212\u0219\u021e\u0220\u0226\u022b\u0230\u0235"+ + "\u0240\u024e\u0253\u025b\u0262\u0268\u026d\u0278\u027b\u0289\u028e\u0293"+ + "\u0298\u029e\u02a8\u02b0\u02ba\u02c2\u02ce\u02d2\u02d7\u02dd\u02e5\u02ee"+ + "\u02f9\u0316\u031a\u031f\u0325\u0328\u032b\u0337\u0342\u0350\u0357\u0360"+ + "\u0367\u036c\u037b\u0382\u0388\u038c\u0390\u0394\u0398\u039d\u03a1\u03a5"+ + "\u03a7\u03ac\u03b3\u03b8\u03ba\u03c0\u03c5\u03c9\u03dc\u03e1\u03f1\u03f6"+ + "\u03fc\u0402\u0404\u0408\u040d\u0411\u0418\u041f\u0427\u042a\u042f\u0437"+ + "\u043c\u0443\u044a\u044f\u0455\u0461\u0466\u046a\u0474\u0479\u0481\u0484"+ + "\u0489\u0491\u0494\u0499\u049e\u04a3\u04a8\u04af\u04b4\u04bc\u04c1\u04c6"+ + "\u04cb\u04d1\u04d7\u04da\u04dd\u04e6\u04ec\u04f2\u04f5\u04f8\u0500\u0505"+ + "\u050a\u0510\u0513\u051e\u0527\u0531\u0536\u0541\u0546\u0552\u0557\u0563"+ + "\u056d\u0572\u057a\u057d\u0584\u058c\u0592\u059b\u05a5\u05a9\u05ac\u05b5"+ + "\u05c3\u05c6\u05cf\u05d4\u05dc\u05e2\u05ea\u05f6\u05fd\u060b\u0621\u0643"+ + "\u064f\u0655\u0661\u066e\u0688\u068c\u0691\u0695\u0699\u06a1\u06a5\u06a9"+ + "\u06b0\u06b9\u06c1\u06d0\u06dc\u06e2\u06e8\u06fd\u0702\u0708\u0714\u071f"+ + "\u0729\u072c\u0731\u073a\u0740\u074a\u074f\u0758\u076f\u0779\u078f\u0796"+ + "\u079e\u07a6\u07b1\u07c8\u07d2\u07dd\u07f3\u07f7\u07fc\u0804\u080a\u080e"+ + "\u0812\u0816\u081c\u0821\u0826\u082a\u082e\u0834\u0839\u083e\u0842\u0846"+ + "\u0848\u084d\u0852\u0857\u085b\u085f\u0863\u0868\u0870\u0876\u087a\u087e"+ + "\u0882\u0888\u088d\u0892\u0896\u089a\u089c\u08a1\u08b0\u08be\u08ca\u08d3"+ + "\u08e2\u08ef\u08f8\u08fe\u0905\u090a\u0911\u0916\u091d\u0922\u0929\u092e"+ + "\u0936\u093b\u093f\u0943\u0948\u094f\u0956\u095b\u0962\u0967\u096e\u0973"+ + "\u097b\u0980\u0984\u098b\u0991\u0998\u099f\u09a6\u09ae\u09b5\u09bd\u09c1"+ + "\u09c8\u09cf\u09d6\u09de\u09e5\u09ed\u09f3\u09f9\u0a05\u0a0b\u0a11\u0a1c"+ + "\u0a25\u0a2c\u0a33\u0a38\u0a3c\u0a45\u0a50\u0a5a\u0a65\u0a70\u0a7b\u0a86"+ + "\u0a92\u0a94\u0aa9\u0aab\u0abe\u0ac0\u0acc\u0ace\u0add\u0adf\u0ae9\u0af7"+ + "\u0afb\u0aff\u0b01\u0b18\u0b23\u0b29"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/antlr4/Java8Visitor.java b/i18n-maven-plugin/src/main/antlr4/Java8Visitor.java new file mode 100644 index 0000000..827a9d4 --- /dev/null +++ b/i18n-maven-plugin/src/main/antlr4/Java8Visitor.java @@ -0,0 +1,1434 @@ +// Generated from ../projets/nuiton-all/i18n/i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link Java8Parser}. + * + * @param <T> The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface Java8Visitor<T> extends ParseTreeVisitor<T> { + /** + * Visit a parse tree produced by {@link Java8Parser#literal}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(Java8Parser.LiteralContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#type}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitType(Java8Parser.TypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimitiveType(Java8Parser.PrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#numericType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNumericType(Java8Parser.NumericTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#integralType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIntegralType(Java8Parser.IntegralTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#floatingPointType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFloatingPointType(Java8Parser.FloatingPointTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#referenceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReferenceType(Java8Parser.ReferenceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceType(Java8Parser.ClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType(Java8Parser.ClassTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType_lf_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType_lf_classOrInterfaceType(Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType_lfno_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType_lfno_classOrInterfaceType(Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType(Java8Parser.InterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType_lf_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType_lf_classOrInterfaceType(Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType_lfno_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType_lfno_classOrInterfaceType(Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeVariable}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeVariable(Java8Parser.TypeVariableContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayType(Java8Parser.ArrayTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dims}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDims(Java8Parser.DimsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(Java8Parser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameterModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterModifier(Java8Parser.TypeParameterModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeBound(Java8Parser.TypeBoundContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#additionalBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditionalBound(Java8Parser.AdditionalBoundContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(Java8Parser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentList(Java8Parser.TypeArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgument(Java8Parser.TypeArgumentContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#wildcard}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWildcard(Java8Parser.WildcardContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#wildcardBounds}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWildcardBounds(Java8Parser.WildcardBoundsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageName(Java8Parser.PackageNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeName(Java8Parser.TypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageOrTypeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageOrTypeName(Java8Parser.PackageOrTypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expressionName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionName(Java8Parser.ExpressionNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodName(Java8Parser.MethodNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ambiguousName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAmbiguousName(Java8Parser.AmbiguousNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#compilationUnit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompilationUnit(Java8Parser.CompilationUnitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageDeclaration(Java8Parser.PackageDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageModifier(Java8Parser.PackageModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#importDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportDeclaration(Java8Parser.ImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleTypeImportDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeImportOnDemandDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleStaticImportDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#staticImportOnDemandDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeDeclaration(Java8Parser.TypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(Java8Parser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalClassDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalClassDeclaration(Java8Parser.NormalClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassModifier(Java8Parser.ClassModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(Java8Parser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterList(Java8Parser.TypeParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#superclass}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperclass(Java8Parser.SuperclassContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#superinterfaces}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperinterfaces(Java8Parser.SuperinterfacesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceTypeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceTypeList(Java8Parser.InterfaceTypeListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBody(Java8Parser.ClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBodyDeclaration(Java8Parser.ClassBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassMemberDeclaration(Java8Parser.ClassMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldDeclaration(Java8Parser.FieldDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldModifier(Java8Parser.FieldModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorList(Java8Parser.VariableDeclaratorListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarator(Java8Parser.VariableDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorId}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorId(Java8Parser.VariableDeclaratorIdContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializer(Java8Parser.VariableInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannType(Java8Parser.UnannTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannPrimitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannPrimitiveType(Java8Parser.UnannPrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannReferenceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannReferenceType(Java8Parser.UnannReferenceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassOrInterfaceType(Java8Parser.UnannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType(Java8Parser.UnannClassTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType_lf_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType_lf_unannClassOrInterfaceType(Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType_lfno_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType_lfno_unannClassOrInterfaceType(Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType(Java8Parser.UnannInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lf_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType_lf_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lfno_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannTypeVariable}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannTypeVariable(Java8Parser.UnannTypeVariableContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannArrayType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannArrayType(Java8Parser.UnannArrayTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclaration(Java8Parser.MethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodModifier(Java8Parser.MethodModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodHeader}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodHeader(Java8Parser.MethodHeaderContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#result}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResult(Java8Parser.ResultContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclarator(Java8Parser.MethodDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterList(Java8Parser.FormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameters(Java8Parser.FormalParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameter(Java8Parser.FormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableModifier(Java8Parser.VariableModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lastFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLastFormalParameter(Java8Parser.LastFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#receiverParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReceiverParameter(Java8Parser.ReceiverParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#throws_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrows_(Java8Parser.Throws_Context ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exceptionTypeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionTypeList(Java8Parser.ExceptionTypeListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exceptionType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionType(Java8Parser.ExceptionTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodBody(Java8Parser.MethodBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#instanceInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInstanceInitializer(Java8Parser.InstanceInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#staticInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStaticInitializer(Java8Parser.StaticInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclaration(Java8Parser.ConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorModifier(Java8Parser.ConstructorModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclarator(Java8Parser.ConstructorDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#simpleTypeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTypeName(Java8Parser.SimpleTypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorBody(Java8Parser.ConstructorBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#explicitConstructorInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitConstructorInvocation(Java8Parser.ExplicitConstructorInvocationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumDeclaration(Java8Parser.EnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBody(Java8Parser.EnumBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantList(Java8Parser.EnumConstantListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstant}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstant(Java8Parser.EnumConstantContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantModifier(Java8Parser.EnumConstantModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumBodyDeclarations}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBodyDeclarations(Java8Parser.EnumBodyDeclarationsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceDeclaration(Java8Parser.InterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalInterfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalInterfaceDeclaration(Java8Parser.NormalInterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceModifier(Java8Parser.InterfaceModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#extendsInterfaces}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExtendsInterfaces(Java8Parser.ExtendsInterfacesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBody(Java8Parser.InterfaceBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMemberDeclaration(Java8Parser.InterfaceMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantDeclaration(Java8Parser.ConstantDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantModifier(Java8Parser.ConstantModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodDeclaration(Java8Parser.InterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMethodModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodModifier(Java8Parser.InterfaceMethodModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeDeclaration(Java8Parser.AnnotationTypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeBody(Java8Parser.AnnotationTypeBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeMemberDeclaration(Java8Parser.AnnotationTypeMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementDeclaration(Java8Parser.AnnotationTypeElementDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementModifier(Java8Parser.AnnotationTypeElementModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#defaultValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDefaultValue(Java8Parser.DefaultValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotation(Java8Parser.AnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalAnnotation(Java8Parser.NormalAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePairList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePairList(Java8Parser.ElementValuePairListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePair}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePair(Java8Parser.ElementValuePairContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValue(Java8Parser.ElementValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValueArrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueArrayInitializer(Java8Parser.ElementValueArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValueList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueList(Java8Parser.ElementValueListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#markerAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMarkerAnnotation(Java8Parser.MarkerAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleElementAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleElementAnnotation(Java8Parser.SingleElementAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayInitializer(Java8Parser.ArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableInitializerList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializerList(Java8Parser.VariableInitializerListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#block}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(Java8Parser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#blockStatements}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatements(Java8Parser.BlockStatementsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#blockStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatement(Java8Parser.BlockStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclarationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclarationStatement(Java8Parser.LocalVariableDeclarationStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclaration(Java8Parser.LocalVariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(Java8Parser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementNoShortIf(Java8Parser.StatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementWithoutTrailingSubstatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementWithoutTrailingSubstatement(Java8Parser.StatementWithoutTrailingSubstatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#emptyStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEmptyStatement(Java8Parser.EmptyStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#labeledStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabeledStatement(Java8Parser.LabeledStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#labeledStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabeledStatementNoShortIf(Java8Parser.LabeledStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expressionStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionStatement(Java8Parser.ExpressionStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementExpression(Java8Parser.StatementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenStatement(Java8Parser.IfThenStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenElseStatement(Java8Parser.IfThenElseStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenElseStatementNoShortIf(Java8Parser.IfThenElseStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assertStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssertStatement(Java8Parser.AssertStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchStatement(Java8Parser.SwitchStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlock(Java8Parser.SwitchBlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchBlockStatementGroup}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlockStatementGroup(Java8Parser.SwitchBlockStatementGroupContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchLabels}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabels(Java8Parser.SwitchLabelsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchLabel}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabel(Java8Parser.SwitchLabelContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantName(Java8Parser.EnumConstantNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#whileStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatement(Java8Parser.WhileStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#whileStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatementNoShortIf(Java8Parser.WhileStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#doStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDoStatement(Java8Parser.DoStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatement(Java8Parser.ForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatementNoShortIf(Java8Parser.ForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#basicForStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBasicForStatement(Java8Parser.BasicForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#basicForStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBasicForStatementNoShortIf(Java8Parser.BasicForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forInit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInit(Java8Parser.ForInitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forUpdate}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForUpdate(Java8Parser.ForUpdateContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementExpressionList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementExpressionList(Java8Parser.StatementExpressionListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enhancedForStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForStatement(Java8Parser.EnhancedForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enhancedForStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForStatementNoShortIf(Java8Parser.EnhancedForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#breakStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBreakStatement(Java8Parser.BreakStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#continueStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitContinueStatement(Java8Parser.ContinueStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#returnStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReturnStatement(Java8Parser.ReturnStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#throwStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrowStatement(Java8Parser.ThrowStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#synchronizedStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSynchronizedStatement(Java8Parser.SynchronizedStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#tryStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryStatement(Java8Parser.TryStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catches}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatches(Java8Parser.CatchesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchClause(Java8Parser.CatchClauseContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchFormalParameter(Java8Parser.CatchFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchType(Java8Parser.CatchTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#finally_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinally_(Java8Parser.Finally_Context ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#tryWithResourcesStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryWithResourcesStatement(Java8Parser.TryWithResourcesStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resourceSpecification}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceSpecification(Java8Parser.ResourceSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resourceList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceList(Java8Parser.ResourceListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resource}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResource(Java8Parser.ResourceContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimary(Java8Parser.PrimaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray(Java8Parser.PrimaryNoNewArrayContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_arrayAccess(Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_arrayAccess(Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression(Java8Parser.ClassInstanceCreationExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression_lf_primary(Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression_lfno_primary(Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentsOrDiamond(Java8Parser.TypeArgumentsOrDiamondContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess(Java8Parser.FieldAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess_lf_primary(Java8Parser.FieldAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess_lfno_primary(Java8Parser.FieldAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess(Java8Parser.ArrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess_lf_primary(Java8Parser.ArrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess_lfno_primary(Java8Parser.ArrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation(Java8Parser.MethodInvocationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation_lf_primary(Java8Parser.MethodInvocation_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation_lfno_primary(Java8Parser.MethodInvocation_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#argumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArgumentList(Java8Parser.ArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference(Java8Parser.MethodReferenceContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference_lf_primary(Java8Parser.MethodReference_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference_lfno_primary(Java8Parser.MethodReference_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayCreationExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayCreationExpression(Java8Parser.ArrayCreationExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dimExprs}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDimExprs(Java8Parser.DimExprsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dimExpr}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDimExpr(Java8Parser.DimExprContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantExpression(Java8Parser.ConstantExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(Java8Parser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaExpression(Java8Parser.LambdaExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaParameters(Java8Parser.LambdaParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#inferredFormalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInferredFormalParameterList(Java8Parser.InferredFormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaBody(Java8Parser.LambdaBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignmentExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentExpression(Java8Parser.AssignmentExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignment(Java8Parser.AssignmentContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#leftHandSide}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLeftHandSide(Java8Parser.LeftHandSideContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignmentOperator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentOperator(Java8Parser.AssignmentOperatorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalExpression(Java8Parser.ConditionalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalOrExpression(Java8Parser.ConditionalOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalAndExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalAndExpression(Java8Parser.ConditionalAndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#inclusiveOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInclusiveOrExpression(Java8Parser.InclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exclusiveOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExclusiveOrExpression(Java8Parser.ExclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#andExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAndExpression(Java8Parser.AndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#equalityExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEqualityExpression(Java8Parser.EqualityExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#relationalExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRelationalExpression(Java8Parser.RelationalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#shiftExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitShiftExpression(Java8Parser.ShiftExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#additiveExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveExpression(Java8Parser.AdditiveExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#multiplicativeExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeExpression(Java8Parser.MultiplicativeExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unaryExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryExpression(Java8Parser.UnaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#preIncrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreIncrementExpression(Java8Parser.PreIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#preDecrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreDecrementExpression(Java8Parser.PreDecrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unaryExpressionNotPlusMinus}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryExpressionNotPlusMinus(Java8Parser.UnaryExpressionNotPlusMinusContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixExpression(Java8Parser.PostfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostIncrementExpression(Java8Parser.PostIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression_lf_postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostIncrementExpression_lf_postfixExpression(Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostDecrementExpression(Java8Parser.PostDecrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression_lf_postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostDecrementExpression_lf_postfixExpression(Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#castExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCastExpression(Java8Parser.CastExpressionContext ctx); +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java index 5fa9511..c8cc546 100644 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java @@ -5,7 +5,7 @@ * $Id$ * $HeadURL$ * %% - * Copyright (C) 2011 CodeLutin, Tony Chemit + * Copyright (C) 2011 - 2016 CodeLutin, Tony Chemit * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -27,7 +27,6 @@ package org.nuiton.i18n.plugin.parser.impl; import org.antlr.v4.runtime.ANTLRInputStream; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.misc.NotNull; import org.antlr.v4.runtime.tree.ParseTree; import org.apache.commons.io.IOUtils; import org.apache.maven.plugin.logging.Log; @@ -40,9 +39,9 @@ import org.nuiton.i18n.plugin.parser.FileParser; import org.nuiton.i18n.plugin.parser.I18nSourceEntry; import org.nuiton.i18n.plugin.parser.ParserException; import org.nuiton.i18n.plugin.parser.SourceEntry; -import org.nuiton.i18n.plugin.parser.java.JavaBaseVisitor; -import org.nuiton.i18n.plugin.parser.java.JavaLexer; -import org.nuiton.i18n.plugin.parser.java.JavaParser; +import org.nuiton.i18n.plugin.parser.java.Java8BaseVisitor; +import org.nuiton.i18n.plugin.parser.java.Java8Lexer; +import org.nuiton.i18n.plugin.parser.java.Java8Parser; import org.nuiton.io.FileUpdater; import org.nuiton.io.MirroredFileUpdater; import org.nuiton.io.SortedProperties; @@ -198,10 +197,10 @@ public class ParserGWTJavaMojo extends AbstractI18nParserMojo { Reader inputStream = new InputStreamReader(new FileInputStream(file), "UTF-8"); try { // parse the file - TokenStream tokenStream = new CommonTokenStream(new JavaLexer(new ANTLRInputStream(inputStream))); - JavaParser parser = new JavaParser(tokenStream); + TokenStream tokenStream = new CommonTokenStream(new Java8Lexer(new ANTLRInputStream(inputStream))); + Java8Parser parser = new Java8Parser(tokenStream); - JavaParser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); + Java8Parser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); compilationUnitContext.accept(new JavaParserVisitor(file)); inputStream.close(); } catch (Exception e) { @@ -215,7 +214,7 @@ public class ParserGWTJavaMojo extends AbstractI18nParserMojo { public void parseLine(File file, String line) throws IOException { } - protected class JavaParserVisitor extends JavaBaseVisitor<Void> { + protected class JavaParserVisitor extends Java8BaseVisitor<Void> { protected final Set<String> annotationPrefix; @@ -230,7 +229,7 @@ public class ParserGWTJavaMojo extends AbstractI18nParserMojo { } @Override - public Void visitAnnotation(@NotNull JavaParser.AnnotationContext ctx) { + public Void visitAnnotation(Java8Parser.AnnotationContext ctx) { boolean match = false; if (ctx.getChildCount() > 3) { ParseTree child = ctx.getChild(1); diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java index ce65c6b..9253d78 100755 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java @@ -5,7 +5,7 @@ * $Id$ * $HeadURL$ * %% - * Copyright (C) 2007 - 2010 CodeLutin, Tony Chemit + * Copyright (C) 2007 - 2016 CodeLutin, Tony Chemit * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -25,11 +25,16 @@ package org.nuiton.i18n.plugin.parser.impl; +import java.io.File; +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; +import java.util.regex.Pattern; + import org.antlr.v4.runtime.ANTLRInputStream; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.ParseTree; +import org.antlr.v4.runtime.tree.TerminalNode; import org.apache.commons.io.FileUtils; import org.apache.maven.plugin.logging.Log; import org.apache.maven.plugins.annotations.LifecyclePhase; @@ -41,19 +46,21 @@ import org.nuiton.i18n.plugin.parser.FileParser; import org.nuiton.i18n.plugin.parser.I18nSourceEntry; import org.nuiton.i18n.plugin.parser.ParserException; import org.nuiton.i18n.plugin.parser.SourceEntry; -import org.nuiton.i18n.plugin.parser.java.JavaBaseVisitor; -import org.nuiton.i18n.plugin.parser.java.JavaLexer; -import org.nuiton.i18n.plugin.parser.java.JavaParser; +import org.nuiton.i18n.plugin.parser.java.Java8BaseVisitor; +import org.nuiton.i18n.plugin.parser.java.Java8Lexer; +import org.nuiton.i18n.plugin.parser.java.Java8Parser; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.ArgumentListContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.ExpressionContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.LambdaBodyContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.LambdaExpressionContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.MethodInvocationContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.MethodInvocation_lfno_primaryContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.MethodNameContext; +import org.nuiton.i18n.plugin.parser.java.Java8Parser.TypeNameContext; import org.nuiton.io.FileUpdater; import org.nuiton.io.FileUpdaterHelper; import org.nuiton.io.SortedProperties; -import java.io.File; -import java.io.IOException; -import java.util.HashSet; -import java.util.Set; -import java.util.regex.Pattern; - /** * To parse java files to detect new i18n keys. * <p/> @@ -146,10 +153,10 @@ public class ParserJavaMojo extends AbstractI18nParserMojo { try { - TokenStream tokenStream = new CommonTokenStream(new JavaLexer(new ANTLRInputStream(content))); - JavaParser parser = new JavaParser(tokenStream); + TokenStream tokenStream = new CommonTokenStream(new Java8Lexer(new ANTLRInputStream(content))); + Java8Parser parser = new Java8Parser(tokenStream); - JavaParser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); + Java8Parser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); compilationUnitContext.accept(new JavaParserVisitor(file)); } catch (Exception e) { @@ -163,7 +170,7 @@ public class ParserJavaMojo extends AbstractI18nParserMojo { public void parseLine(File file, String line) throws IOException { } - protected class JavaParserVisitor extends JavaBaseVisitor<Void> { + protected class JavaParserVisitor extends Java8BaseVisitor<Void> { protected final Set<String> simpleI18nMethodPrefix; @@ -186,22 +193,16 @@ public class ParserJavaMojo extends AbstractI18nParserMojo { complexI18nMethodPrefix.add("l"); } - @Override - public Void visitStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx) { - return super.visitStatementExpression(ctx); - } - - @Override - public Void visitExpression(@NotNull JavaParser.ExpressionContext ctx) { + /*@Override + public Void visitExpression(Java8Parser.ExpressionContext ctx) { boolean match = false; - if (ctx.getChildCount() > 2 && ctx.getChild(2) instanceof JavaParser.ExpressionListContext) { + if (ctx.getChildCount() > 2 && ctx.getChild(2) instanceof Java8Parser.ExpressionContext) { ParseTree child = ctx.getChild(0); String childText = child.getText(); if (simpleI18nMethodPrefix.contains(childText)) { - // key is argument 1 of child 2 - JavaParser.ExpressionListContext arguments = (JavaParser.ExpressionListContext) ctx.getChild(2); + Java8Parser.ExpressionContext arguments = (Java8Parser.ExpressionContext) ctx.getChild(2); String firstArgs = arguments.getChild(0).getText(); if (firstArgs.matches("^\"[^\"]+\"$")) { String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); @@ -214,7 +215,7 @@ public class ParserJavaMojo extends AbstractI18nParserMojo { } else if (complexI18nMethodPrefix.contains(childText)) { // key is argument 2 of child 2 - JavaParser.ExpressionListContext arguments = (JavaParser.ExpressionListContext) ctx.getChild(2); + Java8Parser.ExpressionContext arguments = (Java8Parser.ExpressionContext) ctx.getChild(2); String firstArgs = arguments.getChild(2).getText(); if (firstArgs.matches("^\"[^\"]+\"$")) { String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); @@ -232,9 +233,54 @@ public class ParserJavaMojo extends AbstractI18nParserMojo { aVoid = super.visitExpression(ctx); } return aVoid; + }*/ + + @Override + public Void visitMethodInvocation_lfno_primary(MethodInvocation_lfno_primaryContext ctx) { + + ArgumentListContext list = ctx.argumentList(); + MethodNameContext mnc = ctx.methodName(); + TerminalNode tn = ctx.Identifier(); + TypeNameContext tnc = ctx.typeName(); + + String methodName = mnc != null ? mnc.getText() : + tnc.getText() + "." + tn.getText(); + + boolean match = false; + if (simpleI18nMethodPrefix.contains(methodName)) { + // key is argument 1 of child 2 + ExpressionContext argument = list.expression(0); + String firstArgs = argument.getText(); + if (firstArgs.matches("^\"[^\"]+\"$")) { + String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); + if (getLog().isDebugEnabled()) { + getLog().debug(file.getName() + " detected key = " + key); + } + ParserJavaMojo.JavaFileParser.this.registerKey(key); + match = true; + } + + } else if (complexI18nMethodPrefix.contains(methodName)) { + // key is argument 2 of child 2 + ExpressionContext argument = list.expression(1); + String firstArgs = argument.getText(); + if (firstArgs.matches("^\"[^\"]+\"$")) { + String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); + if (getLog().isDebugEnabled()) { + getLog().debug(file.getName() + " detected key = " + key); + } + ParserJavaMojo.JavaFileParser.this.registerKey(key); + match = true; + } + } + + Void aVoid = null; + if (!match) { + // continue visit + aVoid = super.visitMethodInvocation_lfno_primary(ctx); + } + return aVoid; } } } - - } diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8.tokens similarity index 81% copy from i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens copy to i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8.tokens index 22c63e5..52ef1ee 100644 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8.tokens @@ -1,201 +1,205 @@ -PACKAGE=32 -LT=68 -WHILE=50 -MOD=88 -CONST=10 -MOD_ASSIGN=96 +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 CASE=6 -NEW=31 +CATCH=7 CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 DO=13 -DIV_ASSIGN=92 -BREAK=4 -Identifier=100 -NOTEQUAL=76 -MUL_ASSIGN=91 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 FINAL=18 -RPAREN=58 -INC=79 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 IMPORT=25 -CARET=87 -THIS=43 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 RETURN=36 -DOUBLE=14 -VOID=48 -SUPER=40 -GOTO=23 -COMMENT=104 -RBRACK=62 -LSHIFT_ASSIGN=97 -GE=75 -RBRACE=60 -LINE_COMMENT=105 +SHORT=37 STATIC=38 -PRIVATE=33 -ADD_ASSIGN=89 -SWITCH=41 STRICTFP=39 -ELSE=15 -ELLIPSIS=102 -NATIVE=30 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 THROWS=45 -INT=27 -ASSERT=2 -MUL=83 +TRANSIENT=46 TRY=47 -WS=103 -BITOR=86 +VOID=48 +VOLATILE=49 +WHILE=50 +IntegerLiteral=51 FloatingPointLiteral=52 -OR=78 -GT=67 -CATCH=7 -THROW=44 BooleanLiteral=53 -PROTECTED=34 -DEC=80 -CLASS=9 -NullLiteral=56 -LBRACK=61 CharacterLiteral=54 -LBRACE=59 -FOR=21 -SUB=82 -FLOAT=20 -ABSTRACT=1 -AND=77 -AND_ASSIGN=93 -BITAND=85 +StringLiteral=55 +NullLiteral=56 LPAREN=57 -IF=22 -AT=101 -SYNCHRONIZED=42 -BOOLEAN=3 -IMPLEMENTS=24 -CONTINUE=11 +RPAREN=58 +LBRACE=59 +RBRACE=60 +LBRACK=61 +RBRACK=62 +SEMI=63 COMMA=64 -TRANSIENT=46 -EQUAL=73 -XOR_ASSIGN=95 -TILDE=70 DOT=65 -ADD=81 -BYTE=5 -VOLATILE=49 -DEFAULT=12 -SHORT=37 +ASSIGN=66 +GT=67 +LT=68 BANG=69 -INSTANCEOF=26 -RSHIFT_ASSIGN=98 -SEMI=63 -StringLiteral=55 -COLON=72 -OR_ASSIGN=94 -ENUM=16 +TILDE=70 QUESTION=71 -FINALLY=19 -URSHIFT_ASSIGN=99 -ASSIGN=66 -INTERFACE=28 -IntegerLiteral=51 -DIV=84 -LONG=29 -PUBLIC=35 -EXTENDS=17 -SUB_ASSIGN=90 +COLON=72 +EQUAL=73 LE=74 -'instanceof'=26 -'>='=75 -'~'=70 -'/'=84 -'=='=73 -'/='=92 -'switch'=41 -'%='=96 -'implements'=24 -'>'=67 -'||'=78 -'this'=43 -'&&'=77 -';'=63 -'volatile'=49 -'return'=36 -'for'=21 -'protected'=34 -'+'=81 -'.'=65 -'^'=87 +GE=75 +NOTEQUAL=76 +AND=77 +OR=78 +INC=79 +DEC=80 +ADD=81 +SUB=82 +MUL=83 +DIV=84 +BITAND=85 +BITOR=86 +CARET=87 +MOD=88 +ARROW=89 +COLONCOLON=90 +ADD_ASSIGN=91 +SUB_ASSIGN=92 +MUL_ASSIGN=93 +DIV_ASSIGN=94 +AND_ASSIGN=95 +OR_ASSIGN=96 +XOR_ASSIGN=97 +MOD_ASSIGN=98 +LSHIFT_ASSIGN=99 +RSHIFT_ASSIGN=100 +URSHIFT_ASSIGN=101 +Identifier=102 +AT=103 +ELLIPSIS=104 +WS=105 +COMMENT=106 +LINE_COMMENT=107 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 'byte'=5 -'import'=25 -'++'=79 -'static'=38 -'else'=15 +'case'=6 'catch'=7 -'final'=18 -'^='=95 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 'extends'=17 -'+='=89 +'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 -'break'=4 -'...'=102 -'{'=59 -'>>='=98 +'new'=31 'package'=32 -'>>>='=99 -'void'=48 -'?'=71 -'try'=47 'private'=33 -'int'=27 -'&='=93 -'if'=22 -':'=72 -'('=57 -'-'=82 -'while'=50 -','=64 -'synchronized'=42 -'default'=12 +'protected'=34 'public'=35 -'-='=90 -'<<='=97 -']'=62 +'return'=36 'short'=37 -'long'=29 -'enum'=16 -'!'=69 -'transient'=46 -'|'=86 -'finally'=19 -'assert'=2 -'class'=9 -'new'=31 -'|='=94 +'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 'null'=56 -'const'=10 -'goto'=23 -'='=66 -'@'=101 -'throw'=44 +'('=57 ')'=58 -'*='=91 -'%'=88 -'do'=13 -'super'=40 -'case'=6 -'char'=8 -'strictfp'=39 -'float'=20 +'{'=59 '}'=60 -'boolean'=3 -'abstract'=1 -'double'=14 +'['=61 +']'=62 +';'=63 +','=64 +'.'=65 +'='=66 +'>'=67 +'<'=68 +'!'=69 +'~'=70 +'?'=71 +':'=72 +'=='=73 '<='=74 +'>='=75 '!='=76 -'continue'=11 +'&&'=77 +'||'=78 +'++'=79 '--'=80 -'<'=68 +'+'=81 +'-'=82 '*'=83 -'['=61 +'/'=84 '&'=85 -'interface'=28 +'|'=86 +'^'=87 +'%'=88 +'->'=89 +'::'=90 +'+='=91 +'-='=92 +'*='=93 +'/='=94 +'&='=95 +'|='=96 +'^='=97 +'%='=98 +'<<='=99 +'>>='=100 +'>>>='=101 +'@'=103 +'...'=104 diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8BaseVisitor.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8BaseVisitor.java new file mode 100644 index 0000000..8463b45 --- /dev/null +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8BaseVisitor.java @@ -0,0 +1,1698 @@ +// Generated from i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +package org.nuiton.i18n.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link Java8Visitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param <T> The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public class Java8BaseVisitor<T> extends AbstractParseTreeVisitor<T> implements Java8Visitor<T> { + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLiteral(Java8Parser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitType(Java8Parser.TypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimitiveType(Java8Parser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNumericType(Java8Parser.NumericTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIntegralType(Java8Parser.IntegralTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFloatingPointType(Java8Parser.FloatingPointTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReferenceType(Java8Parser.ReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassOrInterfaceType(Java8Parser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType(Java8Parser.ClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType_lf_classOrInterfaceType(Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassType_lfno_classOrInterfaceType(Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType(Java8Parser.InterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType_lf_classOrInterfaceType(Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceType_lfno_classOrInterfaceType(Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeVariable(Java8Parser.TypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayType(Java8Parser.ArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDims(Java8Parser.DimsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameter(Java8Parser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameterModifier(Java8Parser.TypeParameterModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeBound(Java8Parser.TypeBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAdditionalBound(Java8Parser.AdditionalBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArguments(Java8Parser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgumentList(Java8Parser.TypeArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgument(Java8Parser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWildcard(Java8Parser.WildcardContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWildcardBounds(Java8Parser.WildcardBoundsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageName(Java8Parser.PackageNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeName(Java8Parser.TypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageOrTypeName(Java8Parser.PackageOrTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpressionName(Java8Parser.ExpressionNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodName(Java8Parser.MethodNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAmbiguousName(Java8Parser.AmbiguousNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCompilationUnit(Java8Parser.CompilationUnitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageDeclaration(Java8Parser.PackageDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPackageModifier(Java8Parser.PackageModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitImportDeclaration(Java8Parser.ImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeDeclaration(Java8Parser.TypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassDeclaration(Java8Parser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalClassDeclaration(Java8Parser.NormalClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassModifier(Java8Parser.ClassModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameters(Java8Parser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeParameterList(Java8Parser.TypeParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSuperclass(Java8Parser.SuperclassContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSuperinterfaces(Java8Parser.SuperinterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceTypeList(Java8Parser.InterfaceTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassBody(Java8Parser.ClassBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassBodyDeclaration(Java8Parser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassMemberDeclaration(Java8Parser.ClassMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldDeclaration(Java8Parser.FieldDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldModifier(Java8Parser.FieldModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclaratorList(Java8Parser.VariableDeclaratorListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclarator(Java8Parser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableDeclaratorId(Java8Parser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableInitializer(Java8Parser.VariableInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannType(Java8Parser.UnannTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannPrimitiveType(Java8Parser.UnannPrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannReferenceType(Java8Parser.UnannReferenceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassOrInterfaceType(Java8Parser.UnannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType(Java8Parser.UnannClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType_lf_unannClassOrInterfaceType(Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannClassType_lfno_unannClassOrInterfaceType(Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType(Java8Parser.UnannInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType_lf_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannTypeVariable(Java8Parser.UnannTypeVariableContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnannArrayType(Java8Parser.UnannArrayTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodDeclaration(Java8Parser.MethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodModifier(Java8Parser.MethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodHeader(Java8Parser.MethodHeaderContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResult(Java8Parser.ResultContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodDeclarator(Java8Parser.MethodDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameterList(Java8Parser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameters(Java8Parser.FormalParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFormalParameter(Java8Parser.FormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableModifier(Java8Parser.VariableModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLastFormalParameter(Java8Parser.LastFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReceiverParameter(Java8Parser.ReceiverParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitThrows_(Java8Parser.Throws_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExceptionTypeList(Java8Parser.ExceptionTypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExceptionType(Java8Parser.ExceptionTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodBody(Java8Parser.MethodBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInstanceInitializer(Java8Parser.InstanceInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStaticInitializer(Java8Parser.StaticInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorDeclaration(Java8Parser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorModifier(Java8Parser.ConstructorModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorDeclarator(Java8Parser.ConstructorDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSimpleTypeName(Java8Parser.SimpleTypeNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstructorBody(Java8Parser.ConstructorBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExplicitConstructorInvocation(Java8Parser.ExplicitConstructorInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumDeclaration(Java8Parser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumBody(Java8Parser.EnumBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantList(Java8Parser.EnumConstantListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstant(Java8Parser.EnumConstantContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantModifier(Java8Parser.EnumConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumBodyDeclarations(Java8Parser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceDeclaration(Java8Parser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalInterfaceDeclaration(Java8Parser.NormalInterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceModifier(Java8Parser.InterfaceModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExtendsInterfaces(Java8Parser.ExtendsInterfacesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceBody(Java8Parser.InterfaceBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMemberDeclaration(Java8Parser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantDeclaration(Java8Parser.ConstantDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantModifier(Java8Parser.ConstantModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMethodDeclaration(Java8Parser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInterfaceMethodModifier(Java8Parser.InterfaceMethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeDeclaration(Java8Parser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeBody(Java8Parser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeMemberDeclaration(Java8Parser.AnnotationTypeMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeElementDeclaration(Java8Parser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotationTypeElementModifier(Java8Parser.AnnotationTypeElementModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDefaultValue(Java8Parser.DefaultValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAnnotation(Java8Parser.AnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitNormalAnnotation(Java8Parser.NormalAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValuePairList(Java8Parser.ElementValuePairListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValuePair(Java8Parser.ElementValuePairContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValue(Java8Parser.ElementValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValueArrayInitializer(Java8Parser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitElementValueList(Java8Parser.ElementValueListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMarkerAnnotation(Java8Parser.MarkerAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSingleElementAnnotation(Java8Parser.SingleElementAnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayInitializer(Java8Parser.ArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitVariableInitializerList(Java8Parser.VariableInitializerListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlock(Java8Parser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlockStatements(Java8Parser.BlockStatementsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBlockStatement(Java8Parser.BlockStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLocalVariableDeclarationStatement(Java8Parser.LocalVariableDeclarationStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLocalVariableDeclaration(Java8Parser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatement(Java8Parser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementNoShortIf(Java8Parser.StatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementWithoutTrailingSubstatement(Java8Parser.StatementWithoutTrailingSubstatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEmptyStatement(Java8Parser.EmptyStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLabeledStatement(Java8Parser.LabeledStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLabeledStatementNoShortIf(Java8Parser.LabeledStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpressionStatement(Java8Parser.ExpressionStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementExpression(Java8Parser.StatementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenStatement(Java8Parser.IfThenStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenElseStatement(Java8Parser.IfThenElseStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitIfThenElseStatementNoShortIf(Java8Parser.IfThenElseStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssertStatement(Java8Parser.AssertStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchStatement(Java8Parser.SwitchStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchBlock(Java8Parser.SwitchBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchBlockStatementGroup(Java8Parser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchLabels(Java8Parser.SwitchLabelsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSwitchLabel(Java8Parser.SwitchLabelContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnumConstantName(Java8Parser.EnumConstantNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWhileStatement(Java8Parser.WhileStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitWhileStatementNoShortIf(Java8Parser.WhileStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDoStatement(Java8Parser.DoStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForStatement(Java8Parser.ForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForStatementNoShortIf(Java8Parser.ForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBasicForStatement(Java8Parser.BasicForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBasicForStatementNoShortIf(Java8Parser.BasicForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForInit(Java8Parser.ForInitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitForUpdate(Java8Parser.ForUpdateContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitStatementExpressionList(Java8Parser.StatementExpressionListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnhancedForStatement(Java8Parser.EnhancedForStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEnhancedForStatementNoShortIf(Java8Parser.EnhancedForStatementNoShortIfContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitBreakStatement(Java8Parser.BreakStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitContinueStatement(Java8Parser.ContinueStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitReturnStatement(Java8Parser.ReturnStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitThrowStatement(Java8Parser.ThrowStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitSynchronizedStatement(Java8Parser.SynchronizedStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTryStatement(Java8Parser.TryStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatches(Java8Parser.CatchesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchClause(Java8Parser.CatchClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchFormalParameter(Java8Parser.CatchFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCatchType(Java8Parser.CatchTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFinally_(Java8Parser.Finally_Context ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTryWithResourcesStatement(Java8Parser.TryWithResourcesStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResourceSpecification(Java8Parser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResourceList(Java8Parser.ResourceListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitResource(Java8Parser.ResourceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimary(Java8Parser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray(Java8Parser.PrimaryNoNewArrayContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_arrayAccess(Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_arrayAccess(Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression(Java8Parser.ClassInstanceCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression_lf_primary(Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitClassInstanceCreationExpression_lfno_primary(Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitTypeArgumentsOrDiamond(Java8Parser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess(Java8Parser.FieldAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess_lf_primary(Java8Parser.FieldAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitFieldAccess_lfno_primary(Java8Parser.FieldAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess(Java8Parser.ArrayAccessContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess_lf_primary(Java8Parser.ArrayAccess_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayAccess_lfno_primary(Java8Parser.ArrayAccess_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation(Java8Parser.MethodInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation_lf_primary(Java8Parser.MethodInvocation_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodInvocation_lfno_primary(Java8Parser.MethodInvocation_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArgumentList(Java8Parser.ArgumentListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference(Java8Parser.MethodReferenceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference_lf_primary(Java8Parser.MethodReference_lf_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMethodReference_lfno_primary(Java8Parser.MethodReference_lfno_primaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitArrayCreationExpression(Java8Parser.ArrayCreationExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDimExprs(Java8Parser.DimExprsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitDimExpr(Java8Parser.DimExprContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConstantExpression(Java8Parser.ConstantExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExpression(Java8Parser.ExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaExpression(Java8Parser.LambdaExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaParameters(Java8Parser.LambdaParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInferredFormalParameterList(Java8Parser.InferredFormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLambdaBody(Java8Parser.LambdaBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignmentExpression(Java8Parser.AssignmentExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignment(Java8Parser.AssignmentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitLeftHandSide(Java8Parser.LeftHandSideContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAssignmentOperator(Java8Parser.AssignmentOperatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalExpression(Java8Parser.ConditionalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalOrExpression(Java8Parser.ConditionalOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitConditionalAndExpression(Java8Parser.ConditionalAndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitInclusiveOrExpression(Java8Parser.InclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitExclusiveOrExpression(Java8Parser.ExclusiveOrExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAndExpression(Java8Parser.AndExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitEqualityExpression(Java8Parser.EqualityExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitRelationalExpression(Java8Parser.RelationalExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitShiftExpression(Java8Parser.ShiftExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitAdditiveExpression(Java8Parser.AdditiveExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitMultiplicativeExpression(Java8Parser.MultiplicativeExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnaryExpression(Java8Parser.UnaryExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPreIncrementExpression(Java8Parser.PreIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPreDecrementExpression(Java8Parser.PreDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitUnaryExpressionNotPlusMinus(Java8Parser.UnaryExpressionNotPlusMinusContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostfixExpression(Java8Parser.PostfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostIncrementExpression(Java8Parser.PostIncrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostIncrementExpression_lf_postfixExpression(Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostDecrementExpression(Java8Parser.PostDecrementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitPostDecrementExpression_lf_postfixExpression(Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + * <p>The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.</p> + */ + @Override public T visitCastExpression(Java8Parser.CastExpressionContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.java new file mode 100644 index 0000000..704ef5f --- /dev/null +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.java @@ -0,0 +1,609 @@ +// Generated from i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +package org.nuiton.i18n.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, + ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, + OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, + URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, + LINE_COMMENT=107; + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + public static final String[] ruleNames = { + "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", + "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", + "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", + "HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", + "DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", + "DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", + "HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", + "OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", + "BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", + "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", + "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", + "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", + "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", + "StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", + "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", + "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", + "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", + "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", + "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", + "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", + "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + + private static final String[] _LITERAL_NAMES = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", + "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", + "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", + "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + 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; + } + + + public Java8Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Java8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 146: + return JavaLetter_sempred((RuleContext)_localctx, predIndex); + case 147: + return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return Character.isJavaIdentifierStart(_input.LA(-1)); + case 1: + return Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); + } + return true; + } + private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return Character.isJavaIdentifierPart(_input.LA(-1)); + case 3: + return Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); + } + return true; + } + + public static final String _serializedATN = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2m\u0448\b\1\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ + "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ + "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ + "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\3\2\3\2\3\2\3"+ + "\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4"+ + "\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3"+ + "\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n"+ + "\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f"+ + "\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3"+ + "\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3"+ + "\22\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3"+ + "\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3"+ + "\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3"+ + "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3"+ + "\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3"+ + "\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3"+ + "\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!"+ + "\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3"+ + "#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3"+ + "\'\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3"+ + ")\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3"+ + ",\3,\3,\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3"+ + "/\3/\3/\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3"+ + "\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3"+ + "\64\3\64\5\64\u028d\n\64\3\65\3\65\5\65\u0291\n\65\3\66\3\66\5\66\u0295"+ + "\n\66\3\67\3\67\5\67\u0299\n\67\38\38\58\u029d\n8\39\39\3:\3:\3:\5:\u02a4"+ + "\n:\3:\3:\3:\5:\u02a9\n:\5:\u02ab\n:\3;\3;\5;\u02af\n;\3;\5;\u02b2\n;"+ + "\3<\3<\5<\u02b6\n<\3=\3=\3>\6>\u02bb\n>\r>\16>\u02bc\3?\3?\5?\u02c1\n"+ + "?\3@\6@\u02c4\n@\r@\16@\u02c5\3A\3A\3A\3A\3B\3B\5B\u02ce\nB\3B\5B\u02d1"+ + "\nB\3C\3C\3D\6D\u02d6\nD\rD\16D\u02d7\3E\3E\5E\u02dc\nE\3F\3F\5F\u02e0"+ + "\nF\3F\3F\3G\3G\5G\u02e6\nG\3G\5G\u02e9\nG\3H\3H\3I\6I\u02ee\nI\rI\16"+ + "I\u02ef\3J\3J\5J\u02f4\nJ\3K\3K\3K\3K\3L\3L\5L\u02fc\nL\3L\5L\u02ff\n"+ + "L\3M\3M\3N\6N\u0304\nN\rN\16N\u0305\3O\3O\5O\u030a\nO\3P\3P\5P\u030e\n"+ + "P\3Q\3Q\3Q\5Q\u0313\nQ\3Q\5Q\u0316\nQ\3Q\5Q\u0319\nQ\3Q\3Q\3Q\5Q\u031e"+ + "\nQ\3Q\5Q\u0321\nQ\3Q\3Q\3Q\5Q\u0326\nQ\3Q\3Q\3Q\5Q\u032b\nQ\3R\3R\3R"+ + "\3S\3S\3T\5T\u0333\nT\3T\3T\3U\3U\3V\3V\3W\3W\3W\5W\u033e\nW\3X\3X\5X"+ + "\u0342\nX\3X\3X\3X\5X\u0347\nX\3X\3X\5X\u034b\nX\3Y\3Y\3Y\3Z\3Z\3[\3["+ + "\3[\3[\3[\3[\3[\3[\3[\5[\u035b\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\"+ + "\u0365\n\\\3]\3]\3^\3^\5^\u036b\n^\3^\3^\3_\6_\u0370\n_\r_\16_\u0371\3"+ + "`\3`\5`\u0376\n`\3a\3a\3a\3a\5a\u037c\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3"+ + "b\3b\5b\u0389\nb\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3f\3f\3g\3"+ + "g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3p\3p\3q\3q\3r\3r\3"+ + "s\3s\3t\3t\3u\3u\3v\3v\3v\3w\3w\3w\3x\3x\3x\3y\3y\3y\3z\3z\3z\3{\3{\3"+ + "{\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3\u0081\3\u0081"+ + "\3\u0082\3\u0082\3\u0083\3\u0083\3\u0084\3\u0084\3\u0085\3\u0085\3\u0086"+ + "\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089"+ + "\3\u0089\3\u0089\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c"+ + "\3\u008c\3\u008c\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008f"+ + "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0093\3\u0093\7\u0093"+ + "\u040e\n\u0093\f\u0093\16\u0093\u0411\13\u0093\3\u0094\3\u0094\3\u0094"+ + "\3\u0094\3\u0094\3\u0094\5\u0094\u0419\n\u0094\3\u0095\3\u0095\3\u0095"+ + "\3\u0095\3\u0095\3\u0095\5\u0095\u0421\n\u0095\3\u0096\3\u0096\3\u0097"+ + "\3\u0097\3\u0097\3\u0097\3\u0098\6\u0098\u042a\n\u0098\r\u0098\16\u0098"+ + "\u042b\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\7\u0099\u0434\n"+ + "\u0099\f\u0099\16\u0099\u0437\13\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ + "\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\7\u009a\u0442\n\u009a\f\u009a"+ + "\16\u009a\u0445\13\u009a\3\u009a\3\u009a\3\u0435\2\u009b\3\3\5\4\7\5\t"+ + "\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+ + "%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+ + "%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\2k\2m\2o\2q\2s\2u\2w\2"+ + "y\2{\2}\2\177\2\u0081\2\u0083\2\u0085\2\u0087\2\u0089\2\u008b\2\u008d"+ + "\2\u008f\2\u0091\2\u0093\2\u0095\2\u0097\2\u0099\2\u009b\2\u009d\2\u009f"+ + "\66\u00a1\2\u00a3\2\u00a5\2\u00a7\2\u00a9\2\u00ab\2\u00ad\2\u00af\2\u00b1"+ + "\2\u00b3\2\u00b5\67\u00b78\u00b9\2\u00bb9\u00bd\2\u00bf\2\u00c1\2\u00c3"+ + "\2\u00c5\2\u00c7\2\u00c9:\u00cb;\u00cd<\u00cf=\u00d1>\u00d3?\u00d5@\u00d7"+ + "A\u00d9B\u00dbC\u00ddD\u00dfE\u00e1F\u00e3G\u00e5H\u00e7I\u00e9J\u00eb"+ + "K\u00edL\u00efM\u00f1N\u00f3O\u00f5P\u00f7Q\u00f9R\u00fbS\u00fdT\u00ff"+ + "U\u0101V\u0103W\u0105X\u0107Y\u0109Z\u010b[\u010d\\\u010f]\u0111^\u0113"+ + "_\u0115`\u0117a\u0119b\u011bc\u011dd\u011fe\u0121f\u0123g\u0125h\u0127"+ + "\2\u0129\2\u012bi\u012dj\u012fk\u0131l\u0133m\3\2\30\4\2NNnn\3\2\63;\4"+ + "\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4\2GGgg\4\2--//\6\2FFHHf"+ + "fhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\aac"+ + "|\4\2\2\u0081\ud802\udc01\3\2\ud802\udc01\3\2\udc02\ue001\7\2&&\62;C\\"+ + "aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\u0456\2\3\3\2\2\2\2\5\3\2\2\2\2"+ + "\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2"+ + "\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2"+ + "\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2"+ + "\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2"+ + "\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2"+ + "\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2"+ + "M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3"+ + "\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2"+ + "\2\2g\3\2\2\2\2\u009f\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00bb"+ + "\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2"+ + "\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9"+ + "\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2"+ + "\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb"+ + "\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2"+ + "\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd"+ + "\3\2\2\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2"+ + "\2\2\u0107\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f"+ + "\3\2\2\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2"+ + "\2\2\u0119\3\2\2\2\2\u011b\3\2\2\2\2\u011d\3\2\2\2\2\u011f\3\2\2\2\2\u0121"+ + "\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2\2\2\u012b\3\2\2\2\2\u012d\3\2\2"+ + "\2\2\u012f\3\2\2\2\2\u0131\3\2\2\2\2\u0133\3\2\2\2\3\u0135\3\2\2\2\5\u013e"+ + "\3\2\2\2\7\u0145\3\2\2\2\t\u014d\3\2\2\2\13\u0153\3\2\2\2\r\u0158\3\2"+ + "\2\2\17\u015d\3\2\2\2\21\u0163\3\2\2\2\23\u0168\3\2\2\2\25\u016e\3\2\2"+ + "\2\27\u0174\3\2\2\2\31\u017d\3\2\2\2\33\u0185\3\2\2\2\35\u0188\3\2\2\2"+ + "\37\u018f\3\2\2\2!\u0194\3\2\2\2#\u0199\3\2\2\2%\u01a1\3\2\2\2\'\u01a7"+ + "\3\2\2\2)\u01af\3\2\2\2+\u01b5\3\2\2\2-\u01b9\3\2\2\2/\u01bc\3\2\2\2\61"+ + "\u01c1\3\2\2\2\63\u01cc\3\2\2\2\65\u01d3\3\2\2\2\67\u01de\3\2\2\29\u01e2"+ + "\3\2\2\2;\u01ec\3\2\2\2=\u01f1\3\2\2\2?\u01f8\3\2\2\2A\u01fc\3\2\2\2C"+ + "\u0204\3\2\2\2E\u020c\3\2\2\2G\u0216\3\2\2\2I\u021d\3\2\2\2K\u0224\3\2"+ + "\2\2M\u022a\3\2\2\2O\u0231\3\2\2\2Q\u023a\3\2\2\2S\u0240\3\2\2\2U\u0247"+ + "\3\2\2\2W\u0254\3\2\2\2Y\u0259\3\2\2\2[\u025f\3\2\2\2]\u0266\3\2\2\2_"+ + "\u0270\3\2\2\2a\u0274\3\2\2\2c\u0279\3\2\2\2e\u0282\3\2\2\2g\u028c\3\2"+ + "\2\2i\u028e\3\2\2\2k\u0292\3\2\2\2m\u0296\3\2\2\2o\u029a\3\2\2\2q\u029e"+ + "\3\2\2\2s\u02aa\3\2\2\2u\u02ac\3\2\2\2w\u02b5\3\2\2\2y\u02b7\3\2\2\2{"+ + "\u02ba\3\2\2\2}\u02c0\3\2\2\2\177\u02c3\3\2\2\2\u0081\u02c7\3\2\2\2\u0083"+ + "\u02cb\3\2\2\2\u0085\u02d2\3\2\2\2\u0087\u02d5\3\2\2\2\u0089\u02db\3\2"+ + "\2\2\u008b\u02dd\3\2\2\2\u008d\u02e3\3\2\2\2\u008f\u02ea\3\2\2\2\u0091"+ + "\u02ed\3\2\2\2\u0093\u02f3\3\2\2\2\u0095\u02f5\3\2\2\2\u0097\u02f9\3\2"+ + "\2\2\u0099\u0300\3\2\2\2\u009b\u0303\3\2\2\2\u009d\u0309\3\2\2\2\u009f"+ + "\u030d\3\2\2\2\u00a1\u032a\3\2\2\2\u00a3\u032c\3\2\2\2\u00a5\u032f\3\2"+ + "\2\2\u00a7\u0332\3\2\2\2\u00a9\u0336\3\2\2\2\u00ab\u0338\3\2\2\2\u00ad"+ + "\u033a\3\2\2\2\u00af\u034a\3\2\2\2\u00b1\u034c\3\2\2\2\u00b3\u034f\3\2"+ + "\2\2\u00b5\u035a\3\2\2\2\u00b7\u0364\3\2\2\2\u00b9\u0366\3\2\2\2\u00bb"+ + "\u0368\3\2\2\2\u00bd\u036f\3\2\2\2\u00bf\u0375\3\2\2\2\u00c1\u037b\3\2"+ + "\2\2\u00c3\u0388\3\2\2\2\u00c5\u038a\3\2\2\2\u00c7\u038c\3\2\2\2\u00c9"+ + "\u0393\3\2\2\2\u00cb\u0398\3\2\2\2\u00cd\u039a\3\2\2\2\u00cf\u039c\3\2"+ + "\2\2\u00d1\u039e\3\2\2\2\u00d3\u03a0\3\2\2\2\u00d5\u03a2\3\2\2\2\u00d7"+ + "\u03a4\3\2\2\2\u00d9\u03a6\3\2\2\2\u00db\u03a8\3\2\2\2\u00dd\u03aa\3\2"+ + "\2\2\u00df\u03ac\3\2\2\2\u00e1\u03ae\3\2\2\2\u00e3\u03b0\3\2\2\2\u00e5"+ + "\u03b2\3\2\2\2\u00e7\u03b4\3\2\2\2\u00e9\u03b6\3\2\2\2\u00eb\u03b8\3\2"+ + "\2\2\u00ed\u03bb\3\2\2\2\u00ef\u03be\3\2\2\2\u00f1\u03c1\3\2\2\2\u00f3"+ + "\u03c4\3\2\2\2\u00f5\u03c7\3\2\2\2\u00f7\u03ca\3\2\2\2\u00f9\u03cd\3\2"+ + "\2\2\u00fb\u03d0\3\2\2\2\u00fd\u03d2\3\2\2\2\u00ff\u03d4\3\2\2\2\u0101"+ + "\u03d6\3\2\2\2\u0103\u03d8\3\2\2\2\u0105\u03da\3\2\2\2\u0107\u03dc\3\2"+ + "\2\2\u0109\u03de\3\2\2\2\u010b\u03e0\3\2\2\2\u010d\u03e3\3\2\2\2\u010f"+ + "\u03e6\3\2\2\2\u0111\u03e9\3\2\2\2\u0113\u03ec\3\2\2\2\u0115\u03ef\3\2"+ + "\2\2\u0117\u03f2\3\2\2\2\u0119\u03f5\3\2\2\2\u011b\u03f8\3\2\2\2\u011d"+ + "\u03fb\3\2\2\2\u011f\u03fe\3\2\2\2\u0121\u0402\3\2\2\2\u0123\u0406\3\2"+ + "\2\2\u0125\u040b\3\2\2\2\u0127\u0418\3\2\2\2\u0129\u0420\3\2\2\2\u012b"+ + "\u0422\3\2\2\2\u012d\u0424\3\2\2\2\u012f\u0429\3\2\2\2\u0131\u042f\3\2"+ + "\2\2\u0133\u043d\3\2\2\2\u0135\u0136\7c\2\2\u0136\u0137\7d\2\2\u0137\u0138"+ + "\7u\2\2\u0138\u0139\7v\2\2\u0139\u013a\7t\2\2\u013a\u013b\7c\2\2\u013b"+ + "\u013c\7e\2\2\u013c\u013d\7v\2\2\u013d\4\3\2\2\2\u013e\u013f\7c\2\2\u013f"+ + "\u0140\7u\2\2\u0140\u0141\7u\2\2\u0141\u0142\7g\2\2\u0142\u0143\7t\2\2"+ + "\u0143\u0144\7v\2\2\u0144\6\3\2\2\2\u0145\u0146\7d\2\2\u0146\u0147\7q"+ + "\2\2\u0147\u0148\7q\2\2\u0148\u0149\7n\2\2\u0149\u014a\7g\2\2\u014a\u014b"+ + "\7c\2\2\u014b\u014c\7p\2\2\u014c\b\3\2\2\2\u014d\u014e\7d\2\2\u014e\u014f"+ + "\7t\2\2\u014f\u0150\7g\2\2\u0150\u0151\7c\2\2\u0151\u0152\7m\2\2\u0152"+ + "\n\3\2\2\2\u0153\u0154\7d\2\2\u0154\u0155\7{\2\2\u0155\u0156\7v\2\2\u0156"+ + "\u0157\7g\2\2\u0157\f\3\2\2\2\u0158\u0159\7e\2\2\u0159\u015a\7c\2\2\u015a"+ + "\u015b\7u\2\2\u015b\u015c\7g\2\2\u015c\16\3\2\2\2\u015d\u015e\7e\2\2\u015e"+ + "\u015f\7c\2\2\u015f\u0160\7v\2\2\u0160\u0161\7e\2\2\u0161\u0162\7j\2\2"+ + "\u0162\20\3\2\2\2\u0163\u0164\7e\2\2\u0164\u0165\7j\2\2\u0165\u0166\7"+ + "c\2\2\u0166\u0167\7t\2\2\u0167\22\3\2\2\2\u0168\u0169\7e\2\2\u0169\u016a"+ + "\7n\2\2\u016a\u016b\7c\2\2\u016b\u016c\7u\2\2\u016c\u016d\7u\2\2\u016d"+ + "\24\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171\7p\2\2\u0171"+ + "\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173\26\3\2\2\2\u0174\u0175\7e\2\2\u0175"+ + "\u0176\7q\2\2\u0176\u0177\7p\2\2\u0177\u0178\7v\2\2\u0178\u0179\7k\2\2"+ + "\u0179\u017a\7p\2\2\u017a\u017b\7w\2\2\u017b\u017c\7g\2\2\u017c\30\3\2"+ + "\2\2\u017d\u017e\7f\2\2\u017e\u017f\7g\2\2\u017f\u0180\7h\2\2\u0180\u0181"+ + "\7c\2\2\u0181\u0182\7w\2\2\u0182\u0183\7n\2\2\u0183\u0184\7v\2\2\u0184"+ + "\32\3\2\2\2\u0185\u0186\7f\2\2\u0186\u0187\7q\2\2\u0187\34\3\2\2\2\u0188"+ + "\u0189\7f\2\2\u0189\u018a\7q\2\2\u018a\u018b\7w\2\2\u018b\u018c\7d\2\2"+ + "\u018c\u018d\7n\2\2\u018d\u018e\7g\2\2\u018e\36\3\2\2\2\u018f\u0190\7"+ + "g\2\2\u0190\u0191\7n\2\2\u0191\u0192\7u\2\2\u0192\u0193\7g\2\2\u0193 "+ + "\3\2\2\2\u0194\u0195\7g\2\2\u0195\u0196\7p\2\2\u0196\u0197\7w\2\2\u0197"+ + "\u0198\7o\2\2\u0198\"\3\2\2\2\u0199\u019a\7g\2\2\u019a\u019b\7z\2\2\u019b"+ + "\u019c\7v\2\2\u019c\u019d\7g\2\2\u019d\u019e\7p\2\2\u019e\u019f\7f\2\2"+ + "\u019f\u01a0\7u\2\2\u01a0$\3\2\2\2\u01a1\u01a2\7h\2\2\u01a2\u01a3\7k\2"+ + "\2\u01a3\u01a4\7p\2\2\u01a4\u01a5\7c\2\2\u01a5\u01a6\7n\2\2\u01a6&\3\2"+ + "\2\2\u01a7\u01a8\7h\2\2\u01a8\u01a9\7k\2\2\u01a9\u01aa\7p\2\2\u01aa\u01ab"+ + "\7c\2\2\u01ab\u01ac\7n\2\2\u01ac\u01ad\7n\2\2\u01ad\u01ae\7{\2\2\u01ae"+ + "(\3\2\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7n\2\2\u01b1\u01b2\7q\2\2\u01b2"+ + "\u01b3\7c\2\2\u01b3\u01b4\7v\2\2\u01b4*\3\2\2\2\u01b5\u01b6\7h\2\2\u01b6"+ + "\u01b7\7q\2\2\u01b7\u01b8\7t\2\2\u01b8,\3\2\2\2\u01b9\u01ba\7k\2\2\u01ba"+ + "\u01bb\7h\2\2\u01bb.\3\2\2\2\u01bc\u01bd\7i\2\2\u01bd\u01be\7q\2\2\u01be"+ + "\u01bf\7v\2\2\u01bf\u01c0\7q\2\2\u01c0\60\3\2\2\2\u01c1\u01c2\7k\2\2\u01c2"+ + "\u01c3\7o\2\2\u01c3\u01c4\7r\2\2\u01c4\u01c5\7n\2\2\u01c5\u01c6\7g\2\2"+ + "\u01c6\u01c7\7o\2\2\u01c7\u01c8\7g\2\2\u01c8\u01c9\7p\2\2\u01c9\u01ca"+ + "\7v\2\2\u01ca\u01cb\7u\2\2\u01cb\62\3\2\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce"+ + "\7o\2\2\u01ce\u01cf\7r\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7t\2\2\u01d1"+ + "\u01d2\7v\2\2\u01d2\64\3\2\2\2\u01d3\u01d4\7k\2\2\u01d4\u01d5\7p\2\2\u01d5"+ + "\u01d6\7u\2\2\u01d6\u01d7\7v\2\2\u01d7\u01d8\7c\2\2\u01d8\u01d9\7p\2\2"+ + "\u01d9\u01da\7e\2\2\u01da\u01db\7g\2\2\u01db\u01dc\7q\2\2\u01dc\u01dd"+ + "\7h\2\2\u01dd\66\3\2\2\2\u01de\u01df\7k\2\2\u01df\u01e0\7p\2\2\u01e0\u01e1"+ + "\7v\2\2\u01e18\3\2\2\2\u01e2\u01e3\7k\2\2\u01e3\u01e4\7p\2\2\u01e4\u01e5"+ + "\7v\2\2\u01e5\u01e6\7g\2\2\u01e6\u01e7\7t\2\2\u01e7\u01e8\7h\2\2\u01e8"+ + "\u01e9\7c\2\2\u01e9\u01ea\7e\2\2\u01ea\u01eb\7g\2\2\u01eb:\3\2\2\2\u01ec"+ + "\u01ed\7n\2\2\u01ed\u01ee\7q\2\2\u01ee\u01ef\7p\2\2\u01ef\u01f0\7i\2\2"+ + "\u01f0<\3\2\2\2\u01f1\u01f2\7p\2\2\u01f2\u01f3\7c\2\2\u01f3\u01f4\7v\2"+ + "\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7x\2\2\u01f6\u01f7\7g\2\2\u01f7>\3\2"+ + "\2\2\u01f8\u01f9\7p\2\2\u01f9\u01fa\7g\2\2\u01fa\u01fb\7y\2\2\u01fb@\3"+ + "\2\2\2\u01fc\u01fd\7r\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff\7e\2\2\u01ff"+ + "\u0200\7m\2\2\u0200\u0201\7c\2\2\u0201\u0202\7i\2\2\u0202\u0203\7g\2\2"+ + "\u0203B\3\2\2\2\u0204\u0205\7r\2\2\u0205\u0206\7t\2\2\u0206\u0207\7k\2"+ + "\2\u0207\u0208\7x\2\2\u0208\u0209\7c\2\2\u0209\u020a\7v\2\2\u020a\u020b"+ + "\7g\2\2\u020bD\3\2\2\2\u020c\u020d\7r\2\2\u020d\u020e\7t\2\2\u020e\u020f"+ + "\7q\2\2\u020f\u0210\7v\2\2\u0210\u0211\7g\2\2\u0211\u0212\7e\2\2\u0212"+ + "\u0213\7v\2\2\u0213\u0214\7g\2\2\u0214\u0215\7f\2\2\u0215F\3\2\2\2\u0216"+ + "\u0217\7r\2\2\u0217\u0218\7w\2\2\u0218\u0219\7d\2\2\u0219\u021a\7n\2\2"+ + "\u021a\u021b\7k\2\2\u021b\u021c\7e\2\2\u021cH\3\2\2\2\u021d\u021e\7t\2"+ + "\2\u021e\u021f\7g\2\2\u021f\u0220\7v\2\2\u0220\u0221\7w\2\2\u0221\u0222"+ + "\7t\2\2\u0222\u0223\7p\2\2\u0223J\3\2\2\2\u0224\u0225\7u\2\2\u0225\u0226"+ + "\7j\2\2\u0226\u0227\7q\2\2\u0227\u0228\7t\2\2\u0228\u0229\7v\2\2\u0229"+ + "L\3\2\2\2\u022a\u022b\7u\2\2\u022b\u022c\7v\2\2\u022c\u022d\7c\2\2\u022d"+ + "\u022e\7v\2\2\u022e\u022f\7k\2\2\u022f\u0230\7e\2\2\u0230N\3\2\2\2\u0231"+ + "\u0232\7u\2\2\u0232\u0233\7v\2\2\u0233\u0234\7t\2\2\u0234\u0235\7k\2\2"+ + "\u0235\u0236\7e\2\2\u0236\u0237\7v\2\2\u0237\u0238\7h\2\2\u0238\u0239"+ + "\7r\2\2\u0239P\3\2\2\2\u023a\u023b\7u\2\2\u023b\u023c\7w\2\2\u023c\u023d"+ + "\7r\2\2\u023d\u023e\7g\2\2\u023e\u023f\7t\2\2\u023fR\3\2\2\2\u0240\u0241"+ + "\7u\2\2\u0241\u0242\7y\2\2\u0242\u0243\7k\2\2\u0243\u0244\7v\2\2\u0244"+ + "\u0245\7e\2\2\u0245\u0246\7j\2\2\u0246T\3\2\2\2\u0247\u0248\7u\2\2\u0248"+ + "\u0249\7{\2\2\u0249\u024a\7p\2\2\u024a\u024b\7e\2\2\u024b\u024c\7j\2\2"+ + "\u024c\u024d\7t\2\2\u024d\u024e\7q\2\2\u024e\u024f\7p\2\2\u024f\u0250"+ + "\7k\2\2\u0250\u0251\7|\2\2\u0251\u0252\7g\2\2\u0252\u0253\7f\2\2\u0253"+ + "V\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7j\2\2\u0256\u0257\7k\2\2\u0257"+ + "\u0258\7u\2\2\u0258X\3\2\2\2\u0259\u025a\7v\2\2\u025a\u025b\7j\2\2\u025b"+ + "\u025c\7t\2\2\u025c\u025d\7q\2\2\u025d\u025e\7y\2\2\u025eZ\3\2\2\2\u025f"+ + "\u0260\7v\2\2\u0260\u0261\7j\2\2\u0261\u0262\7t\2\2\u0262\u0263\7q\2\2"+ + "\u0263\u0264\7y\2\2\u0264\u0265\7u\2\2\u0265\\\3\2\2\2\u0266\u0267\7v"+ + "\2\2\u0267\u0268\7t\2\2\u0268\u0269\7c\2\2\u0269\u026a\7p\2\2\u026a\u026b"+ + "\7u\2\2\u026b\u026c\7k\2\2\u026c\u026d\7g\2\2\u026d\u026e\7p\2\2\u026e"+ + "\u026f\7v\2\2\u026f^\3\2\2\2\u0270\u0271\7v\2\2\u0271\u0272\7t\2\2\u0272"+ + "\u0273\7{\2\2\u0273`\3\2\2\2\u0274\u0275\7x\2\2\u0275\u0276\7q\2\2\u0276"+ + "\u0277\7k\2\2\u0277\u0278\7f\2\2\u0278b\3\2\2\2\u0279\u027a\7x\2\2\u027a"+ + "\u027b\7q\2\2\u027b\u027c\7n\2\2\u027c\u027d\7c\2\2\u027d\u027e\7v\2\2"+ + "\u027e\u027f\7k\2\2\u027f\u0280\7n\2\2\u0280\u0281\7g\2\2\u0281d\3\2\2"+ + "\2\u0282\u0283\7y\2\2\u0283\u0284\7j\2\2\u0284\u0285\7k\2\2\u0285\u0286"+ + "\7n\2\2\u0286\u0287\7g\2\2\u0287f\3\2\2\2\u0288\u028d\5i\65\2\u0289\u028d"+ + "\5k\66\2\u028a\u028d\5m\67\2\u028b\u028d\5o8\2\u028c\u0288\3\2\2\2\u028c"+ + "\u0289\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028b\3\2\2\2\u028dh\3\2\2\2"+ + "\u028e\u0290\5s:\2\u028f\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3"+ + "\2\2\2\u0291j\3\2\2\2\u0292\u0294\5\u0081A\2\u0293\u0295\5q9\2\u0294\u0293"+ + "\3\2\2\2\u0294\u0295\3\2\2\2\u0295l\3\2\2\2\u0296\u0298\5\u008bF\2\u0297"+ + "\u0299\5q9\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299n\3\2\2\2\u029a"+ + "\u029c\5\u0095K\2\u029b\u029d\5q9\2\u029c\u029b\3\2\2\2\u029c\u029d\3"+ + "\2\2\2\u029dp\3\2\2\2\u029e\u029f\t\2\2\2\u029fr\3\2\2\2\u02a0\u02ab\7"+ + "\62\2\2\u02a1\u02a8\5y=\2\u02a2\u02a4\5u;\2\u02a3\u02a2\3\2\2\2\u02a3"+ + "\u02a4\3\2\2\2\u02a4\u02a9\3\2\2\2\u02a5\u02a6\5\177@\2\u02a6\u02a7\5"+ + "u;\2\u02a7\u02a9\3\2\2\2\u02a8\u02a3\3\2\2\2\u02a8\u02a5\3\2\2\2\u02a9"+ + "\u02ab\3\2\2\2\u02aa\u02a0\3\2\2\2\u02aa\u02a1\3\2\2\2\u02abt\3\2\2\2"+ + "\u02ac\u02b1\5w<\2\u02ad\u02af\5{>\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+ + "\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b2\5w<\2\u02b1\u02ae\3\2\2\2\u02b1"+ + "\u02b2\3\2\2\2\u02b2v\3\2\2\2\u02b3\u02b6\7\62\2\2\u02b4\u02b6\5y=\2\u02b5"+ + "\u02b3\3\2\2\2\u02b5\u02b4\3\2\2\2\u02b6x\3\2\2\2\u02b7\u02b8\t\3\2\2"+ + "\u02b8z\3\2\2\2\u02b9\u02bb\5}?\2\u02ba\u02b9\3\2\2\2\u02bb\u02bc\3\2"+ + "\2\2\u02bc\u02ba\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd|\3\2\2\2\u02be\u02c1"+ + "\5w<\2\u02bf\u02c1\7a\2\2\u02c0\u02be\3\2\2\2\u02c0\u02bf\3\2\2\2\u02c1"+ + "~\3\2\2\2\u02c2\u02c4\7a\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+ + "\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u0080\3\2\2\2\u02c7\u02c8\7\62"+ + "\2\2\u02c8\u02c9\t\4\2\2\u02c9\u02ca\5\u0083B\2\u02ca\u0082\3\2\2\2\u02cb"+ + "\u02d0\5\u0085C\2\u02cc\u02ce\5\u0087D\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce"+ + "\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d1\5\u0085C\2\u02d0\u02cd\3\2\2"+ + "\2\u02d0\u02d1\3\2\2\2\u02d1\u0084\3\2\2\2\u02d2\u02d3\t\5\2\2\u02d3\u0086"+ + "\3\2\2\2\u02d4\u02d6\5\u0089E\2\u02d5\u02d4\3\2\2\2\u02d6\u02d7\3\2\2"+ + "\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u0088\3\2\2\2\u02d9\u02dc"+ + "\5\u0085C\2\u02da\u02dc\7a\2\2\u02db\u02d9\3\2\2\2\u02db\u02da\3\2\2\2"+ + "\u02dc\u008a\3\2\2\2\u02dd\u02df\7\62\2\2\u02de\u02e0\5\177@\2\u02df\u02de"+ + "\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e2\5\u008dG"+ + "\2\u02e2\u008c\3\2\2\2\u02e3\u02e8\5\u008fH\2\u02e4\u02e6\5\u0091I\2\u02e5"+ + "\u02e4\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\5\u008f"+ + "H\2\u02e8\u02e5\3\2\2\2\u02e8\u02e9\3\2\2\2\u02e9\u008e\3\2\2\2\u02ea"+ + "\u02eb\t\6\2\2\u02eb\u0090\3\2\2\2\u02ec\u02ee\5\u0093J\2\u02ed\u02ec"+ + "\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02ed\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0"+ + "\u0092\3\2\2\2\u02f1\u02f4\5\u008fH\2\u02f2\u02f4\7a\2\2\u02f3\u02f1\3"+ + "\2\2\2\u02f3\u02f2\3\2\2\2\u02f4\u0094\3\2\2\2\u02f5\u02f6\7\62\2\2\u02f6"+ + "\u02f7\t\7\2\2\u02f7\u02f8\5\u0097L\2\u02f8\u0096\3\2\2\2\u02f9\u02fe"+ + "\5\u0099M\2\u02fa\u02fc\5\u009bN\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2"+ + "\2\2\u02fc\u02fd\3\2\2\2\u02fd\u02ff\5\u0099M\2\u02fe\u02fb\3\2\2\2\u02fe"+ + "\u02ff\3\2\2\2\u02ff\u0098\3\2\2\2\u0300\u0301\t\b\2\2\u0301\u009a\3\2"+ + "\2\2\u0302\u0304\5\u009dO\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+ + "\u0303\3\2\2\2\u0305\u0306\3\2\2\2\u0306\u009c\3\2\2\2\u0307\u030a\5\u0099"+ + "M\2\u0308\u030a\7a\2\2\u0309\u0307\3\2\2\2\u0309\u0308\3\2\2\2\u030a\u009e"+ + "\3\2\2\2\u030b\u030e\5\u00a1Q\2\u030c\u030e\5\u00adW\2\u030d\u030b\3\2"+ + "\2\2\u030d\u030c\3\2\2\2\u030e\u00a0\3\2\2\2\u030f\u0310\5u;\2\u0310\u0312"+ + "\7\60\2\2\u0311\u0313\5u;\2\u0312\u0311\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ + "\u0315\3\2\2\2\u0314\u0316\5\u00a3R\2\u0315\u0314\3\2\2\2\u0315\u0316"+ + "\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0319\5\u00abV\2\u0318\u0317\3\2\2"+ + "\2\u0318\u0319\3\2\2\2\u0319\u032b\3\2\2\2\u031a\u031b\7\60\2\2\u031b"+ + "\u031d\5u;\2\u031c\u031e\5\u00a3R\2\u031d\u031c\3\2\2\2\u031d\u031e\3"+ + "\2\2\2\u031e\u0320\3\2\2\2\u031f\u0321\5\u00abV\2\u0320\u031f\3\2\2\2"+ + "\u0320\u0321\3\2\2\2\u0321\u032b\3\2\2\2\u0322\u0323\5u;\2\u0323\u0325"+ + "\5\u00a3R\2\u0324\u0326\5\u00abV\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2"+ + "\2\2\u0326\u032b\3\2\2\2\u0327\u0328\5u;\2\u0328\u0329\5\u00abV\2\u0329"+ + "\u032b\3\2\2\2\u032a\u030f\3\2\2\2\u032a\u031a\3\2\2\2\u032a\u0322\3\2"+ + "\2\2\u032a\u0327\3\2\2\2\u032b\u00a2\3\2\2\2\u032c\u032d\5\u00a5S\2\u032d"+ + "\u032e\5\u00a7T\2\u032e\u00a4\3\2\2\2\u032f\u0330\t\t\2\2\u0330\u00a6"+ + "\3\2\2\2\u0331\u0333\5\u00a9U\2\u0332\u0331\3\2\2\2\u0332\u0333\3\2\2"+ + "\2\u0333\u0334\3\2\2\2\u0334\u0335\5u;\2\u0335\u00a8\3\2\2\2\u0336\u0337"+ + "\t\n\2\2\u0337\u00aa\3\2\2\2\u0338\u0339\t\13\2\2\u0339\u00ac\3\2\2\2"+ + "\u033a\u033b\5\u00afX\2\u033b\u033d\5\u00b1Y\2\u033c\u033e\5\u00abV\2"+ + "\u033d\u033c\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u00ae\3\2\2\2\u033f\u0341"+ + "\5\u0081A\2\u0340\u0342\7\60\2\2\u0341\u0340\3\2\2\2\u0341\u0342\3\2\2"+ + "\2\u0342\u034b\3\2\2\2\u0343\u0344\7\62\2\2\u0344\u0346\t\4\2\2\u0345"+ + "\u0347\5\u0083B\2\u0346\u0345\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348"+ + "\3\2\2\2\u0348\u0349\7\60\2\2\u0349\u034b\5\u0083B\2\u034a\u033f\3\2\2"+ + "\2\u034a\u0343\3\2\2\2\u034b\u00b0\3\2\2\2\u034c\u034d\5\u00b3Z\2\u034d"+ + "\u034e\5\u00a7T\2\u034e\u00b2\3\2\2\2\u034f\u0350\t\f\2\2\u0350\u00b4"+ + "\3\2\2\2\u0351\u0352\7v\2\2\u0352\u0353\7t\2\2\u0353\u0354\7w\2\2\u0354"+ + "\u035b\7g\2\2\u0355\u0356\7h\2\2\u0356\u0357\7c\2\2\u0357\u0358\7n\2\2"+ + "\u0358\u0359\7u\2\2\u0359\u035b\7g\2\2\u035a\u0351\3\2\2\2\u035a\u0355"+ + "\3\2\2\2\u035b\u00b6\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\5\u00b9]\2"+ + "\u035e\u035f\7)\2\2\u035f\u0365\3\2\2\2\u0360\u0361\7)\2\2\u0361\u0362"+ + "\5\u00c1a\2\u0362\u0363\7)\2\2\u0363\u0365\3\2\2\2\u0364\u035c\3\2\2\2"+ + "\u0364\u0360\3\2\2\2\u0365\u00b8\3\2\2\2\u0366\u0367\n\r\2\2\u0367\u00ba"+ + "\3\2\2\2\u0368\u036a\7$\2\2\u0369\u036b\5\u00bd_\2\u036a\u0369\3\2\2\2"+ + "\u036a\u036b\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7$\2\2\u036d\u00bc"+ + "\3\2\2\2\u036e\u0370\5\u00bf`\2\u036f\u036e\3\2\2\2\u0370\u0371\3\2\2"+ + "\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u00be\3\2\2\2\u0373\u0376"+ + "\n\16\2\2\u0374\u0376\5\u00c1a\2\u0375\u0373\3\2\2\2\u0375\u0374\3\2\2"+ + "\2\u0376\u00c0\3\2\2\2\u0377\u0378\7^\2\2\u0378\u037c\t\17\2\2\u0379\u037c"+ + "\5\u00c3b\2\u037a\u037c\5\u00c7d\2\u037b\u0377\3\2\2\2\u037b\u0379\3\2"+ + "\2\2\u037b\u037a\3\2\2\2\u037c\u00c2\3\2\2\2\u037d\u037e\7^\2\2\u037e"+ + "\u0389\5\u008fH\2\u037f\u0380\7^\2\2\u0380\u0381\5\u008fH\2\u0381\u0382"+ + "\5\u008fH\2\u0382\u0389\3\2\2\2\u0383\u0384\7^\2\2\u0384\u0385\5\u00c5"+ + "c\2\u0385\u0386\5\u008fH\2\u0386\u0387\5\u008fH\2\u0387\u0389\3\2\2\2"+ + "\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0388\u0383\3\2\2\2\u0389\u00c4"+ + "\3\2\2\2\u038a\u038b\t\20\2\2\u038b\u00c6\3\2\2\2\u038c\u038d\7^\2\2\u038d"+ + "\u038e\7w\2\2\u038e\u038f\5\u0085C\2\u038f\u0390\5\u0085C\2\u0390\u0391"+ + "\5\u0085C\2\u0391\u0392\5\u0085C\2\u0392\u00c8\3\2\2\2\u0393\u0394\7p"+ + "\2\2\u0394\u0395\7w\2\2\u0395\u0396\7n\2\2\u0396\u0397\7n\2\2\u0397\u00ca"+ + "\3\2\2\2\u0398\u0399\7*\2\2\u0399\u00cc\3\2\2\2\u039a\u039b\7+\2\2\u039b"+ + "\u00ce\3\2\2\2\u039c\u039d\7}\2\2\u039d\u00d0\3\2\2\2\u039e\u039f\7\177"+ + "\2\2\u039f\u00d2\3\2\2\2\u03a0\u03a1\7]\2\2\u03a1\u00d4\3\2\2\2\u03a2"+ + "\u03a3\7_\2\2\u03a3\u00d6\3\2\2\2\u03a4\u03a5\7=\2\2\u03a5\u00d8\3\2\2"+ + "\2\u03a6\u03a7\7.\2\2\u03a7\u00da\3\2\2\2\u03a8\u03a9\7\60\2\2\u03a9\u00dc"+ + "\3\2\2\2\u03aa\u03ab\7?\2\2\u03ab\u00de\3\2\2\2\u03ac\u03ad\7@\2\2\u03ad"+ + "\u00e0\3\2\2\2\u03ae\u03af\7>\2\2\u03af\u00e2\3\2\2\2\u03b0\u03b1\7#\2"+ + "\2\u03b1\u00e4\3\2\2\2\u03b2\u03b3\7\u0080\2\2\u03b3\u00e6\3\2\2\2\u03b4"+ + "\u03b5\7A\2\2\u03b5\u00e8\3\2\2\2\u03b6\u03b7\7<\2\2\u03b7\u00ea\3\2\2"+ + "\2\u03b8\u03b9\7?\2\2\u03b9\u03ba\7?\2\2\u03ba\u00ec\3\2\2\2\u03bb\u03bc"+ + "\7>\2\2\u03bc\u03bd\7?\2\2\u03bd\u00ee\3\2\2\2\u03be\u03bf\7@\2\2\u03bf"+ + "\u03c0\7?\2\2\u03c0\u00f0\3\2\2\2\u03c1\u03c2\7#\2\2\u03c2\u03c3\7?\2"+ + "\2\u03c3\u00f2\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u03c6\7(\2\2\u03c6\u00f4"+ + "\3\2\2\2\u03c7\u03c8\7~\2\2\u03c8\u03c9\7~\2\2\u03c9\u00f6\3\2\2\2\u03ca"+ + "\u03cb\7-\2\2\u03cb\u03cc\7-\2\2\u03cc\u00f8\3\2\2\2\u03cd\u03ce\7/\2"+ + "\2\u03ce\u03cf\7/\2\2\u03cf\u00fa\3\2\2\2\u03d0\u03d1\7-\2\2\u03d1\u00fc"+ + "\3\2\2\2\u03d2\u03d3\7/\2\2\u03d3\u00fe\3\2\2\2\u03d4\u03d5\7,\2\2\u03d5"+ + "\u0100\3\2\2\2\u03d6\u03d7\7\61\2\2\u03d7\u0102\3\2\2\2\u03d8\u03d9\7"+ + "(\2\2\u03d9\u0104\3\2\2\2\u03da\u03db\7~\2\2\u03db\u0106\3\2\2\2\u03dc"+ + "\u03dd\7`\2\2\u03dd\u0108\3\2\2\2\u03de\u03df\7\'\2\2\u03df\u010a\3\2"+ + "\2\2\u03e0\u03e1\7/\2\2\u03e1\u03e2\7@\2\2\u03e2\u010c\3\2\2\2\u03e3\u03e4"+ + "\7<\2\2\u03e4\u03e5\7<\2\2\u03e5\u010e\3\2\2\2\u03e6\u03e7\7-\2\2\u03e7"+ + "\u03e8\7?\2\2\u03e8\u0110\3\2\2\2\u03e9\u03ea\7/\2\2\u03ea\u03eb\7?\2"+ + "\2\u03eb\u0112\3\2\2\2\u03ec\u03ed\7,\2\2\u03ed\u03ee\7?\2\2\u03ee\u0114"+ + "\3\2\2\2\u03ef\u03f0\7\61\2\2\u03f0\u03f1\7?\2\2\u03f1\u0116\3\2\2\2\u03f2"+ + "\u03f3\7(\2\2\u03f3\u03f4\7?\2\2\u03f4\u0118\3\2\2\2\u03f5\u03f6\7~\2"+ + "\2\u03f6\u03f7\7?\2\2\u03f7\u011a\3\2\2\2\u03f8\u03f9\7`\2\2\u03f9\u03fa"+ + "\7?\2\2\u03fa\u011c\3\2\2\2\u03fb\u03fc\7\'\2\2\u03fc\u03fd\7?\2\2\u03fd"+ + "\u011e\3\2\2\2\u03fe\u03ff\7>\2\2\u03ff\u0400\7>\2\2\u0400\u0401\7?\2"+ + "\2\u0401\u0120\3\2\2\2\u0402\u0403\7@\2\2\u0403\u0404\7@\2\2\u0404\u0405"+ + "\7?\2\2\u0405\u0122\3\2\2\2\u0406\u0407\7@\2\2\u0407\u0408\7@\2\2\u0408"+ + "\u0409\7@\2\2\u0409\u040a\7?\2\2\u040a\u0124\3\2\2\2\u040b\u040f\5\u0127"+ + "\u0094\2\u040c\u040e\5\u0129\u0095\2\u040d\u040c\3\2\2\2\u040e\u0411\3"+ + "\2\2\2\u040f\u040d\3\2\2\2\u040f\u0410\3\2\2\2\u0410\u0126\3\2\2\2\u0411"+ + "\u040f\3\2\2\2\u0412\u0419\t\21\2\2\u0413\u0414\n\22\2\2\u0414\u0419\6"+ + "\u0094\2\2\u0415\u0416\t\23\2\2\u0416\u0417\t\24\2\2\u0417\u0419\6\u0094"+ + "\3\2\u0418\u0412\3\2\2\2\u0418\u0413\3\2\2\2\u0418\u0415\3\2\2\2\u0419"+ + "\u0128\3\2\2\2\u041a\u0421\t\25\2\2\u041b\u041c\n\22\2\2\u041c\u0421\6"+ + "\u0095\4\2\u041d\u041e\t\23\2\2\u041e\u041f\t\24\2\2\u041f\u0421\6\u0095"+ + "\5\2\u0420\u041a\3\2\2\2\u0420\u041b\3\2\2\2\u0420\u041d\3\2\2\2\u0421"+ + "\u012a\3\2\2\2\u0422\u0423\7B\2\2\u0423\u012c\3\2\2\2\u0424\u0425\7\60"+ + "\2\2\u0425\u0426\7\60\2\2\u0426\u0427\7\60\2\2\u0427\u012e\3\2\2\2\u0428"+ + "\u042a\t\26\2\2\u0429\u0428\3\2\2\2\u042a\u042b\3\2\2\2\u042b\u0429\3"+ + "\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042e\b\u0098\2\2"+ + "\u042e\u0130\3\2\2\2\u042f\u0430\7\61\2\2\u0430\u0431\7,\2\2\u0431\u0435"+ + "\3\2\2\2\u0432\u0434\13\2\2\2\u0433\u0432\3\2\2\2\u0434\u0437\3\2\2\2"+ + "\u0435\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\3\2\2\2\u0437\u0435"+ + "\3\2\2\2\u0438\u0439\7,\2\2\u0439\u043a\7\61\2\2\u043a\u043b\3\2\2\2\u043b"+ + "\u043c\b\u0099\2\2\u043c\u0132\3\2\2\2\u043d\u043e\7\61\2\2\u043e\u043f"+ + "\7\61\2\2\u043f\u0443\3\2\2\2\u0440\u0442\n\27\2\2\u0441\u0440\3\2\2\2"+ + "\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2\2\2\u0444\u0446"+ + "\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\b\u009a\2\2\u0447\u0134\3\2\2"+ + "\28\2\u028c\u0290\u0294\u0298\u029c\u02a3\u02a8\u02aa\u02ae\u02b1\u02b5"+ + "\u02bc\u02c0\u02c5\u02cd\u02d0\u02d7\u02db\u02df\u02e5\u02e8\u02ef\u02f3"+ + "\u02fb\u02fe\u0305\u0309\u030d\u0312\u0315\u0318\u031d\u0320\u0325\u032a"+ + "\u0332\u033d\u0341\u0346\u034a\u035a\u0364\u036a\u0371\u0375\u037b\u0388"+ + "\u040f\u0418\u0420\u042b\u0435\u0443\3\b\2\2"; + 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); + } + } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.tokens similarity index 81% rename from i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens rename to i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.tokens index 22c63e5..52ef1ee 100644 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Lexer.tokens @@ -1,201 +1,205 @@ -PACKAGE=32 -LT=68 -WHILE=50 -MOD=88 -CONST=10 -MOD_ASSIGN=96 +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 CASE=6 -NEW=31 +CATCH=7 CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 DO=13 -DIV_ASSIGN=92 -BREAK=4 -Identifier=100 -NOTEQUAL=76 -MUL_ASSIGN=91 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 FINAL=18 -RPAREN=58 -INC=79 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 IMPORT=25 -CARET=87 -THIS=43 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 RETURN=36 -DOUBLE=14 -VOID=48 -SUPER=40 -GOTO=23 -COMMENT=104 -RBRACK=62 -LSHIFT_ASSIGN=97 -GE=75 -RBRACE=60 -LINE_COMMENT=105 +SHORT=37 STATIC=38 -PRIVATE=33 -ADD_ASSIGN=89 -SWITCH=41 STRICTFP=39 -ELSE=15 -ELLIPSIS=102 -NATIVE=30 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 THROWS=45 -INT=27 -ASSERT=2 -MUL=83 +TRANSIENT=46 TRY=47 -WS=103 -BITOR=86 +VOID=48 +VOLATILE=49 +WHILE=50 +IntegerLiteral=51 FloatingPointLiteral=52 -OR=78 -GT=67 -CATCH=7 -THROW=44 BooleanLiteral=53 -PROTECTED=34 -DEC=80 -CLASS=9 -NullLiteral=56 -LBRACK=61 CharacterLiteral=54 -LBRACE=59 -FOR=21 -SUB=82 -FLOAT=20 -ABSTRACT=1 -AND=77 -AND_ASSIGN=93 -BITAND=85 +StringLiteral=55 +NullLiteral=56 LPAREN=57 -IF=22 -AT=101 -SYNCHRONIZED=42 -BOOLEAN=3 -IMPLEMENTS=24 -CONTINUE=11 +RPAREN=58 +LBRACE=59 +RBRACE=60 +LBRACK=61 +RBRACK=62 +SEMI=63 COMMA=64 -TRANSIENT=46 -EQUAL=73 -XOR_ASSIGN=95 -TILDE=70 DOT=65 -ADD=81 -BYTE=5 -VOLATILE=49 -DEFAULT=12 -SHORT=37 +ASSIGN=66 +GT=67 +LT=68 BANG=69 -INSTANCEOF=26 -RSHIFT_ASSIGN=98 -SEMI=63 -StringLiteral=55 -COLON=72 -OR_ASSIGN=94 -ENUM=16 +TILDE=70 QUESTION=71 -FINALLY=19 -URSHIFT_ASSIGN=99 -ASSIGN=66 -INTERFACE=28 -IntegerLiteral=51 -DIV=84 -LONG=29 -PUBLIC=35 -EXTENDS=17 -SUB_ASSIGN=90 +COLON=72 +EQUAL=73 LE=74 -'instanceof'=26 -'>='=75 -'~'=70 -'/'=84 -'=='=73 -'/='=92 -'switch'=41 -'%='=96 -'implements'=24 -'>'=67 -'||'=78 -'this'=43 -'&&'=77 -';'=63 -'volatile'=49 -'return'=36 -'for'=21 -'protected'=34 -'+'=81 -'.'=65 -'^'=87 +GE=75 +NOTEQUAL=76 +AND=77 +OR=78 +INC=79 +DEC=80 +ADD=81 +SUB=82 +MUL=83 +DIV=84 +BITAND=85 +BITOR=86 +CARET=87 +MOD=88 +ARROW=89 +COLONCOLON=90 +ADD_ASSIGN=91 +SUB_ASSIGN=92 +MUL_ASSIGN=93 +DIV_ASSIGN=94 +AND_ASSIGN=95 +OR_ASSIGN=96 +XOR_ASSIGN=97 +MOD_ASSIGN=98 +LSHIFT_ASSIGN=99 +RSHIFT_ASSIGN=100 +URSHIFT_ASSIGN=101 +Identifier=102 +AT=103 +ELLIPSIS=104 +WS=105 +COMMENT=106 +LINE_COMMENT=107 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 'byte'=5 -'import'=25 -'++'=79 -'static'=38 -'else'=15 +'case'=6 'catch'=7 -'final'=18 -'^='=95 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 'extends'=17 -'+='=89 +'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 -'break'=4 -'...'=102 -'{'=59 -'>>='=98 +'new'=31 'package'=32 -'>>>='=99 -'void'=48 -'?'=71 -'try'=47 'private'=33 -'int'=27 -'&='=93 -'if'=22 -':'=72 -'('=57 -'-'=82 -'while'=50 -','=64 -'synchronized'=42 -'default'=12 +'protected'=34 'public'=35 -'-='=90 -'<<='=97 -']'=62 +'return'=36 'short'=37 -'long'=29 -'enum'=16 -'!'=69 -'transient'=46 -'|'=86 -'finally'=19 -'assert'=2 -'class'=9 -'new'=31 -'|='=94 +'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 'null'=56 -'const'=10 -'goto'=23 -'='=66 -'@'=101 -'throw'=44 +'('=57 ')'=58 -'*='=91 -'%'=88 -'do'=13 -'super'=40 -'case'=6 -'char'=8 -'strictfp'=39 -'float'=20 +'{'=59 '}'=60 -'boolean'=3 -'abstract'=1 -'double'=14 +'['=61 +']'=62 +';'=63 +','=64 +'.'=65 +'='=66 +'>'=67 +'<'=68 +'!'=69 +'~'=70 +'?'=71 +':'=72 +'=='=73 '<='=74 +'>='=75 '!='=76 -'continue'=11 +'&&'=77 +'||'=78 +'++'=79 '--'=80 -'<'=68 +'+'=81 +'-'=82 '*'=83 -'['=61 +'/'=84 '&'=85 -'interface'=28 +'|'=86 +'^'=87 +'%'=88 +'->'=89 +'::'=90 +'+='=91 +'-='=92 +'*='=93 +'/='=94 +'&='=95 +'|='=96 +'^='=97 +'%='=98 +'<<='=99 +'>>='=100 +'>>>='=101 +'@'=103 +'...'=104 diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Parser.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Parser.java new file mode 100644 index 0000000..7bfa734 --- /dev/null +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Parser.java @@ -0,0 +1,17870 @@ +// Generated from i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +package org.nuiton.i18n.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ARROW=89, COLONCOLON=90, + ADD_ASSIGN=91, SUB_ASSIGN=92, MUL_ASSIGN=93, DIV_ASSIGN=94, AND_ASSIGN=95, + OR_ASSIGN=96, XOR_ASSIGN=97, MOD_ASSIGN=98, LSHIFT_ASSIGN=99, RSHIFT_ASSIGN=100, + URSHIFT_ASSIGN=101, Identifier=102, AT=103, ELLIPSIS=104, WS=105, COMMENT=106, + LINE_COMMENT=107; + public static final int + RULE_literal = 0, RULE_type = 1, RULE_primitiveType = 2, RULE_numericType = 3, + RULE_integralType = 4, RULE_floatingPointType = 5, RULE_referenceType = 6, + RULE_classOrInterfaceType = 7, RULE_classType = 8, RULE_classType_lf_classOrInterfaceType = 9, + RULE_classType_lfno_classOrInterfaceType = 10, RULE_interfaceType = 11, + RULE_interfaceType_lf_classOrInterfaceType = 12, RULE_interfaceType_lfno_classOrInterfaceType = 13, + RULE_typeVariable = 14, RULE_arrayType = 15, RULE_dims = 16, RULE_typeParameter = 17, + RULE_typeParameterModifier = 18, RULE_typeBound = 19, RULE_additionalBound = 20, + RULE_typeArguments = 21, RULE_typeArgumentList = 22, RULE_typeArgument = 23, + RULE_wildcard = 24, RULE_wildcardBounds = 25, RULE_packageName = 26, RULE_typeName = 27, + RULE_packageOrTypeName = 28, RULE_expressionName = 29, RULE_methodName = 30, + RULE_ambiguousName = 31, RULE_compilationUnit = 32, RULE_packageDeclaration = 33, + RULE_packageModifier = 34, RULE_importDeclaration = 35, RULE_singleTypeImportDeclaration = 36, + RULE_typeImportOnDemandDeclaration = 37, RULE_singleStaticImportDeclaration = 38, + RULE_staticImportOnDemandDeclaration = 39, RULE_typeDeclaration = 40, + RULE_classDeclaration = 41, RULE_normalClassDeclaration = 42, RULE_classModifier = 43, + RULE_typeParameters = 44, RULE_typeParameterList = 45, RULE_superclass = 46, + RULE_superinterfaces = 47, RULE_interfaceTypeList = 48, RULE_classBody = 49, + RULE_classBodyDeclaration = 50, RULE_classMemberDeclaration = 51, RULE_fieldDeclaration = 52, + RULE_fieldModifier = 53, RULE_variableDeclaratorList = 54, RULE_variableDeclarator = 55, + RULE_variableDeclaratorId = 56, RULE_variableInitializer = 57, RULE_unannType = 58, + RULE_unannPrimitiveType = 59, RULE_unannReferenceType = 60, RULE_unannClassOrInterfaceType = 61, + RULE_unannClassType = 62, RULE_unannClassType_lf_unannClassOrInterfaceType = 63, + RULE_unannClassType_lfno_unannClassOrInterfaceType = 64, RULE_unannInterfaceType = 65, + RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 66, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 67, + RULE_unannTypeVariable = 68, RULE_unannArrayType = 69, RULE_methodDeclaration = 70, + RULE_methodModifier = 71, RULE_methodHeader = 72, RULE_result = 73, RULE_methodDeclarator = 74, + RULE_formalParameterList = 75, RULE_formalParameters = 76, RULE_formalParameter = 77, + RULE_variableModifier = 78, RULE_lastFormalParameter = 79, RULE_receiverParameter = 80, + RULE_throws_ = 81, RULE_exceptionTypeList = 82, RULE_exceptionType = 83, + RULE_methodBody = 84, RULE_instanceInitializer = 85, RULE_staticInitializer = 86, + RULE_constructorDeclaration = 87, RULE_constructorModifier = 88, RULE_constructorDeclarator = 89, + RULE_simpleTypeName = 90, RULE_constructorBody = 91, RULE_explicitConstructorInvocation = 92, + RULE_enumDeclaration = 93, RULE_enumBody = 94, RULE_enumConstantList = 95, + RULE_enumConstant = 96, RULE_enumConstantModifier = 97, RULE_enumBodyDeclarations = 98, + RULE_interfaceDeclaration = 99, RULE_normalInterfaceDeclaration = 100, + RULE_interfaceModifier = 101, RULE_extendsInterfaces = 102, RULE_interfaceBody = 103, + RULE_interfaceMemberDeclaration = 104, RULE_constantDeclaration = 105, + RULE_constantModifier = 106, RULE_interfaceMethodDeclaration = 107, RULE_interfaceMethodModifier = 108, + RULE_annotationTypeDeclaration = 109, RULE_annotationTypeBody = 110, RULE_annotationTypeMemberDeclaration = 111, + RULE_annotationTypeElementDeclaration = 112, RULE_annotationTypeElementModifier = 113, + RULE_defaultValue = 114, RULE_annotation = 115, RULE_normalAnnotation = 116, + RULE_elementValuePairList = 117, RULE_elementValuePair = 118, RULE_elementValue = 119, + RULE_elementValueArrayInitializer = 120, RULE_elementValueList = 121, + RULE_markerAnnotation = 122, RULE_singleElementAnnotation = 123, RULE_arrayInitializer = 124, + RULE_variableInitializerList = 125, RULE_block = 126, RULE_blockStatements = 127, + RULE_blockStatement = 128, RULE_localVariableDeclarationStatement = 129, + RULE_localVariableDeclaration = 130, RULE_statement = 131, RULE_statementNoShortIf = 132, + RULE_statementWithoutTrailingSubstatement = 133, RULE_emptyStatement = 134, + RULE_labeledStatement = 135, RULE_labeledStatementNoShortIf = 136, RULE_expressionStatement = 137, + RULE_statementExpression = 138, RULE_ifThenStatement = 139, RULE_ifThenElseStatement = 140, + RULE_ifThenElseStatementNoShortIf = 141, RULE_assertStatement = 142, RULE_switchStatement = 143, + RULE_switchBlock = 144, RULE_switchBlockStatementGroup = 145, RULE_switchLabels = 146, + RULE_switchLabel = 147, RULE_enumConstantName = 148, RULE_whileStatement = 149, + RULE_whileStatementNoShortIf = 150, RULE_doStatement = 151, RULE_forStatement = 152, + RULE_forStatementNoShortIf = 153, RULE_basicForStatement = 154, RULE_basicForStatementNoShortIf = 155, + RULE_forInit = 156, RULE_forUpdate = 157, RULE_statementExpressionList = 158, + RULE_enhancedForStatement = 159, RULE_enhancedForStatementNoShortIf = 160, + RULE_breakStatement = 161, RULE_continueStatement = 162, RULE_returnStatement = 163, + RULE_throwStatement = 164, RULE_synchronizedStatement = 165, RULE_tryStatement = 166, + RULE_catches = 167, RULE_catchClause = 168, RULE_catchFormalParameter = 169, + RULE_catchType = 170, RULE_finally_ = 171, RULE_tryWithResourcesStatement = 172, + RULE_resourceSpecification = 173, RULE_resourceList = 174, RULE_resource = 175, + RULE_primary = 176, RULE_primaryNoNewArray = 177, RULE_primaryNoNewArray_lf_arrayAccess = 178, + RULE_primaryNoNewArray_lfno_arrayAccess = 179, RULE_primaryNoNewArray_lf_primary = 180, + RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 181, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 182, + RULE_primaryNoNewArray_lfno_primary = 183, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 184, + RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 185, + RULE_classInstanceCreationExpression = 186, RULE_classInstanceCreationExpression_lf_primary = 187, + RULE_classInstanceCreationExpression_lfno_primary = 188, RULE_typeArgumentsOrDiamond = 189, + RULE_fieldAccess = 190, RULE_fieldAccess_lf_primary = 191, RULE_fieldAccess_lfno_primary = 192, + RULE_arrayAccess = 193, RULE_arrayAccess_lf_primary = 194, RULE_arrayAccess_lfno_primary = 195, + RULE_methodInvocation = 196, RULE_methodInvocation_lf_primary = 197, RULE_methodInvocation_lfno_primary = 198, + RULE_argumentList = 199, RULE_methodReference = 200, RULE_methodReference_lf_primary = 201, + RULE_methodReference_lfno_primary = 202, RULE_arrayCreationExpression = 203, + RULE_dimExprs = 204, RULE_dimExpr = 205, RULE_constantExpression = 206, + RULE_expression = 207, RULE_lambdaExpression = 208, RULE_lambdaParameters = 209, + RULE_inferredFormalParameterList = 210, RULE_lambdaBody = 211, RULE_assignmentExpression = 212, + RULE_assignment = 213, RULE_leftHandSide = 214, RULE_assignmentOperator = 215, + RULE_conditionalExpression = 216, RULE_conditionalOrExpression = 217, + RULE_conditionalAndExpression = 218, RULE_inclusiveOrExpression = 219, + RULE_exclusiveOrExpression = 220, RULE_andExpression = 221, RULE_equalityExpression = 222, + RULE_relationalExpression = 223, RULE_shiftExpression = 224, RULE_additiveExpression = 225, + RULE_multiplicativeExpression = 226, RULE_unaryExpression = 227, RULE_preIncrementExpression = 228, + RULE_preDecrementExpression = 229, RULE_unaryExpressionNotPlusMinus = 230, + RULE_postfixExpression = 231, RULE_postIncrementExpression = 232, RULE_postIncrementExpression_lf_postfixExpression = 233, + RULE_postDecrementExpression = 234, RULE_postDecrementExpression_lf_postfixExpression = 235, + RULE_castExpression = 236; + public static final String[] ruleNames = { + "literal", "type", "primitiveType", "numericType", "integralType", "floatingPointType", + "referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", + "classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", + "interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", + "dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", + "typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", + "packageName", "typeName", "packageOrTypeName", "expressionName", "methodName", + "ambiguousName", "compilationUnit", "packageDeclaration", "packageModifier", + "importDeclaration", "singleTypeImportDeclaration", "typeImportOnDemandDeclaration", + "singleStaticImportDeclaration", "staticImportOnDemandDeclaration", "typeDeclaration", + "classDeclaration", "normalClassDeclaration", "classModifier", "typeParameters", + "typeParameterList", "superclass", "superinterfaces", "interfaceTypeList", + "classBody", "classBodyDeclaration", "classMemberDeclaration", "fieldDeclaration", + "fieldModifier", "variableDeclaratorList", "variableDeclarator", "variableDeclaratorId", + "variableInitializer", "unannType", "unannPrimitiveType", "unannReferenceType", + "unannClassOrInterfaceType", "unannClassType", "unannClassType_lf_unannClassOrInterfaceType", + "unannClassType_lfno_unannClassOrInterfaceType", "unannInterfaceType", + "unannInterfaceType_lf_unannClassOrInterfaceType", "unannInterfaceType_lfno_unannClassOrInterfaceType", + "unannTypeVariable", "unannArrayType", "methodDeclaration", "methodModifier", + "methodHeader", "result", "methodDeclarator", "formalParameterList", "formalParameters", + "formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", + "throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", + "staticInitializer", "constructorDeclaration", "constructorModifier", + "constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", + "enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", + "enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", + "interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", + "constantDeclaration", "constantModifier", "interfaceMethodDeclaration", + "interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", + "annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", + "annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", + "elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", + "elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", + "variableInitializerList", "block", "blockStatements", "blockStatement", + "localVariableDeclarationStatement", "localVariableDeclaration", "statement", + "statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement", + "labeledStatement", "labeledStatementNoShortIf", "expressionStatement", + "statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", + "assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", + "switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", + "doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", + "basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", + "enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", + "continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", + "tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", + "finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", + "resource", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", + "primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", + "primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", + "primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", + "primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classInstanceCreationExpression", + "classInstanceCreationExpression_lf_primary", "classInstanceCreationExpression_lfno_primary", + "typeArgumentsOrDiamond", "fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", + "arrayAccess", "arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", + "methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", + "methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", + "arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", + "expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", + "lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", + "conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", + "inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", + "relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", + "unaryExpression", "preIncrementExpression", "preDecrementExpression", + "unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", + "postIncrementExpression_lf_postfixExpression", "postDecrementExpression", + "postDecrementExpression_lf_postfixExpression", "castExpression" + }; + + private static final String[] _LITERAL_NAMES = { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, + null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", + "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", + "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", + "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", + "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", + "'>>>='", null, "'@'", "'...'" + }; + private static final String[] _SYMBOLIC_NAMES = { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", + "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", + "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", + "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "FloatingPointLiteral", + "BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", + "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", + "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", "ADD_ASSIGN", + "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", + "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT" + }; + 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 "Java8.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public Java8Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + public static class LiteralContext extends ParserRuleContext { + public TerminalNode IntegerLiteral() { return getToken(Java8Parser.IntegerLiteral, 0); } + public TerminalNode FloatingPointLiteral() { return getToken(Java8Parser.FloatingPointLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(Java8Parser.BooleanLiteral, 0); } + public TerminalNode CharacterLiteral() { return getToken(Java8Parser.CharacterLiteral, 0); } + public TerminalNode StringLiteral() { return getToken(Java8Parser.StringLiteral, 0); } + public TerminalNode NullLiteral() { return getToken(Java8Parser.NullLiteral, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(474); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public TypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_type; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitType(this); + else return visitor.visitChildren(this); + } + } + + public final TypeContext type() throws RecognitionException { + TypeContext _localctx = new TypeContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_type); + try { + setState(478); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(476); + primitiveType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(477); + referenceType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimitiveTypeContext extends ParserRuleContext { + public NumericTypeContext numericType() { + return getRuleContext(NumericTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primitiveType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimitiveType(this); + else return visitor.visitChildren(this); + } + } + + public final PrimitiveTypeContext primitiveType() throws RecognitionException { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_primitiveType); + int _la; + try { + setState(494); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(483); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(480); + annotation(); + } + } + setState(485); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(486); + numericType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(490); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(487); + annotation(); + } + } + setState(492); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(493); + match(BOOLEAN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NumericTypeContext extends ParserRuleContext { + public IntegralTypeContext integralType() { + return getRuleContext(IntegralTypeContext.class,0); + } + public FloatingPointTypeContext floatingPointType() { + return getRuleContext(FloatingPointTypeContext.class,0); + } + public NumericTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_numericType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNumericType(this); + else return visitor.visitChildren(this); + } + } + + public final NumericTypeContext numericType() throws RecognitionException { + NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_numericType); + try { + setState(498); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 1); + { + setState(496); + integralType(); + } + break; + case DOUBLE: + case FLOAT: + enterOuterAlt(_localctx, 2); + { + setState(497); + floatingPointType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IntegralTypeContext extends ParserRuleContext { + public IntegralTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integralType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIntegralType(this); + else return visitor.visitChildren(this); + } + } + + public final IntegralTypeContext integralType() throws RecognitionException { + IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_integralType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(500); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FloatingPointTypeContext extends ParserRuleContext { + public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_floatingPointType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFloatingPointType(this); + else return visitor.visitChildren(this); + } + } + + public final FloatingPointTypeContext floatingPointType() throws RecognitionException { + FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_floatingPointType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(502); + _la = _input.LA(1); + if ( !(_la==DOUBLE || _la==FLOAT) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReferenceTypeContext extends ParserRuleContext { + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public ReferenceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_referenceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReferenceType(this); + else return visitor.visitChildren(this); + } + } + + public final ReferenceTypeContext referenceType() throws RecognitionException { + ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_referenceType); + try { + setState(507); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(504); + classOrInterfaceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(505); + typeVariable(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(506); + arrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() { + return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0); + } + public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() { + return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class); + } + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) { + return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i); + } + public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() { + return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class); + } + public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) { + return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i); + } + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { + ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_classOrInterfaceType); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(511); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { + case 1: + { + setState(509); + classType_lfno_classOrInterfaceType(); + } + break; + case 2: + { + setState(510); + interfaceType_lfno_classOrInterfaceType(); + } + break; + } + setState(517); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(515); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + { + setState(513); + classType_lf_classOrInterfaceType(); + } + break; + case 2: + { + setState(514); + interfaceType_lf_classOrInterfaceType(); + } + break; + } + } + } + setState(519); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,8,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public ClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassTypeContext classType() throws RecognitionException { + ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_classType); + int _la; + try { + setState(542); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(523); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(520); + annotation(); + } + } + setState(525); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(526); + match(Identifier); + setState(528); + _la = _input.LA(1); + if (_la==LT) { + { + setState(527); + typeArguments(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(530); + classOrInterfaceType(); + setState(531); + match(DOT); + setState(535); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(532); + annotation(); + } + } + setState(537); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(538); + match(Identifier); + setState(540); + _la = _input.LA(1); + if (_la==LT) { + { + setState(539); + typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType_lf_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException { + ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_classType_lf_classOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(544); + match(DOT); + setState(548); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(545); + annotation(); + } + } + setState(550); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(551); + match(Identifier); + setState(553); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { + case 1: + { + setState(552); + typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassType_lfno_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException { + ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_classType_lfno_classOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(558); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(555); + annotation(); + } + } + setState(560); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(561); + match(Identifier); + setState(563); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + { + setState(562); + typeArguments(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceTypeContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public InterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceTypeContext interfaceType() throws RecognitionException { + InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_interfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(565); + classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() { + return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType_lf_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException { + InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_interfaceType_lf_classOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(567); + classType_lf_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext { + public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() { + return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0); + } + public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceType_lfno_classOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException { + InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_interfaceType_lfno_classOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(569); + classType_lfno_classOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeVariableContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeVariable; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeVariable(this); + else return visitor.visitChildren(this); + } + } + + public final TypeVariableContext typeVariable() throws RecognitionException { + TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_typeVariable); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(574); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(571); + annotation(); + } + } + setState(576); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(577); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayTypeContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ArrayTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayType(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayTypeContext arrayType() throws RecognitionException { + ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_arrayType); + try { + setState(588); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(579); + primitiveType(); + setState(580); + dims(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(582); + classOrInterfaceType(); + setState(583); + dims(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(585); + typeVariable(); + setState(586); + dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimsContext extends ParserRuleContext { + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public DimsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dims; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDims(this); + else return visitor.visitChildren(this); + } + } + + public final DimsContext dims() throws RecognitionException { + DimsContext _localctx = new DimsContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_dims); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(593); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(590); + annotation(); + } + } + setState(595); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(596); + match(LBRACK); + setState(597); + match(RBRACK); + setState(608); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,22,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(601); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(598); + annotation(); + } + } + setState(603); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(604); + match(LBRACK); + setState(605); + match(RBRACK); + } + } + } + setState(610); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,22,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<TypeParameterModifierContext> typeParameterModifier() { + return getRuleContexts(TypeParameterModifierContext.class); + } + public TypeParameterModifierContext typeParameterModifier(int i) { + return getRuleContext(TypeParameterModifierContext.class,i); + } + public TypeBoundContext typeBound() { + return getRuleContext(TypeBoundContext.class,0); + } + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(614); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(611); + typeParameterModifier(); + } + } + setState(616); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(617); + match(Identifier); + setState(619); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(618); + typeBound(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameterModifier(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { + TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_typeParameterModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeBoundContext extends ParserRuleContext { + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public List<AdditionalBoundContext> additionalBound() { + return getRuleContexts(AdditionalBoundContext.class); + } + public AdditionalBoundContext additionalBound(int i) { + return getRuleContext(AdditionalBoundContext.class,i); + } + public TypeBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeBound; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeBound(this); + else return visitor.visitChildren(this); + } + } + + public final TypeBoundContext typeBound() throws RecognitionException { + TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_typeBound); + int _la; + try { + setState(633); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(623); + match(EXTENDS); + setState(624); + typeVariable(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(625); + match(EXTENDS); + setState(626); + classOrInterfaceType(); + setState(630); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(627); + additionalBound(); + } + } + setState(632); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AdditionalBoundContext extends ParserRuleContext { + public InterfaceTypeContext interfaceType() { + return getRuleContext(InterfaceTypeContext.class,0); + } + public AdditionalBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additionalBound; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAdditionalBound(this); + else return visitor.visitChildren(this); + } + } + + public final AdditionalBoundContext additionalBound() throws RecognitionException { + AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_additionalBound); + try { + enterOuterAlt(_localctx, 1); + { + setState(635); + match(BITAND); + setState(636); + interfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentsContext extends ParserRuleContext { + public TypeArgumentListContext typeArgumentList() { + return getRuleContext(TypeArgumentListContext.class,0); + } + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArguments; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_typeArguments); + try { + enterOuterAlt(_localctx, 1); + { + setState(638); + match(LT); + setState(639); + typeArgumentList(); + setState(640); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentListContext extends ParserRuleContext { + public List<TypeArgumentContext> typeArgument() { + return getRuleContexts(TypeArgumentContext.class); + } + public TypeArgumentContext typeArgument(int i) { + return getRuleContext(TypeArgumentContext.class,i); + } + public TypeArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentListContext typeArgumentList() throws RecognitionException { + TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_typeArgumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(642); + typeArgument(); + setState(647); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(643); + match(COMMA); + setState(644); + typeArgument(); + } + } + setState(649); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentContext extends ParserRuleContext { + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public WildcardContext wildcard() { + return getRuleContext(WildcardContext.class,0); + } + public TypeArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgument; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgument(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentContext typeArgument() throws RecognitionException { + TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_typeArgument); + try { + setState(652); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(650); + referenceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(651); + wildcard(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WildcardContext extends ParserRuleContext { + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public WildcardBoundsContext wildcardBounds() { + return getRuleContext(WildcardBoundsContext.class,0); + } + public WildcardContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_wildcard; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWildcard(this); + else return visitor.visitChildren(this); + } + } + + public final WildcardContext wildcard() throws RecognitionException { + WildcardContext _localctx = new WildcardContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_wildcard); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(657); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(654); + annotation(); + } + } + setState(659); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(660); + match(QUESTION); + setState(662); + _la = _input.LA(1); + if (_la==EXTENDS || _la==SUPER) { + { + setState(661); + wildcardBounds(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WildcardBoundsContext extends ParserRuleContext { + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public WildcardBoundsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_wildcardBounds; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWildcardBounds(this); + else return visitor.visitChildren(this); + } + } + + public final WildcardBoundsContext wildcardBounds() throws RecognitionException { + WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_wildcardBounds); + try { + setState(668); + switch (_input.LA(1)) { + case EXTENDS: + enterOuterAlt(_localctx, 1); + { + setState(664); + match(EXTENDS); + setState(665); + referenceType(); + } + break; + case SUPER: + enterOuterAlt(_localctx, 2); + { + setState(666); + match(SUPER); + setState(667); + referenceType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageNameContext packageName() { + return getRuleContext(PackageNameContext.class,0); + } + public PackageNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageName(this); + else return visitor.visitChildren(this); + } + } + + public final PackageNameContext packageName() throws RecognitionException { + return packageName(0); + } + + private PackageNameContext packageName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState); + PackageNameContext _prevctx = _localctx; + int _startState = 52; + enterRecursionRule(_localctx, 52, RULE_packageName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(671); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(678); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_packageName); + setState(673); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(674); + match(DOT); + setState(675); + match(Identifier); + } + } + } + setState(680); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,32,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class TypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public TypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final TypeNameContext typeName() throws RecognitionException { + TypeNameContext _localctx = new TypeNameContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_typeName); + try { + setState(686); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(681); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(682); + packageOrTypeName(0); + setState(683); + match(DOT); + setState(684); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageOrTypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageOrTypeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageOrTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException { + return packageOrTypeName(0); + } + + private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState); + PackageOrTypeNameContext _prevctx = _localctx; + int _startState = 56; + enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(689); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(696); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new PackageOrTypeNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName); + setState(691); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(692); + match(DOT); + setState(693); + match(Identifier); + } + } + } + setState(698); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ExpressionNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AmbiguousNameContext ambiguousName() { + return getRuleContext(AmbiguousNameContext.class,0); + } + public ExpressionNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpressionName(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionNameContext expressionName() throws RecognitionException { + ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_expressionName); + try { + setState(704); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(699); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(700); + ambiguousName(0); + setState(701); + match(DOT); + setState(702); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public MethodNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodName(this); + else return visitor.visitChildren(this); + } + } + + public final MethodNameContext methodName() throws RecognitionException { + MethodNameContext _localctx = new MethodNameContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_methodName); + try { + enterOuterAlt(_localctx, 1); + { + setState(706); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AmbiguousNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AmbiguousNameContext ambiguousName() { + return getRuleContext(AmbiguousNameContext.class,0); + } + public AmbiguousNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ambiguousName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAmbiguousName(this); + else return visitor.visitChildren(this); + } + } + + public final AmbiguousNameContext ambiguousName() throws RecognitionException { + return ambiguousName(0); + } + + private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState); + AmbiguousNameContext _prevctx = _localctx; + int _startState = 62; + enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(709); + match(Identifier); + } + _ctx.stop = _input.LT(-1); + setState(716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AmbiguousNameContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName); + setState(711); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(712); + match(DOT); + setState(713); + match(Identifier); + } + } + } + setState(718); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class CompilationUnitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(Java8Parser.EOF, 0); } + public PackageDeclarationContext packageDeclaration() { + return getRuleContext(PackageDeclarationContext.class,0); + } + public List<ImportDeclarationContext> importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class,i); + } + public List<TypeDeclarationContext> typeDeclaration() { + return getRuleContexts(TypeDeclarationContext.class); + } + public TypeDeclarationContext typeDeclaration(int i) { + return getRuleContext(TypeDeclarationContext.class,i); + } + public CompilationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compilationUnit; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCompilationUnit(this); + else return visitor.visitChildren(this); + } + } + + public final CompilationUnitContext compilationUnit() throws RecognitionException { + CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_compilationUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(720); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + case 1: + { + setState(719); + packageDeclaration(); + } + break; + } + setState(725); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IMPORT) { + { + { + setState(722); + importDeclaration(); + } + } + setState(727); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(731); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) { + { + { + setState(728); + typeDeclaration(); + } + } + setState(733); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(734); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageDeclarationContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public List<PackageModifierContext> packageModifier() { + return getRuleContexts(PackageModifierContext.class); + } + public PackageModifierContext packageModifier(int i) { + return getRuleContext(PackageModifierContext.class,i); + } + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final PackageDeclarationContext packageDeclaration() throws RecognitionException { + PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_packageDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(739); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(736); + packageModifier(); + } + } + setState(741); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(742); + match(PACKAGE); + setState(743); + match(Identifier); + setState(748); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(744); + match(DOT); + setState(745); + match(Identifier); + } + } + setState(750); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(751); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public PackageModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPackageModifier(this); + else return visitor.visitChildren(this); + } + } + + public final PackageModifierContext packageModifier() throws RecognitionException { + PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_packageModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(753); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ImportDeclarationContext extends ParserRuleContext { + public SingleTypeImportDeclarationContext singleTypeImportDeclaration() { + return getRuleContext(SingleTypeImportDeclarationContext.class,0); + } + public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() { + return getRuleContext(TypeImportOnDemandDeclarationContext.class,0); + } + public SingleStaticImportDeclarationContext singleStaticImportDeclaration() { + return getRuleContext(SingleStaticImportDeclarationContext.class,0); + } + public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() { + return getRuleContext(StaticImportOnDemandDeclarationContext.class,0); + } + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ImportDeclarationContext importDeclaration() throws RecognitionException { + ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_importDeclaration); + try { + setState(759); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(755); + singleTypeImportDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(756); + typeImportOnDemandDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(757); + singleStaticImportDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(758); + staticImportOnDemandDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleTypeImportDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleTypeImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException { + SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_singleTypeImportDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(761); + match(IMPORT); + setState(762); + typeName(); + setState(763); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext { + public PackageOrTypeNameContext packageOrTypeName() { + return getRuleContext(PackageOrTypeNameContext.class,0); + } + public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeImportOnDemandDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException { + TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_typeImportOnDemandDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(765); + match(IMPORT); + setState(766); + packageOrTypeName(0); + setState(767); + match(DOT); + setState(768); + match(MUL); + setState(769); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleStaticImportDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleStaticImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException { + SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_singleStaticImportDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(771); + match(IMPORT); + setState(772); + match(STATIC); + setState(773); + typeName(); + setState(774); + match(DOT); + setState(775); + match(Identifier); + setState(776); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStaticImportOnDemandDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException { + StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_staticImportOnDemandDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(778); + match(IMPORT); + setState(779); + match(STATIC); + setState(780); + typeName(); + setState(781); + match(DOT); + setState(782); + match(MUL); + setState(783); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeDeclarationContext typeDeclaration() throws RecognitionException { + TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_typeDeclaration); + try { + setState(788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(785); + classDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(786); + interfaceDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(787); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassDeclarationContext extends ParserRuleContext { + public NormalClassDeclarationContext normalClassDeclaration() { + return getRuleContext(NormalClassDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_classDeclaration); + try { + setState(792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(790); + normalClassDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(791); + enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalClassDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public List<ClassModifierContext> classModifier() { + return getRuleContexts(ClassModifierContext.class); + } + public ClassModifierContext classModifier(int i) { + return getRuleContext(ClassModifierContext.class,i); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public SuperclassContext superclass() { + return getRuleContext(SuperclassContext.class,0); + } + public SuperinterfacesContext superinterfaces() { + return getRuleContext(SuperinterfacesContext.class,0); + } + public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalClassDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException { + NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_normalClassDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(797); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(794); + classModifier(); + } + } + setState(799); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(800); + match(CLASS); + setState(801); + match(Identifier); + setState(803); + _la = _input.LA(1); + if (_la==LT) { + { + setState(802); + typeParameters(); + } + } + + setState(806); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(805); + superclass(); + } + } + + setState(809); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(808); + superinterfaces(); + } + } + + setState(811); + classBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ClassModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ClassModifierContext classModifier() throws RecognitionException { + ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_classModifier); + try { + setState(821); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(813); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(814); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(815); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(816); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(817); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(818); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 7); + { + setState(819); + match(FINAL); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 8); + { + setState(820); + 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; + } + + public static class TypeParametersContext extends ParserRuleContext { + public TypeParameterListContext typeParameterList() { + return getRuleContext(TypeParameterListContext.class,0); + } + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_typeParameters); + try { + enterOuterAlt(_localctx, 1); + { + setState(823); + match(LT); + setState(824); + typeParameterList(); + setState(825); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterListContext extends ParserRuleContext { + public List<TypeParameterContext> typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class,i); + } + public TypeParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterListContext typeParameterList() throws RecognitionException { + TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_typeParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(827); + typeParameter(); + setState(832); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(828); + match(COMMA); + setState(829); + typeParameter(); + } + } + setState(834); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuperclassContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public SuperclassContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_superclass; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSuperclass(this); + else return visitor.visitChildren(this); + } + } + + public final SuperclassContext superclass() throws RecognitionException { + SuperclassContext _localctx = new SuperclassContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_superclass); + try { + enterOuterAlt(_localctx, 1); + { + setState(835); + match(EXTENDS); + setState(836); + classType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuperinterfacesContext extends ParserRuleContext { + public InterfaceTypeListContext interfaceTypeList() { + return getRuleContext(InterfaceTypeListContext.class,0); + } + public SuperinterfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_superinterfaces; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSuperinterfaces(this); + else return visitor.visitChildren(this); + } + } + + public final SuperinterfacesContext superinterfaces() throws RecognitionException { + SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_superinterfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(838); + match(IMPLEMENTS); + setState(839); + interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceTypeListContext extends ParserRuleContext { + public List<InterfaceTypeContext> interfaceType() { + return getRuleContexts(InterfaceTypeContext.class); + } + public InterfaceTypeContext interfaceType(int i) { + return getRuleContext(InterfaceTypeContext.class,i); + } + public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceTypeList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException { + InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_interfaceTypeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(841); + interfaceType(); + setState(846); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(842); + match(COMMA); + setState(843); + interfaceType(); + } + } + setState(848); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyContext extends ParserRuleContext { + public List<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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassBody(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyContext classBody() throws RecognitionException { + ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_classBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(849); + match(LBRACE); + setState(853); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] + { + { + setState(850); + classBodyDeclaration(); + } + } + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(856); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyDeclarationContext extends ParserRuleContext { + public ClassMemberDeclarationContext classMemberDeclaration() { + return getRuleContext(ClassMemberDeclarationContext.class,0); + } + public InstanceInitializerContext instanceInitializer() { + return getRuleContext(InstanceInitializerContext.class,0); + } + public StaticInitializerContext staticInitializer() { + return getRuleContext(StaticInitializerContext.class,0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassBodyDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { + ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_classBodyDeclaration); + try { + setState(862); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(858); + classMemberDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(859); + instanceInitializer(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(860); + staticInitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(861); + constructorDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassMemberDeclarationContext extends ParserRuleContext { + public FieldDeclarationContext fieldDeclaration() { + return getRuleContext(FieldDeclarationContext.class,0); + } + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { + ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_classMemberDeclaration); + try { + setState(869); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(864); + fieldDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(865); + methodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(866); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(867); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(868); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<FieldModifierContext> fieldModifier() { + return getRuleContexts(FieldModifierContext.class); + } + public FieldModifierContext fieldModifier(int i) { + return getRuleContext(FieldModifierContext.class,i); + } + public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { + FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_fieldDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(874); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0) || _la==AT) { + { + { + setState(871); + fieldModifier(); + } + } + setState(876); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(877); + unannType(); + setState(878); + variableDeclaratorList(); + setState(879); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public FieldModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldModifier(this); + else return visitor.visitChildren(this); + } + } + + public final FieldModifierContext fieldModifier() throws RecognitionException { + FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_fieldModifier); + try { + setState(889); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(881); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(882); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(883); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(884); + match(PRIVATE); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(885); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 6); + { + setState(886); + match(FINAL); + } + break; + case TRANSIENT: + enterOuterAlt(_localctx, 7); + { + setState(887); + match(TRANSIENT); + } + break; + case VOLATILE: + enterOuterAlt(_localctx, 8); + { + setState(888); + 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; + } + + public static class VariableDeclaratorListContext extends ParserRuleContext { + public List<VariableDeclaratorContext> variableDeclarator() { + return getRuleContexts(VariableDeclaratorContext.class); + } + public VariableDeclaratorContext variableDeclarator(int i) { + return getRuleContext(VariableDeclaratorContext.class,i); + } + public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclaratorList(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException { + VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_variableDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(891); + variableDeclarator(); + setState(896); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(892); + match(COMMA); + setState(893); + variableDeclarator(); + } + } + setState(898); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorContext extends ParserRuleContext { + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { + VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_variableDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(899); + variableDeclaratorId(); + setState(902); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(900); + match(ASSIGN); + setState(901); + variableInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorIdContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableDeclaratorId(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { + VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_variableDeclaratorId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(904); + match(Identifier); + setState(906); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(905); + dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableInitializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final VariableInitializerContext variableInitializer() throws RecognitionException { + VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_variableInitializer); + try { + setState(910); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + case AT: + enterOuterAlt(_localctx, 1); + { + setState(908); + expression(); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(909); + arrayInitializer(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannTypeContext extends ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public UnannReferenceTypeContext unannReferenceType() { + return getRuleContext(UnannReferenceTypeContext.class,0); + } + public UnannTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannTypeContext unannType() throws RecognitionException { + UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_unannType); + try { + setState(914); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(912); + unannPrimitiveType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(913); + unannReferenceType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannPrimitiveTypeContext extends ParserRuleContext { + public NumericTypeContext numericType() { + return getRuleContext(NumericTypeContext.class,0); + } + public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannPrimitiveType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannPrimitiveType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException { + UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_unannPrimitiveType); + try { + setState(918); + switch (_input.LA(1)) { + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 1); + { + setState(916); + numericType(); + } + break; + case BOOLEAN: + enterOuterAlt(_localctx, 2); + { + setState(917); + match(BOOLEAN); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannReferenceTypeContext extends ParserRuleContext { + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public UnannTypeVariableContext unannTypeVariable() { + return getRuleContext(UnannTypeVariableContext.class,0); + } + public UnannArrayTypeContext unannArrayType() { + return getRuleContext(UnannArrayTypeContext.class,0); + } + public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannReferenceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannReferenceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException { + UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_unannReferenceType); + try { + setState(923); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(920); + unannClassOrInterfaceType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(921); + unannTypeVariable(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(922); + unannArrayType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() { + return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) { + return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i); + } + public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() { + return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) { + return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i); + } + public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException { + UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_unannClassOrInterfaceType); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(927); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + case 1: + { + setState(925); + unannClassType_lfno_unannClassOrInterfaceType(); + } + break; + case 2: + { + setState(926); + unannInterfaceType_lfno_unannClassOrInterfaceType(); + } + break; + } + setState(933); + _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(931); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + case 1: + { + setState(929); + unannClassType_lf_unannClassOrInterfaceType(); + } + break; + case 2: + { + setState(930); + unannInterfaceType_lf_unannClassOrInterfaceType(); + } + break; + } + } + } + setState(935); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,66,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public UnannClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassTypeContext unannClassType() throws RecognitionException { + UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_unannClassType); + int _la; + try { + setState(952); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(936); + match(Identifier); + setState(938); + _la = _input.LA(1); + if (_la==LT) { + { + setState(937); + typeArguments(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(940); + unannClassOrInterfaceType(); + setState(941); + match(DOT); + setState(945); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(942); + annotation(); + } + } + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(948); + match(Identifier); + setState(950); + _la = _input.LA(1); + if (_la==LT) { + { + setState(949); + typeArguments(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType_lf_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException { + UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_unannClassType_lf_unannClassOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(954); + match(DOT); + setState(958); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(955); + annotation(); + } + } + setState(960); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(961); + match(Identifier); + setState(963); + _la = _input.LA(1); + if (_la==LT) { + { + setState(962); + typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannClassType_lfno_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException { + UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_unannClassType_lfno_unannClassOrInterfaceType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(965); + match(Identifier); + setState(967); + _la = _input.LA(1); + if (_la==LT) { + { + setState(966); + typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceTypeContext extends ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return getRuleContext(UnannClassTypeContext.class,0); + } + public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException { + UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_unannInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(969); + unannClassType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType_lf_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException { + UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_unannInterfaceType_lf_unannClassOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(971); + unannClassType_lf_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext { + public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() { + return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0); + } + public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannInterfaceType_lfno_unannClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException { + UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType); + try { + enterOuterAlt(_localctx, 1); + { + setState(973); + unannClassType_lfno_unannClassOrInterfaceType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannTypeVariableContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannTypeVariable; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannTypeVariable(this); + else return visitor.visitChildren(this); + } + } + + public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException { + UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_unannTypeVariable); + try { + enterOuterAlt(_localctx, 1); + { + setState(975); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnannArrayTypeContext extends ParserRuleContext { + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() { + return getRuleContext(UnannClassOrInterfaceTypeContext.class,0); + } + public UnannTypeVariableContext unannTypeVariable() { + return getRuleContext(UnannTypeVariableContext.class,0); + } + public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unannArrayType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnannArrayType(this); + else return visitor.visitChildren(this); + } + } + + public final UnannArrayTypeContext unannArrayType() throws RecognitionException { + UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_unannArrayType); + try { + setState(986); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(977); + unannPrimitiveType(); + setState(978); + dims(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(980); + unannClassOrInterfaceType(); + setState(981); + dims(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(983); + unannTypeVariable(); + setState(984); + dims(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodDeclarationContext extends ParserRuleContext { + public MethodHeaderContext methodHeader() { + return getRuleContext(MethodHeaderContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public List<MethodModifierContext> methodModifier() { + return getRuleContexts(MethodModifierContext.class); + } + public MethodModifierContext methodModifier(int i) { + return getRuleContext(MethodModifierContext.class,i); + } + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final MethodDeclarationContext methodDeclaration() throws RecognitionException { + MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_methodDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(991); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) { + { + { + setState(988); + methodModifier(); + } + } + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(994); + methodHeader(); + setState(995); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public MethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodModifier(this); + else return visitor.visitChildren(this); + } + } + + public final MethodModifierContext methodModifier() throws RecognitionException { + MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_methodModifier); + try { + setState(1007); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(997); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(998); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(999); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1000); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(1001); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(1002); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 7); + { + setState(1003); + match(FINAL); + } + break; + case SYNCHRONIZED: + enterOuterAlt(_localctx, 8); + { + setState(1004); + match(SYNCHRONIZED); + } + break; + case NATIVE: + enterOuterAlt(_localctx, 9); + { + setState(1005); + match(NATIVE); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 10); + { + setState(1006); + 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; + } + + public static class MethodHeaderContext extends ParserRuleContext { + public ResultContext result() { + return getRuleContext(ResultContext.class,0); + } + public MethodDeclaratorContext methodDeclarator() { + return getRuleContext(MethodDeclaratorContext.class,0); + } + public Throws_Context throws_() { + return getRuleContext(Throws_Context.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public MethodHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodHeader; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodHeader(this); + else return visitor.visitChildren(this); + } + } + + public final MethodHeaderContext methodHeader() throws RecognitionException { + MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_methodHeader); + int _la; + try { + setState(1026); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1009); + result(); + setState(1010); + methodDeclarator(); + setState(1012); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1011); + throws_(); + } + } + + } + break; + case LT: + enterOuterAlt(_localctx, 2); + { + setState(1014); + typeParameters(); + setState(1018); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1015); + annotation(); + } + } + setState(1020); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1021); + result(); + setState(1022); + methodDeclarator(); + setState(1024); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1023); + throws_(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResultContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public ResultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_result; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResult(this); + else return visitor.visitChildren(this); + } + } + + public final ResultContext result() throws RecognitionException { + ResultContext _localctx = new ResultContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_result); + try { + setState(1030); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1028); + unannType(); + } + break; + case VOID: + enterOuterAlt(_localctx, 2); + { + setState(1029); + 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; + } + + public static class MethodDeclaratorContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final MethodDeclaratorContext methodDeclarator() throws RecognitionException { + MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_methodDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1032); + match(Identifier); + setState(1033); + match(LPAREN); + setState(1035); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(1034); + formalParameterList(); + } + } + + setState(1037); + match(RPAREN); + setState(1039); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(1038); + dims(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterListContext extends ParserRuleContext { + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public LastFormalParameterContext lastFormalParameter() { + return getRuleContext(LastFormalParameterContext.class,0); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterListContext formalParameterList() throws RecognitionException { + FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_formalParameterList); + try { + setState(1046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1041); + formalParameters(); + setState(1042); + match(COMMA); + setState(1043); + lastFormalParameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1045); + lastFormalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParametersContext extends ParserRuleContext { + public List<FormalParameterContext> formalParameter() { + return getRuleContexts(FormalParameterContext.class); + } + public FormalParameterContext formalParameter(int i) { + return getRuleContext(FormalParameterContext.class,i); + } + public ReceiverParameterContext receiverParameter() { + return getRuleContext(ReceiverParameterContext.class,0); + } + public FormalParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameters(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParametersContext formalParameters() throws RecognitionException { + FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_formalParameters); + try { + int _alt; + setState(1064); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1048); + formalParameter(); + setState(1053); + _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(1049); + match(COMMA); + setState(1050); + formalParameter(); + } + } + } + setState(1055); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,85,_ctx); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1056); + receiverParameter(); + setState(1061); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1057); + match(COMMA); + setState(1058); + formalParameter(); + } + } + } + setState(1063); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterContext formalParameter() throws RecognitionException { + FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_formalParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1066); + variableModifier(); + } + } + setState(1071); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1072); + unannType(); + setState(1073); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public VariableModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableModifier(this); + else return visitor.visitChildren(this); + } + } + + public final VariableModifierContext variableModifier() throws RecognitionException { + VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_variableModifier); + try { + setState(1077); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1075); + annotation(); + } + break; + case FINAL: + enterOuterAlt(_localctx, 2); + { + setState(1076); + match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LastFormalParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public FormalParameterContext formalParameter() { + return getRuleContext(FormalParameterContext.class,0); + } + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lastFormalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLastFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { + LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_lastFormalParameter); + int _la; + try { + setState(1096); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1082); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1079); + variableModifier(); + } + } + setState(1084); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1085); + unannType(); + setState(1089); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1086); + annotation(); + } + } + setState(1091); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1092); + match(ELLIPSIS); + setState(1093); + variableDeclaratorId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1095); + formalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReceiverParameterContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ReceiverParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_receiverParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReceiverParameter(this); + else return visitor.visitChildren(this); + } + } + + public final ReceiverParameterContext receiverParameter() throws RecognitionException { + ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_receiverParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1101); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1098); + annotation(); + } + } + setState(1103); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1104); + unannType(); + setState(1107); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1105); + match(Identifier); + setState(1106); + match(DOT); + } + } + + setState(1109); + match(THIS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Throws_Context extends ParserRuleContext { + public ExceptionTypeListContext exceptionTypeList() { + return getRuleContext(ExceptionTypeListContext.class,0); + } + public Throws_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throws_; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitThrows_(this); + else return visitor.visitChildren(this); + } + } + + public final Throws_Context throws_() throws RecognitionException { + Throws_Context _localctx = new Throws_Context(_ctx, getState()); + enterRule(_localctx, 162, RULE_throws_); + try { + enterOuterAlt(_localctx, 1); + { + setState(1111); + match(THROWS); + setState(1112); + exceptionTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionTypeListContext extends ParserRuleContext { + public List<ExceptionTypeContext> exceptionType() { + return getRuleContexts(ExceptionTypeContext.class); + } + public ExceptionTypeContext exceptionType(int i) { + return getRuleContext(ExceptionTypeContext.class,i); + } + public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionTypeList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExceptionTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException { + ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_exceptionTypeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1114); + exceptionType(); + setState(1119); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1115); + match(COMMA); + setState(1116); + exceptionType(); + } + } + setState(1121); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionTypeContext extends ParserRuleContext { + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public TypeVariableContext typeVariable() { + return getRuleContext(TypeVariableContext.class,0); + } + public ExceptionTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExceptionType(this); + else return visitor.visitChildren(this); + } + } + + public final ExceptionTypeContext exceptionType() throws RecognitionException { + ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_exceptionType); + try { + setState(1124); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1122); + classType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1123); + typeVariable(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodBodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public MethodBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodBody(this); + else return visitor.visitChildren(this); + } + } + + public final MethodBodyContext methodBody() throws RecognitionException { + MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_methodBody); + try { + setState(1128); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(1126); + block(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(1127); + match(SEMI); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InstanceInitializerContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public InstanceInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_instanceInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInstanceInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final InstanceInitializerContext instanceInitializer() throws RecognitionException { + InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_instanceInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1130); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticInitializerContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public StaticInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStaticInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final StaticInitializerContext staticInitializer() throws RecognitionException { + StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_staticInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1132); + match(STATIC); + setState(1133); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorDeclarationContext extends ParserRuleContext { + public ConstructorDeclaratorContext constructorDeclarator() { + return getRuleContext(ConstructorDeclaratorContext.class,0); + } + public ConstructorBodyContext constructorBody() { + return getRuleContext(ConstructorBodyContext.class,0); + } + public List<ConstructorModifierContext> constructorModifier() { + return getRuleContexts(ConstructorModifierContext.class); + } + public ConstructorModifierContext constructorModifier(int i) { + return getRuleContext(ConstructorModifierContext.class,i); + } + public Throws_Context throws_() { + return getRuleContext(Throws_Context.class,0); + } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { + ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_constructorDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1138); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC))) != 0) || _la==AT) { + { + { + setState(1135); + constructorModifier(); + } + } + setState(1140); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1141); + constructorDeclarator(); + setState(1143); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(1142); + throws_(); + } + } + + setState(1145); + constructorBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ConstructorModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorModifierContext constructorModifier() throws RecognitionException { + ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_constructorModifier); + try { + setState(1151); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1147); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1148); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(1149); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1150); + match(PRIVATE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorDeclaratorContext extends ParserRuleContext { + public SimpleTypeNameContext simpleTypeName() { + return getRuleContext(SimpleTypeNameContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclarator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException { + ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_constructorDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1154); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1153); + typeParameters(); + } + } + + setState(1156); + simpleTypeName(); + setState(1157); + match(LPAREN); + setState(1159); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(1158); + formalParameterList(); + } + } + + setState(1161); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleTypeNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleTypeName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSimpleTypeName(this); + else return visitor.visitChildren(this); + } + } + + public final SimpleTypeNameContext simpleTypeName() throws RecognitionException { + SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_simpleTypeName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1163); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorBodyContext extends ParserRuleContext { + public ExplicitConstructorInvocationContext explicitConstructorInvocation() { + return getRuleContext(ExplicitConstructorInvocationContext.class,0); + } + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public ConstructorBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstructorBody(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorBodyContext constructorBody() throws RecognitionException { + ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_constructorBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1165); + match(LBRACE); + setState(1167); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { + case 1: + { + setState(1166); + explicitConstructorInvocation(); + } + break; + } + setState(1170); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L < [...] + { + setState(1169); + blockStatements(); + } + } + + setState(1172); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExplicitConstructorInvocationContext extends ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExplicitConstructorInvocation(this); + else return visitor.visitChildren(this); + } + } + + public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException { + ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_explicitConstructorInvocation); + int _la; + try { + setState(1220); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1175); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1174); + typeArguments(); + } + } + + setState(1177); + match(THIS); + setState(1178); + match(LPAREN); + setState(1180); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1179); + argumentList(); + } + } + + setState(1182); + match(RPAREN); + setState(1183); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1185); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1184); + typeArguments(); + } + } + + setState(1187); + match(SUPER); + setState(1188); + match(LPAREN); + setState(1190); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1189); + argumentList(); + } + } + + setState(1192); + match(RPAREN); + setState(1193); + match(SEMI); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1194); + expressionName(); + setState(1195); + match(DOT); + setState(1197); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1196); + typeArguments(); + } + } + + setState(1199); + match(SUPER); + setState(1200); + match(LPAREN); + setState(1202); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1201); + argumentList(); + } + } + + setState(1204); + match(RPAREN); + setState(1205); + match(SEMI); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1207); + primary(); + setState(1208); + match(DOT); + setState(1210); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1209); + typeArguments(); + } + } + + setState(1212); + match(SUPER); + setState(1213); + match(LPAREN); + setState(1215); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1214); + argumentList(); + } + } + + setState(1217); + match(RPAREN); + setState(1218); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public EnumBodyContext enumBody() { + return getRuleContext(EnumBodyContext.class,0); + } + public List<ClassModifierContext> classModifier() { + return getRuleContexts(ClassModifierContext.class); + } + public ClassModifierContext classModifier(int i) { + return getRuleContext(ClassModifierContext.class,i); + } + public SuperinterfacesContext superinterfaces() { + return getRuleContext(SuperinterfacesContext.class,0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final EnumDeclarationContext enumDeclaration() throws RecognitionException { + EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_enumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1225); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1222); + classModifier(); + } + } + setState(1227); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1228); + match(ENUM); + setState(1229); + match(Identifier); + setState(1231); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(1230); + superinterfaces(); + } + } + + setState(1233); + enumBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumBodyContext extends ParserRuleContext { + public EnumConstantListContext enumConstantList() { + return getRuleContext(EnumConstantListContext.class,0); + } + public EnumBodyDeclarationsContext enumBodyDeclarations() { + return getRuleContext(EnumBodyDeclarationsContext.class,0); + } + public EnumBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumBody(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyContext enumBody() throws RecognitionException { + EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_enumBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1235); + match(LBRACE); + setState(1237); + _la = _input.LA(1); + if (_la==Identifier || _la==AT) { + { + setState(1236); + enumConstantList(); + } + } + + setState(1240); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1239); + match(COMMA); + } + } + + setState(1243); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1242); + enumBodyDeclarations(); + } + } + + setState(1245); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantListContext extends ParserRuleContext { + public List<EnumConstantContext> enumConstant() { + return getRuleContexts(EnumConstantContext.class); + } + public EnumConstantContext enumConstant(int i) { + return getRuleContext(EnumConstantContext.class,i); + } + public EnumConstantListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantList(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantListContext enumConstantList() throws RecognitionException { + EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_enumConstantList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1247); + enumConstant(); + setState(1252); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1248); + match(COMMA); + setState(1249); + enumConstant(); + } + } + } + setState(1254); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,119,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<EnumConstantModifierContext> enumConstantModifier() { + return getRuleContexts(EnumConstantModifierContext.class); + } + public EnumConstantModifierContext enumConstantModifier(int i) { + return getRuleContext(EnumConstantModifierContext.class,i); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public EnumConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstant; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstant(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantContext enumConstant() throws RecognitionException { + EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_enumConstant); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1258); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(1255); + enumConstantModifier(); + } + } + setState(1260); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1261); + match(Identifier); + setState(1267); + _la = _input.LA(1); + if (_la==LPAREN) { + { + setState(1262); + match(LPAREN); + setState(1264); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(1263); + argumentList(); + } + } + + setState(1266); + match(RPAREN); + } + } + + setState(1270); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(1269); + classBody(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantModifier(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException { + EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_enumConstantModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1272); + annotation(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumBodyDeclarationsContext extends ParserRuleContext { + public List<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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumBodyDeclarations(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { + EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_enumBodyDeclarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1274); + match(SEMI); + setState(1278); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] + { + { + setState(1275); + classBodyDeclaration(); + } + } + setState(1280); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceDeclarationContext extends ParserRuleContext { + public NormalInterfaceDeclarationContext normalInterfaceDeclaration() { + return getRuleContext(NormalInterfaceDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { + InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_interfaceDeclaration); + try { + setState(1283); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1281); + normalInterfaceDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1282); + annotationTypeDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalInterfaceDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public InterfaceBodyContext interfaceBody() { + return getRuleContext(InterfaceBodyContext.class,0); + } + public List<InterfaceModifierContext> interfaceModifier() { + return getRuleContexts(InterfaceModifierContext.class); + } + public InterfaceModifierContext interfaceModifier(int i) { + return getRuleContext(InterfaceModifierContext.class,i); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ExtendsInterfacesContext extendsInterfaces() { + return getRuleContext(ExtendsInterfacesContext.class,0); + } + public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException { + NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_normalInterfaceDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1288); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1285); + interfaceModifier(); + } + } + setState(1290); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1291); + match(INTERFACE); + setState(1292); + match(Identifier); + setState(1294); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1293); + typeParameters(); + } + } + + setState(1297); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(1296); + extendsInterfaces(); + } + } + + setState(1299); + interfaceBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public InterfaceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceModifier(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceModifierContext interfaceModifier() throws RecognitionException { + InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_interfaceModifier); + try { + setState(1308); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1301); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1302); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(1303); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(1304); + match(PRIVATE); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 5); + { + setState(1305); + match(ABSTRACT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 6); + { + setState(1306); + match(STATIC); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 7); + { + setState(1307); + 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; + } + + public static class ExtendsInterfacesContext extends ParserRuleContext { + public InterfaceTypeListContext interfaceTypeList() { + return getRuleContext(InterfaceTypeListContext.class,0); + } + public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_extendsInterfaces; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExtendsInterfaces(this); + else return visitor.visitChildren(this); + } + } + + public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException { + ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_extendsInterfaces); + try { + enterOuterAlt(_localctx, 1); + { + setState(1310); + match(EXTENDS); + setState(1311); + interfaceTypeList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceBodyContext extends ParserRuleContext { + public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() { + return getRuleContexts(InterfaceMemberDeclarationContext.class); + } + public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) { + return getRuleContext(InterfaceMemberDeclarationContext.class,i); + } + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceBody(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceBodyContext interfaceBody() throws RecognitionException { + InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_interfaceBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1313); + match(LBRACE); + setState(1317); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << [...] + { + { + setState(1314); + interfaceMemberDeclaration(); + } + } + setState(1319); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1320); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMemberDeclarationContext extends ParserRuleContext { + public ConstantDeclarationContext constantDeclaration() { + return getRuleContext(ConstantDeclarationContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { + InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_interfaceMemberDeclaration); + try { + setState(1327); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1322); + constantDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1323); + interfaceMethodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1324); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1325); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1326); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<ConstantModifierContext> constantModifier() { + return getRuleContexts(ConstantModifierContext.class); + } + public ConstantModifierContext constantModifier(int i) { + return getRuleContext(ConstantModifierContext.class,i); + } + public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantDeclarationContext constantDeclaration() throws RecognitionException { + ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_constantDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << FINAL) | (1L << PUBLIC) | (1L << STATIC))) != 0) || _la==AT) { + { + { + setState(1329); + constantModifier(); + } + } + setState(1334); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1335); + unannType(); + setState(1336); + variableDeclaratorList(); + setState(1337); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ConstantModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantModifierContext constantModifier() throws RecognitionException { + ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_constantModifier); + try { + setState(1343); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1339); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1340); + match(PUBLIC); + } + break; + case STATIC: + enterOuterAlt(_localctx, 3); + { + setState(1341); + match(STATIC); + } + break; + case FINAL: + enterOuterAlt(_localctx, 4); + { + setState(1342); + match(FINAL); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodDeclarationContext extends ParserRuleContext { + public MethodHeaderContext methodHeader() { + return getRuleContext(MethodHeaderContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public List<InterfaceMethodModifierContext> interfaceMethodModifier() { + return getRuleContexts(InterfaceMethodModifierContext.class); + } + public InterfaceMethodModifierContext interfaceMethodModifier(int i) { + return getRuleContext(InterfaceMethodModifierContext.class,i); + } + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { + InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_interfaceMethodDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1348); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { + { + { + setState(1345); + interfaceMethodModifier(); + } + } + setState(1350); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1351); + methodHeader(); + setState(1352); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInterfaceMethodModifier(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { + InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_interfaceMethodModifier); + try { + setState(1360); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1354); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1355); + match(PUBLIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 3); + { + setState(1356); + match(ABSTRACT); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 4); + { + setState(1357); + match(DEFAULT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(1358); + match(STATIC); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 6); + { + setState(1359); + 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; + } + + public static class AnnotationTypeDeclarationContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AnnotationTypeBodyContext annotationTypeBody() { + return getRuleContext(AnnotationTypeBodyContext.class,0); + } + public List<InterfaceModifierContext> interfaceModifier() { + return getRuleContexts(InterfaceModifierContext.class); + } + public InterfaceModifierContext interfaceModifier(int i) { + return getRuleContext(InterfaceModifierContext.class,i); + } + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { + AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_annotationTypeDeclaration); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1365); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,136,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1362); + interfaceModifier(); + } + } + } + setState(1367); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,136,_ctx); + } + setState(1368); + match(AT); + setState(1369); + match(INTERFACE); + setState(1370); + match(Identifier); + setState(1371); + annotationTypeBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeBodyContext extends ParserRuleContext { + public List<AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() { + return getRuleContexts(AnnotationTypeMemberDeclarationContext.class); + } + public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) { + return getRuleContext(AnnotationTypeMemberDeclarationContext.class,i); + } + public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeBody; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeBody(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { + AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_annotationTypeBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1373); + match(LBRACE); + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==Identifier || _la==AT) { + { + { + setState(1374); + annotationTypeMemberDeclaration(); + } + } + setState(1379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1380); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext { + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() { + return getRuleContext(AnnotationTypeElementDeclarationContext.class,0); + } + public ConstantDeclarationContext constantDeclaration() { + return getRuleContext(ConstantDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeMemberDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException { + AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_annotationTypeMemberDeclaration); + try { + setState(1387); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1382); + annotationTypeElementDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1383); + constantDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1384); + classDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1385); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1386); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List<AnnotationTypeElementModifierContext> annotationTypeElementModifier() { + return getRuleContexts(AnnotationTypeElementModifierContext.class); + } + public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) { + return getRuleContext(AnnotationTypeElementModifierContext.class,i); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeElementDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { + AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_annotationTypeElementDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1392); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ABSTRACT || _la==PUBLIC || _la==AT) { + { + { + setState(1389); + annotationTypeElementModifier(); + } + } + setState(1394); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1395); + unannType(); + setState(1396); + match(Identifier); + setState(1397); + match(LPAREN); + setState(1398); + match(RPAREN); + setState(1400); + _la = _input.LA(1); + if (_la==LBRACK || _la==AT) { + { + setState(1399); + dims(); + } + } + + setState(1403); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(1402); + defaultValue(); + } + } + + setState(1405); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeElementModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementModifier; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotationTypeElementModifier(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException { + AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_annotationTypeElementModifier); + try { + setState(1410); + switch (_input.LA(1)) { + case AT: + enterOuterAlt(_localctx, 1); + { + setState(1407); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(1408); + match(PUBLIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 3); + { + setState(1409); + match(ABSTRACT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DefaultValueContext extends ParserRuleContext { + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public DefaultValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaultValue; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDefaultValue(this); + else return visitor.visitChildren(this); + } + } + + public final DefaultValueContext defaultValue() throws RecognitionException { + DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_defaultValue); + try { + enterOuterAlt(_localctx, 1); + { + setState(1412); + match(DEFAULT); + setState(1413); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationContext extends ParserRuleContext { + public NormalAnnotationContext normalAnnotation() { + return getRuleContext(NormalAnnotationContext.class,0); + } + public MarkerAnnotationContext markerAnnotation() { + return getRuleContext(MarkerAnnotationContext.class,0); + } + public SingleElementAnnotationContext singleElementAnnotation() { + return getRuleContext(SingleElementAnnotationContext.class,0); + } + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_annotation); + try { + setState(1418); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1415); + normalAnnotation(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1416); + markerAnnotation(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1417); + singleElementAnnotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NormalAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ElementValuePairListContext elementValuePairList() { + return getRuleContext(ElementValuePairListContext.class,0); + } + public NormalAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_normalAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitNormalAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final NormalAnnotationContext normalAnnotation() throws RecognitionException { + NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_normalAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1420); + match(AT); + setState(1421); + typeName(); + setState(1422); + match(LPAREN); + setState(1424); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1423); + elementValuePairList(); + } + } + + setState(1426); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValuePairListContext extends ParserRuleContext { + public List<ElementValuePairContext> elementValuePair() { + return getRuleContexts(ElementValuePairContext.class); + } + public ElementValuePairContext elementValuePair(int i) { + return getRuleContext(ElementValuePairContext.class,i); + } + public ElementValuePairListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePairList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValuePairList(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairListContext elementValuePairList() throws RecognitionException { + ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_elementValuePairList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1428); + elementValuePair(); + setState(1433); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1429); + match(COMMA); + setState(1430); + elementValuePair(); + } + } + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValuePairContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public ElementValuePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePair; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValuePair(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairContext elementValuePair() throws RecognitionException { + ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_elementValuePair); + try { + enterOuterAlt(_localctx, 1); + { + setState(1436); + match(Identifier); + setState(1437); + match(ASSIGN); + setState(1438); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + return getRuleContext(ElementValueArrayInitializerContext.class,0); + } + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ElementValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValue; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValue(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueContext elementValue() throws RecognitionException { + ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_elementValue); + try { + setState(1443); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1440); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1441); + elementValueArrayInitializer(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1442); + annotation(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueArrayInitializerContext extends ParserRuleContext { + public ElementValueListContext elementValueList() { + return getRuleContext(ElementValueListContext.class,0); + } + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValueArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { + ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_elementValueArrayInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1445); + match(LBRACE); + setState(1447); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] + { + setState(1446); + elementValueList(); + } + } + + setState(1450); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1449); + match(COMMA); + } + } + + setState(1452); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueListContext extends ParserRuleContext { + public List<ElementValueContext> elementValue() { + return getRuleContexts(ElementValueContext.class); + } + public ElementValueContext elementValue(int i) { + return getRuleContext(ElementValueContext.class,i); + } + public ElementValueListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitElementValueList(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueListContext elementValueList() throws RecognitionException { + ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_elementValueList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1454); + elementValue(); + setState(1459); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,149,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1455); + match(COMMA); + setState(1456); + elementValue(); + } + } + } + setState(1461); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,149,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MarkerAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_markerAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMarkerAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final MarkerAnnotationContext markerAnnotation() throws RecognitionException { + MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_markerAnnotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1462); + match(AT); + setState(1463); + typeName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SingleElementAnnotationContext extends ParserRuleContext { + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_singleElementAnnotation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSingleElementAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException { + SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_singleElementAnnotation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1465); + match(AT); + setState(1466); + typeName(); + setState(1467); + match(LPAREN); + setState(1468); + elementValue(); + setState(1469); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayInitializerContext extends ParserRuleContext { + public VariableInitializerListContext variableInitializerList() { + return getRuleContext(VariableInitializerListContext.class,0); + } + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayInitializer; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayInitializerContext arrayInitializer() throws RecognitionException { + ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_arrayInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1471); + match(LBRACE); + setState(1473); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << [...] + { + setState(1472); + variableInitializerList(); + } + } + + setState(1476); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1475); + match(COMMA); + } + } + + setState(1478); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableInitializerListContext extends ParserRuleContext { + public List<VariableInitializerContext> variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public VariableInitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializerList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitVariableInitializerList(this); + else return visitor.visitChildren(this); + } + } + + public final VariableInitializerListContext variableInitializerList() throws RecognitionException { + VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_variableInitializerList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1480); + variableInitializer(); + setState(1485); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,152,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1481); + match(COMMA); + setState(1482); + variableInitializer(); + } + } + } + setState(1487); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,152,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockContext extends ParserRuleContext { + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1488); + match(LBRACE); + setState(1490); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L < [...] + { + setState(1489); + blockStatements(); + } + } + + setState(1492); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementsContext extends ParserRuleContext { + public List<BlockStatementContext> blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class,i); + } + public BlockStatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatements; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlockStatements(this); + else return visitor.visitChildren(this); + } + } + + public final BlockStatementsContext blockStatements() throws RecognitionException { + BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_blockStatements); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1494); + blockStatement(); + setState(1498); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1 [...] + { + { + setState(1495); + blockStatement(); + } + } + setState(1500); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementContext extends ParserRuleContext { + public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { + return getRuleContext(LocalVariableDeclarationStatementContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBlockStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BlockStatementContext blockStatement() throws RecognitionException { + BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_blockStatement); + try { + setState(1504); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1501); + localVariableDeclarationStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1502); + classDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1503); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalVariableDeclarationStatementContext extends ParserRuleContext { + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLocalVariableDeclarationStatement(this); + else return visitor.visitChildren(this); + } + } + + public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException { + LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_localVariableDeclarationStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1506); + localVariableDeclaration(); + setState(1507); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalVariableDeclarationContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorListContext variableDeclaratorList() { + return getRuleContext(VariableDeclaratorListContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localVariableDeclaration; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLocalVariableDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { + LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_localVariableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1512); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1509); + variableModifier(); + } + } + setState(1514); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1515); + unannType(); + setState(1516); + variableDeclaratorList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementContext extends ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0); + } + public LabeledStatementContext labeledStatement() { + return getRuleContext(LabeledStatementContext.class,0); + } + public IfThenStatementContext ifThenStatement() { + return getRuleContext(IfThenStatementContext.class,0); + } + public IfThenElseStatementContext ifThenElseStatement() { + return getRuleContext(IfThenElseStatementContext.class,0); + } + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class,0); + } + public ForStatementContext forStatement() { + return getRuleContext(ForStatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_statement); + try { + setState(1524); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1518); + statementWithoutTrailingSubstatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1519); + labeledStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1520); + ifThenStatement(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1521); + ifThenElseStatement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1522); + whileStatement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1523); + forStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementNoShortIfContext extends ParserRuleContext { + public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() { + return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0); + } + public LabeledStatementNoShortIfContext labeledStatementNoShortIf() { + return getRuleContext(LabeledStatementNoShortIfContext.class,0); + } + public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() { + return getRuleContext(IfThenElseStatementNoShortIfContext.class,0); + } + public WhileStatementNoShortIfContext whileStatementNoShortIf() { + return getRuleContext(WhileStatementNoShortIfContext.class,0); + } + public ForStatementNoShortIfContext forStatementNoShortIf() { + return getRuleContext(ForStatementNoShortIfContext.class,0); + } + public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException { + StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_statementNoShortIf); + try { + setState(1531); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1526); + statementWithoutTrailingSubstatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1527); + labeledStatementNoShortIf(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1528); + ifThenElseStatementNoShortIf(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1529); + whileStatementNoShortIf(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1530); + forStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public EmptyStatementContext emptyStatement() { + return getRuleContext(EmptyStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public AssertStatementContext assertStatement() { + return getRuleContext(AssertStatementContext.class,0); + } + public SwitchStatementContext switchStatement() { + return getRuleContext(SwitchStatementContext.class,0); + } + public DoStatementContext doStatement() { + return getRuleContext(DoStatementContext.class,0); + } + public BreakStatementContext breakStatement() { + return getRuleContext(BreakStatementContext.class,0); + } + public ContinueStatementContext continueStatement() { + return getRuleContext(ContinueStatementContext.class,0); + } + public ReturnStatementContext returnStatement() { + return getRuleContext(ReturnStatementContext.class,0); + } + public SynchronizedStatementContext synchronizedStatement() { + return getRuleContext(SynchronizedStatementContext.class,0); + } + public ThrowStatementContext throwStatement() { + return getRuleContext(ThrowStatementContext.class,0); + } + public TryStatementContext tryStatement() { + return getRuleContext(TryStatementContext.class,0); + } + public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementWithoutTrailingSubstatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementWithoutTrailingSubstatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException { + StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_statementWithoutTrailingSubstatement); + try { + setState(1545); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(1533); + block(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(1534); + emptyStatement(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case INC: + case DEC: + case Identifier: + case AT: + enterOuterAlt(_localctx, 3); + { + setState(1535); + expressionStatement(); + } + break; + case ASSERT: + enterOuterAlt(_localctx, 4); + { + setState(1536); + assertStatement(); + } + break; + case SWITCH: + enterOuterAlt(_localctx, 5); + { + setState(1537); + switchStatement(); + } + break; + case DO: + enterOuterAlt(_localctx, 6); + { + setState(1538); + doStatement(); + } + break; + case BREAK: + enterOuterAlt(_localctx, 7); + { + setState(1539); + breakStatement(); + } + break; + case CONTINUE: + enterOuterAlt(_localctx, 8); + { + setState(1540); + continueStatement(); + } + break; + case RETURN: + enterOuterAlt(_localctx, 9); + { + setState(1541); + returnStatement(); + } + break; + case SYNCHRONIZED: + enterOuterAlt(_localctx, 10); + { + setState(1542); + synchronizedStatement(); + } + break; + case THROW: + enterOuterAlt(_localctx, 11); + { + setState(1543); + throwStatement(); + } + break; + case TRY: + enterOuterAlt(_localctx, 12); + { + setState(1544); + tryStatement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EmptyStatementContext extends ParserRuleContext { + public EmptyStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEmptyStatement(this); + else return visitor.visitChildren(this); + } + } + + public final EmptyStatementContext emptyStatement() throws RecognitionException { + EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_emptyStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1547); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeledStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public LabeledStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeledStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLabeledStatement(this); + else return visitor.visitChildren(this); + } + } + + public final LabeledStatementContext labeledStatement() throws RecognitionException { + LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_labeledStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1549); + match(Identifier); + setState(1550); + match(COLON); + setState(1551); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeledStatementNoShortIfContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeledStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLabeledStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException { + LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_labeledStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1553); + match(Identifier); + setState(1554); + match(COLON); + setState(1555); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionStatementContext extends ParserRuleContext { + public StatementExpressionContext statementExpression() { + return getRuleContext(StatementExpressionContext.class,0); + } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpressionStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_expressionStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1557); + statementExpression(); + setState(1558); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementExpressionContext extends ParserRuleContext { + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public PreIncrementExpressionContext preIncrementExpression() { + return getRuleContext(PreIncrementExpressionContext.class,0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return getRuleContext(PreDecrementExpressionContext.class,0); + } + public PostIncrementExpressionContext postIncrementExpression() { + return getRuleContext(PostIncrementExpressionContext.class,0); + } + public PostDecrementExpressionContext postDecrementExpression() { + return getRuleContext(PostDecrementExpressionContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public StatementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final StatementExpressionContext statementExpression() throws RecognitionException { + StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_statementExpression); + try { + setState(1567); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1560); + assignment(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1561); + preIncrementExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1562); + preDecrementExpression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1563); + postIncrementExpression(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1564); + postDecrementExpression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1565); + methodInvocation(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1566); + classInstanceCreationExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public IfThenStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenStatementContext ifThenStatement() throws RecognitionException { + IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_ifThenStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1569); + match(IF); + setState(1570); + match(LPAREN); + setState(1571); + expression(); + setState(1572); + match(RPAREN); + setState(1573); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenElseStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenElseStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenElseStatement(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException { + IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_ifThenElseStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1575); + match(IF); + setState(1576); + match(LPAREN); + setState(1577); + expression(); + setState(1578); + match(RPAREN); + setState(1579); + statementNoShortIf(); + setState(1580); + match(ELSE); + setState(1581); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List<StatementNoShortIfContext> statementNoShortIf() { + return getRuleContexts(StatementNoShortIfContext.class); + } + public StatementNoShortIfContext statementNoShortIf(int i) { + return getRuleContext(StatementNoShortIfContext.class,i); + } + public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_ifThenElseStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitIfThenElseStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException { + IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_ifThenElseStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1583); + match(IF); + setState(1584); + match(LPAREN); + setState(1585); + expression(); + setState(1586); + match(RPAREN); + setState(1587); + statementNoShortIf(); + setState(1588); + match(ELSE); + setState(1589); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssertStatementContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public AssertStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assertStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssertStatement(this); + else return visitor.visitChildren(this); + } + } + + public final AssertStatementContext assertStatement() throws RecognitionException { + AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_assertStatement); + try { + setState(1601); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1591); + match(ASSERT); + setState(1592); + expression(); + setState(1593); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1595); + match(ASSERT); + setState(1596); + expression(); + setState(1597); + match(COLON); + setState(1598); + expression(); + setState(1599); + match(SEMI); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public SwitchBlockContext switchBlock() { + return getRuleContext(SwitchBlockContext.class,0); + } + public SwitchStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchStatement(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchStatementContext switchStatement() throws RecognitionException { + SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_switchStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1603); + match(SWITCH); + setState(1604); + match(LPAREN); + setState(1605); + expression(); + setState(1606); + match(RPAREN); + setState(1607); + switchBlock(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockContext extends ParserRuleContext { + public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() { + return getRuleContexts(SwitchBlockStatementGroupContext.class); + } + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return getRuleContext(SwitchBlockStatementGroupContext.class,i); + } + public List<SwitchLabelContext> switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public SwitchBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlock; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchBlock(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchBlockContext switchBlock() throws RecognitionException { + SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_switchBlock); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1609); + match(LBRACE); + setState(1613); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,162,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1610); + switchBlockStatementGroup(); + } + } + } + setState(1615); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,162,_ctx); + } + setState(1619); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(1616); + switchLabel(); + } + } + setState(1621); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1622); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockStatementGroupContext extends ParserRuleContext { + public SwitchLabelsContext switchLabels() { + return getRuleContext(SwitchLabelsContext.class,0); + } + public BlockStatementsContext blockStatements() { + return getRuleContext(BlockStatementsContext.class,0); + } + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchBlockStatementGroup(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { + SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_switchBlockStatementGroup); + try { + enterOuterAlt(_localctx, 1); + { + setState(1624); + switchLabels(); + setState(1625); + blockStatements(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelsContext extends ParserRuleContext { + public List<SwitchLabelContext> switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public SwitchLabelsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabels; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchLabels(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchLabelsContext switchLabels() throws RecognitionException { + SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_switchLabels); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1627); + switchLabel(); + setState(1631); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(1628); + switchLabel(); + } + } + setState(1633); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelContext extends ParserRuleContext { + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public EnumConstantNameContext enumConstantName() { + return getRuleContext(EnumConstantNameContext.class,0); + } + public SwitchLabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabel; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSwitchLabel(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchLabelContext switchLabel() throws RecognitionException { + SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_switchLabel); + try { + setState(1644); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1634); + match(CASE); + setState(1635); + constantExpression(); + setState(1636); + match(COLON); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1638); + match(CASE); + setState(1639); + enumConstantName(); + setState(1640); + match(COLON); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1642); + match(DEFAULT); + setState(1643); + match(COLON); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public EnumConstantNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantName; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnumConstantName(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantNameContext enumConstantName() throws RecognitionException { + EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_enumConstantName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1646); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWhileStatement(this); + else return visitor.visitChildren(this); + } + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_whileStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1648); + match(WHILE); + setState(1649); + match(LPAREN); + setState(1650); + expression(); + setState(1651); + match(RPAREN); + setState(1652); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileStatementNoShortIfContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_whileStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitWhileStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException { + WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_whileStatementNoShortIf); + try { + enterOuterAlt(_localctx, 1); + { + setState(1654); + match(WHILE); + setState(1655); + match(LPAREN); + setState(1656); + expression(); + setState(1657); + match(RPAREN); + setState(1658); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DoStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DoStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_doStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDoStatement(this); + else return visitor.visitChildren(this); + } + } + + public final DoStatementContext doStatement() throws RecognitionException { + DoStatementContext _localctx = new DoStatementContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_doStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1660); + match(DO); + setState(1661); + statement(); + setState(1662); + match(WHILE); + setState(1663); + match(LPAREN); + setState(1664); + expression(); + setState(1665); + match(RPAREN); + setState(1666); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForStatementContext extends ParserRuleContext { + public BasicForStatementContext basicForStatement() { + return getRuleContext(BasicForStatementContext.class,0); + } + public EnhancedForStatementContext enhancedForStatement() { + return getRuleContext(EnhancedForStatementContext.class,0); + } + public ForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ForStatementContext forStatement() throws RecognitionException { + ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_forStatement); + try { + setState(1670); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1668); + basicForStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1669); + enhancedForStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForStatementNoShortIfContext extends ParserRuleContext { + public BasicForStatementNoShortIfContext basicForStatementNoShortIf() { + return getRuleContext(BasicForStatementNoShortIfContext.class,0); + } + public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() { + return getRuleContext(EnhancedForStatementNoShortIfContext.class,0); + } + public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException { + ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_forStatementNoShortIf); + try { + setState(1674); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1672); + basicForStatementNoShortIf(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1673); + enhancedForStatementNoShortIf(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BasicForStatementContext extends ParserRuleContext { + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + public BasicForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_basicForStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBasicForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BasicForStatementContext basicForStatement() throws RecognitionException { + BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_basicForStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1676); + match(FOR); + setState(1677); + match(LPAREN); + setState(1679); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << [...] + { + setState(1678); + forInit(); + } + } + + setState(1681); + match(SEMI); + setState(1683); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1682); + expression(); + } + } + + setState(1685); + match(SEMI); + setState(1687); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (INC - 79)) | (1 [...] + { + setState(1686); + forUpdate(); + } + } + + setState(1689); + match(RPAREN); + setState(1690); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BasicForStatementNoShortIfContext extends ParserRuleContext { + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_basicForStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBasicForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException { + BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_basicForStatementNoShortIf); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1692); + match(FOR); + setState(1693); + match(LPAREN); + setState(1695); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << [...] + { + setState(1694); + forInit(); + } + } + + setState(1697); + match(SEMI); + setState(1699); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1698); + expression(); + } + } + + setState(1701); + match(SEMI); + setState(1703); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (INC - 79)) | (1 [...] + { + setState(1702); + forUpdate(); + } + } + + setState(1705); + match(RPAREN); + setState(1706); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForInitContext extends ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return getRuleContext(StatementExpressionListContext.class,0); + } + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInit; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForInit(this); + else return visitor.visitChildren(this); + } + } + + public final ForInitContext forInit() throws RecognitionException { + ForInitContext _localctx = new ForInitContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_forInit); + try { + setState(1710); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1708); + statementExpressionList(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1709); + localVariableDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForUpdateContext extends ParserRuleContext { + public StatementExpressionListContext statementExpressionList() { + return getRuleContext(StatementExpressionListContext.class,0); + } + public ForUpdateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forUpdate; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitForUpdate(this); + else return visitor.visitChildren(this); + } + } + + public final ForUpdateContext forUpdate() throws RecognitionException { + ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_forUpdate); + try { + enterOuterAlt(_localctx, 1); + { + setState(1712); + statementExpressionList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementExpressionListContext extends ParserRuleContext { + public List<StatementExpressionContext> statementExpression() { + return getRuleContexts(StatementExpressionContext.class); + } + public StatementExpressionContext statementExpression(int i) { + return getRuleContext(StatementExpressionContext.class,i); + } + public StatementExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementExpressionList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitStatementExpressionList(this); + else return visitor.visitChildren(this); + } + } + + public final StatementExpressionListContext statementExpressionList() throws RecognitionException { + StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_statementExpressionList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1714); + statementExpression(); + setState(1719); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1715); + match(COMMA); + setState(1716); + statementExpression(); + } + } + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnhancedForStatementContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enhancedForStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnhancedForStatement(this); + else return visitor.visitChildren(this); + } + } + + public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException { + EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_enhancedForStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1722); + match(FOR); + setState(1723); + match(LPAREN); + setState(1727); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1724); + variableModifier(); + } + } + setState(1729); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1730); + unannType(); + setState(1731); + variableDeclaratorId(); + setState(1732); + match(COLON); + setState(1733); + expression(); + setState(1734); + match(RPAREN); + setState(1735); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public StatementNoShortIfContext statementNoShortIf() { + return getRuleContext(StatementNoShortIfContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enhancedForStatementNoShortIf; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEnhancedForStatementNoShortIf(this); + else return visitor.visitChildren(this); + } + } + + public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException { + EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_enhancedForStatementNoShortIf); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1737); + match(FOR); + setState(1738); + match(LPAREN); + setState(1742); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1739); + variableModifier(); + } + } + setState(1744); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1745); + unannType(); + setState(1746); + variableDeclaratorId(); + setState(1747); + match(COLON); + setState(1748); + expression(); + setState(1749); + match(RPAREN); + setState(1750); + statementNoShortIf(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BreakStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public BreakStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_breakStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitBreakStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BreakStatementContext breakStatement() throws RecognitionException { + BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_breakStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1752); + match(BREAK); + setState(1754); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1753); + match(Identifier); + } + } + + setState(1756); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ContinueStatementContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ContinueStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continueStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitContinueStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ContinueStatementContext continueStatement() throws RecognitionException { + ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_continueStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1758); + match(CONTINUE); + setState(1760); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1759); + match(Identifier); + } + } + + setState(1762); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ReturnStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_returnStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitReturnStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ReturnStatementContext returnStatement() throws RecognitionException { + ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_returnStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1764); + match(RETURN); + setState(1766); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(1765); + expression(); + } + } + + setState(1768); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ThrowStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ThrowStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitThrowStatement(this); + else return visitor.visitChildren(this); + } + } + + public final ThrowStatementContext throwStatement() throws RecognitionException { + ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_throwStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1770); + match(THROW); + setState(1771); + expression(); + setState(1772); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SynchronizedStatementContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_synchronizedStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitSynchronizedStatement(this); + else return visitor.visitChildren(this); + } + } + + public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException { + SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_synchronizedStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(1774); + match(SYNCHRONIZED); + setState(1775); + match(LPAREN); + setState(1776); + expression(); + setState(1777); + match(RPAREN); + setState(1778); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryStatementContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchesContext catches() { + return getRuleContext(CatchesContext.class,0); + } + public Finally_Context finally_() { + return getRuleContext(Finally_Context.class,0); + } + public TryWithResourcesStatementContext tryWithResourcesStatement() { + return getRuleContext(TryWithResourcesStatementContext.class,0); + } + public TryStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTryStatement(this); + else return visitor.visitChildren(this); + } + } + + public final TryStatementContext tryStatement() throws RecognitionException { + TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_tryStatement); + int _la; + try { + setState(1792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1780); + match(TRY); + setState(1781); + block(); + setState(1782); + catches(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1784); + match(TRY); + setState(1785); + block(); + setState(1787); + _la = _input.LA(1); + if (_la==CATCH) { + { + setState(1786); + catches(); + } + } + + setState(1789); + finally_(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1791); + tryWithResourcesStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchesContext extends ParserRuleContext { + public List<CatchClauseContext> catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public CatchesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catches; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatches(this); + else return visitor.visitChildren(this); + } + } + + public final CatchesContext catches() throws RecognitionException { + CatchesContext _localctx = new CatchesContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_catches); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1794); + catchClause(); + setState(1798); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CATCH) { + { + { + setState(1795); + catchClause(); + } + } + setState(1800); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchClauseContext extends ParserRuleContext { + public CatchFormalParameterContext catchFormalParameter() { + return getRuleContext(CatchFormalParameterContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchClause(this); + else return visitor.visitChildren(this); + } + } + + public final CatchClauseContext catchClause() throws RecognitionException { + CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_catchClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1801); + match(CATCH); + setState(1802); + match(LPAREN); + setState(1803); + catchFormalParameter(); + setState(1804); + match(RPAREN); + setState(1805); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchFormalParameterContext extends ParserRuleContext { + public CatchTypeContext catchType() { + return getRuleContext(CatchTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchFormalParameter; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException { + CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_catchFormalParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1807); + variableModifier(); + } + } + setState(1812); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1813); + catchType(); + setState(1814); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchTypeContext extends ParserRuleContext { + public UnannClassTypeContext unannClassType() { + return getRuleContext(UnannClassTypeContext.class,0); + } + public List<ClassTypeContext> classType() { + return getRuleContexts(ClassTypeContext.class); + } + public ClassTypeContext classType(int i) { + return getRuleContext(ClassTypeContext.class,i); + } + public CatchTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchType; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCatchType(this); + else return visitor.visitChildren(this); + } + } + + public final CatchTypeContext catchType() throws RecognitionException { + CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_catchType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1816); + unannClassType(); + setState(1821); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITOR) { + { + { + setState(1817); + match(BITOR); + setState(1818); + classType(); + } + } + setState(1823); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Finally_Context extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public Finally_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finally_; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFinally_(this); + else return visitor.visitChildren(this); + } + } + + public final Finally_Context finally_() throws RecognitionException { + Finally_Context _localctx = new Finally_Context(_ctx, getState()); + enterRule(_localctx, 342, RULE_finally_); + try { + enterOuterAlt(_localctx, 1); + { + setState(1824); + match(FINALLY); + setState(1825); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryWithResourcesStatementContext extends ParserRuleContext { + public ResourceSpecificationContext resourceSpecification() { + return getRuleContext(ResourceSpecificationContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchesContext catches() { + return getRuleContext(CatchesContext.class,0); + } + public Finally_Context finally_() { + return getRuleContext(Finally_Context.class,0); + } + public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryWithResourcesStatement; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTryWithResourcesStatement(this); + else return visitor.visitChildren(this); + } + } + + public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException { + TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_tryWithResourcesStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1827); + match(TRY); + setState(1828); + resourceSpecification(); + setState(1829); + block(); + setState(1831); + _la = _input.LA(1); + if (_la==CATCH) { + { + setState(1830); + catches(); + } + } + + setState(1834); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(1833); + finally_(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceSpecificationContext extends ParserRuleContext { + public ResourceListContext resourceList() { + return getRuleContext(ResourceListContext.class,0); + } + public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resourceSpecification; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResourceSpecification(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { + ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_resourceSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1836); + match(LPAREN); + setState(1837); + resourceList(); + setState(1839); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(1838); + match(SEMI); + } + } + + setState(1841); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceListContext extends ParserRuleContext { + public List<ResourceContext> resource() { + return getRuleContexts(ResourceContext.class); + } + public ResourceContext resource(int i) { + return getRuleContext(ResourceContext.class,i); + } + public ResourceListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resourceList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResourceList(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceListContext resourceList() throws RecognitionException { + ResourceListContext _localctx = new ResourceListContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_resourceList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1843); + resource(); + setState(1848); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1844); + match(SEMI); + setState(1845); + resource(); + } + } + } + setState(1850); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,189,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceContext extends ParserRuleContext { + public UnannTypeContext unannType() { + return getRuleContext(UnannTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List<VariableModifierContext> variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public ResourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resource; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitResource(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceContext resource() throws RecognitionException { + ResourceContext _localctx = new ResourceContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_resource); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1854); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FINAL || _la==AT) { + { + { + setState(1851); + variableModifier(); + } + } + setState(1856); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1857); + unannType(); + setState(1858); + variableDeclaratorId(); + setState(1859); + match(ASSIGN); + setState(1860); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() { + return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class,0); + } + public ArrayCreationExpressionContext arrayCreationExpression() { + return getRuleContext(ArrayCreationExpressionContext.class,0); + } + public List<PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() { + return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class); + } + public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class,i); + } + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryContext primary() throws RecognitionException { + PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1864); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { + case 1: + { + setState(1862); + primaryNoNewArray_lfno_primary(); + } + break; + case 2: + { + setState(1863); + arrayCreationExpression(); + } + break; + } + setState(1869); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,192,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1866); + primaryNoNewArray_lf_primary(); + } + } + } + setState(1871); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,192,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArrayContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public ArrayAccessContext arrayAccess() { + return getRuleContext(ArrayAccessContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public MethodReferenceContext methodReference() { + return getRuleContext(MethodReferenceContext.class,0); + } + public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException { + PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_primaryNoNewArray); + int _la; + try { + setState(1901); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1872); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1873); + typeName(); + setState(1878); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1874); + match(LBRACK); + setState(1875); + match(RBRACK); + } + } + setState(1880); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1881); + match(DOT); + setState(1882); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1884); + match(VOID); + setState(1885); + match(DOT); + setState(1886); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1887); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1888); + typeName(); + setState(1889); + match(DOT); + setState(1890); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1892); + match(LPAREN); + setState(1893); + expression(); + setState(1894); + match(RPAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1896); + classInstanceCreationExpression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1897); + fieldAccess(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1898); + arrayAccess(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1899); + methodInvocation(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1900); + methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_arrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException { + PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_primaryNoNewArray_lf_arrayAccess); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpressionContext classInstanceCreationExpression() { + return getRuleContext(ClassInstanceCreationExpressionContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public MethodInvocationContext methodInvocation() { + return getRuleContext(MethodInvocationContext.class,0); + } + public MethodReferenceContext methodReference() { + return getRuleContext(MethodReferenceContext.class,0); + } + public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_arrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException { + PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_primaryNoNewArray_lfno_arrayAccess); + int _la; + try { + setState(1933); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1905); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1906); + typeName(); + setState(1911); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1907); + match(LBRACK); + setState(1908); + match(RBRACK); + } + } + setState(1913); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1914); + match(DOT); + setState(1915); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1917); + match(VOID); + setState(1918); + match(DOT); + setState(1919); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1920); + match(THIS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1921); + typeName(); + setState(1922); + match(DOT); + setState(1923); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1925); + match(LPAREN); + setState(1926); + expression(); + setState(1927); + match(RPAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1929); + classInstanceCreationExpression(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1930); + fieldAccess(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1931); + methodInvocation(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1932); + methodReference(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return getRuleContext(FieldAccess_lf_primaryContext.class,0); + } + public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() { + return getRuleContext(ArrayAccess_lf_primaryContext.class,0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return getRuleContext(MethodInvocation_lf_primaryContext.class,0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return getRuleContext(MethodReference_lf_primaryContext.class,0); + } + public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_primaryNoNewArray_lf_primary); + try { + setState(1940); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1935); + classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1936); + fieldAccess_lf_primary(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1937); + arrayAccess_lf_primary(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1938); + methodInvocation_lf_primary(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1939); + methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext { + public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() { + return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0); + } + public FieldAccess_lf_primaryContext fieldAccess_lf_primary() { + return getRuleContext(FieldAccess_lf_primaryContext.class,0); + } + public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() { + return getRuleContext(MethodInvocation_lf_primaryContext.class,0); + } + public MethodReference_lf_primaryContext methodReference_lf_primary() { + return getRuleContext(MethodReference_lf_primaryContext.class,0); + } + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException { + PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary); + try { + setState(1948); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1944); + classInstanceCreationExpression_lf_primary(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1945); + fieldAccess_lf_primary(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1946); + methodInvocation_lf_primary(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1947); + methodReference_lf_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return getRuleContext(FieldAccess_lfno_primaryContext.class,0); + } + public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() { + return getRuleContext(ArrayAccess_lfno_primaryContext.class,0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return getRuleContext(MethodInvocation_lfno_primaryContext.class,0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return getRuleContext(MethodReference_lfno_primaryContext.class,0); + } + public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_primaryNoNewArray_lfno_primary); + int _la; + try { + setState(1990); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1950); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1951); + typeName(); + setState(1956); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1952); + match(LBRACK); + setState(1953); + match(RBRACK); + } + } + setState(1958); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1959); + match(DOT); + setState(1960); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1962); + unannPrimitiveType(); + setState(1967); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1963); + match(LBRACK); + setState(1964); + match(RBRACK); + } + } + setState(1969); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1970); + match(DOT); + setState(1971); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1973); + match(VOID); + setState(1974); + match(DOT); + setState(1975); + match(CLASS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1976); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1977); + typeName(); + setState(1978); + match(DOT); + setState(1979); + match(THIS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1981); + match(LPAREN); + setState(1982); + expression(); + setState(1983); + match(RPAREN); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1985); + classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1986); + fieldAccess_lfno_primary(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1987); + arrayAccess_lfno_primary(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1988); + methodInvocation_lfno_primary(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1989); + methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary); + try { + enterOuterAlt(_localctx, 1); + { + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext { + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public UnannPrimitiveTypeContext unannPrimitiveType() { + return getRuleContext(UnannPrimitiveTypeContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() { + return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0); + } + public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() { + return getRuleContext(FieldAccess_lfno_primaryContext.class,0); + } + public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() { + return getRuleContext(MethodInvocation_lfno_primaryContext.class,0); + } + public MethodReference_lfno_primaryContext methodReference_lfno_primary() { + return getRuleContext(MethodReference_lfno_primaryContext.class,0); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException { + PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary); + int _la; + try { + setState(2033); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1994); + literal(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1995); + typeName(); + setState(2000); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1996); + match(LBRACK); + setState(1997); + match(RBRACK); + } + } + setState(2002); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2003); + match(DOT); + setState(2004); + match(CLASS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2006); + unannPrimitiveType(); + setState(2011); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(2007); + match(LBRACK); + setState(2008); + match(RBRACK); + } + } + setState(2013); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2014); + match(DOT); + setState(2015); + match(CLASS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2017); + match(VOID); + setState(2018); + match(DOT); + setState(2019); + match(CLASS); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2020); + match(THIS); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2021); + typeName(); + setState(2022); + match(DOT); + setState(2023); + match(THIS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2025); + match(LPAREN); + setState(2026); + expression(); + setState(2027); + match(RPAREN); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2029); + classInstanceCreationExpression_lfno_primary(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2030); + fieldAccess_lfno_primary(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2031); + methodInvocation_lfno_primary(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2032); + methodReference_lfno_primary(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpressionContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException { + ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_classInstanceCreationExpression); + int _la; + try { + setState(2118); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,222,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2035); + match(NEW); + setState(2037); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2036); + typeArguments(); + } + } + + setState(2042); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2039); + annotation(); + } + } + setState(2044); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2045); + match(Identifier); + setState(2056); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(2046); + match(DOT); + setState(2050); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2047); + annotation(); + } + } + setState(2052); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2053); + match(Identifier); + } + } + setState(2058); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2060); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2059); + typeArgumentsOrDiamond(); + } + } + + setState(2062); + match(LPAREN); + setState(2064); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2063); + argumentList(); + } + } + + setState(2066); + match(RPAREN); + setState(2068); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2067); + classBody(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2070); + expressionName(); + setState(2071); + match(DOT); + setState(2072); + match(NEW); + setState(2074); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2073); + typeArguments(); + } + } + + setState(2079); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2076); + annotation(); + } + } + setState(2081); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2082); + match(Identifier); + setState(2084); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2083); + typeArgumentsOrDiamond(); + } + } + + setState(2086); + match(LPAREN); + setState(2088); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2087); + argumentList(); + } + } + + setState(2090); + match(RPAREN); + setState(2092); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2091); + classBody(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2094); + primary(); + setState(2095); + match(DOT); + setState(2096); + match(NEW); + setState(2098); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2097); + typeArguments(); + } + } + + setState(2103); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2100); + annotation(); + } + } + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2106); + match(Identifier); + setState(2108); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2107); + typeArgumentsOrDiamond(); + } + } + + setState(2110); + match(LPAREN); + setState(2112); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2111); + argumentList(); + } + } + + setState(2114); + match(RPAREN); + setState(2116); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(2115); + classBody(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException { + ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_classInstanceCreationExpression_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2120); + match(DOT); + setState(2121); + match(NEW); + setState(2123); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2122); + typeArguments(); + } + } + + setState(2128); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2125); + annotation(); + } + } + setState(2130); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2131); + match(Identifier); + setState(2133); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2132); + typeArgumentsOrDiamond(); + } + } + + setState(2135); + match(LPAREN); + setState(2137); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(2136); + argumentList(); + } + } + + setState(2139); + match(RPAREN); + setState(2141); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { + case 1: + { + setState(2140); + classBody(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public List<AnnotationContext> annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() { + return getRuleContext(TypeArgumentsOrDiamondContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitClassInstanceCreationExpression_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException { + ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_classInstanceCreationExpression_lfno_primary); + int _la; + try { + setState(2202); + switch (_input.LA(1)) { + case NEW: + enterOuterAlt(_localctx, 1); + { + setState(2143); + match(NEW); + setState(2145); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2144); + typeArguments(); + } + } + + setState(2150); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2147); + annotation(); + } + } + setState(2152); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2153); + match(Identifier); + setState(2164); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(2154); + match(DOT); + setState(2158); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2155); + annotation(); + } + } + setState(2160); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2161); + match(Identifier); + } + } + setState(2166); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2168); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2167); + typeArgumentsOrDiamond(); + } + } + + setState(2170); + match(LPAREN); + setState(2172); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2171); + argumentList(); + } + } + + setState(2174); + match(RPAREN); + setState(2176); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,234,_ctx) ) { + case 1: + { + setState(2175); + classBody(); + } + break; + } + } + break; + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(2178); + expressionName(); + setState(2179); + match(DOT); + setState(2180); + match(NEW); + setState(2182); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2181); + typeArguments(); + } + } + + setState(2187); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2184); + annotation(); + } + } + setState(2189); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2190); + match(Identifier); + setState(2192); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2191); + typeArgumentsOrDiamond(); + } + } + + setState(2194); + match(LPAREN); + setState(2196); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2195); + argumentList(); + } + } + + setState(2198); + match(RPAREN); + setState(2200); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,239,_ctx) ) { + case 1: + { + setState(2199); + classBody(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { + TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_typeArgumentsOrDiamond); + try { + setState(2207); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,241,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2204); + typeArguments(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2205); + match(LT); + setState(2206); + match(GT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccessContext extends ParserRuleContext { + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public FieldAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccessContext fieldAccess() throws RecognitionException { + FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_fieldAccess); + try { + setState(2222); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2209); + primary(); + setState(2210); + match(DOT); + setState(2211); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2213); + match(SUPER); + setState(2214); + match(DOT); + setState(2215); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2216); + typeName(); + setState(2217); + match(DOT); + setState(2218); + match(SUPER); + setState(2219); + match(DOT); + setState(2220); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccess_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException { + FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 382, RULE_fieldAccess_lf_primary); + try { + enterOuterAlt(_localctx, 1); + { + setState(2224); + match(DOT); + setState(2225); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldAccess_lfno_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitFieldAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException { + FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 384, RULE_fieldAccess_lfno_primary); + try { + setState(2236); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(2227); + match(SUPER); + setState(2228); + match(DOT); + setState(2229); + match(Identifier); + } + break; + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(2230); + typeName(); + setState(2231); + match(DOT); + setState(2232); + match(SUPER); + setState(2233); + match(DOT); + setState(2234); + match(Identifier); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccessContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() { + return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0); + } + public List<PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() { + return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class); + } + public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) { + return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class,i); + } + public ArrayAccessContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccessContext arrayAccess() throws RecognitionException { + ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState()); + enterRule(_localctx, 386, RULE_arrayAccess); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2248); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,244,_ctx) ) { + case 1: + { + setState(2238); + expressionName(); + setState(2239); + match(LBRACK); + setState(2240); + expression(); + setState(2241); + match(RBRACK); + } + break; + case 2: + { + setState(2243); + primaryNoNewArray_lfno_arrayAccess(); + setState(2244); + match(LBRACK); + setState(2245); + expression(); + setState(2246); + match(RBRACK); + } + break; + } + setState(2257); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(2250); + primaryNoNewArray_lf_arrayAccess(); + setState(2251); + match(LBRACK); + setState(2252); + expression(); + setState(2253); + match(RBRACK); + } + } + setState(2259); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccess_lf_primaryContext extends ParserRuleContext { + public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() { + return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List<PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() { + return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class); + } + public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class,i); + } + public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException { + ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 388, RULE_arrayAccess_lf_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2260); + primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(); + setState(2261); + match(LBRACK); + setState(2262); + expression(); + setState(2263); + match(RBRACK); + } + setState(2272); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,246,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2265); + primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(); + setState(2266); + match(LBRACK); + setState(2267); + expression(); + setState(2268); + match(RBRACK); + } + } + } + setState(2274); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,246,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() { + return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0); + } + public List<PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() { + return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class); + } + public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) { + return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class,i); + } + public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayAccess_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayAccess_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException { + ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 390, RULE_arrayAccess_lfno_primary); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2285); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,247,_ctx) ) { + case 1: + { + setState(2275); + expressionName(); + setState(2276); + match(LBRACK); + setState(2277); + expression(); + setState(2278); + match(RBRACK); + } + break; + case 2: + { + setState(2280); + primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(); + setState(2281); + match(LBRACK); + setState(2282); + expression(); + setState(2283); + match(RBRACK); + } + break; + } + setState(2294); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,248,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2287); + primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(); + setState(2288); + match(LBRACK); + setState(2289); + expression(); + setState(2290); + match(RBRACK); + } + } + } + setState(2296); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,248,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocationContext extends ParserRuleContext { + public MethodNameContext methodName() { + return getRuleContext(MethodNameContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public MethodInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocationContext methodInvocation() throws RecognitionException { + MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState()); + enterRule(_localctx, 392, RULE_methodInvocation); + int _la; + try { + setState(2365); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,260,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2297); + methodName(); + setState(2298); + match(LPAREN); + setState(2300); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2299); + argumentList(); + } + } + + setState(2302); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2304); + typeName(); + setState(2305); + match(DOT); + setState(2307); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2306); + typeArguments(); + } + } + + setState(2309); + match(Identifier); + setState(2310); + match(LPAREN); + setState(2312); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2311); + argumentList(); + } + } + + setState(2314); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2316); + expressionName(); + setState(2317); + match(DOT); + setState(2319); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2318); + typeArguments(); + } + } + + setState(2321); + match(Identifier); + setState(2322); + match(LPAREN); + setState(2324); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2323); + argumentList(); + } + } + + setState(2326); + match(RPAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2328); + primary(); + setState(2329); + match(DOT); + setState(2331); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2330); + typeArguments(); + } + } + + setState(2333); + match(Identifier); + setState(2334); + match(LPAREN); + setState(2336); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2335); + argumentList(); + } + } + + setState(2338); + match(RPAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2340); + match(SUPER); + setState(2341); + match(DOT); + setState(2343); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2342); + typeArguments(); + } + } + + setState(2345); + match(Identifier); + setState(2346); + match(LPAREN); + setState(2348); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2347); + argumentList(); + } + } + + setState(2350); + match(RPAREN); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2351); + typeName(); + setState(2352); + match(DOT); + setState(2353); + match(SUPER); + setState(2354); + match(DOT); + setState(2356); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2355); + typeArguments(); + } + } + + setState(2358); + match(Identifier); + setState(2359); + match(LPAREN); + setState(2361); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2360); + argumentList(); + } + } + + setState(2363); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocation_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException { + MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_methodInvocation_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2367); + match(DOT); + setState(2369); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2368); + typeArguments(); + } + } + + setState(2371); + match(Identifier); + setState(2372); + match(LPAREN); + setState(2374); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | ( [...] + { + setState(2373); + argumentList(); + } + } + + setState(2376); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext { + public MethodNameContext methodName() { + return getRuleContext(MethodNameContext.class,0); + } + public ArgumentListContext argumentList() { + return getRuleContext(ArgumentListContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodInvocation_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodInvocation_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException { + MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_methodInvocation_lfno_primary); + int _la; + try { + setState(2434); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2378); + methodName(); + setState(2379); + match(LPAREN); + setState(2381); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2380); + argumentList(); + } + } + + setState(2383); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2385); + typeName(); + setState(2386); + match(DOT); + setState(2388); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2387); + typeArguments(); + } + } + + setState(2390); + match(Identifier); + setState(2391); + match(LPAREN); + setState(2393); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2392); + argumentList(); + } + } + + setState(2395); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2397); + expressionName(); + setState(2398); + match(DOT); + setState(2400); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2399); + typeArguments(); + } + } + + setState(2402); + match(Identifier); + setState(2403); + match(LPAREN); + setState(2405); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2404); + argumentList(); + } + } + + setState(2407); + match(RPAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2409); + match(SUPER); + setState(2410); + match(DOT); + setState(2412); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2411); + typeArguments(); + } + } + + setState(2414); + match(Identifier); + setState(2415); + match(LPAREN); + setState(2417); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2416); + argumentList(); + } + } + + setState(2419); + match(RPAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2420); + typeName(); + setState(2421); + match(DOT); + setState(2422); + match(SUPER); + setState(2423); + match(DOT); + setState(2425); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2424); + typeArguments(); + } + } + + setState(2427); + match(Identifier); + setState(2428); + match(LPAREN); + setState(2430); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (BANG - 69)) | [...] + { + setState(2429); + argumentList(); + } + } + + setState(2432); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArgumentListContext extends ParserRuleContext { + public List<ExpressionContext> expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argumentList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArgumentList(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentListContext argumentList() throws RecognitionException { + ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_argumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2436); + expression(); + setState(2441); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2437); + match(COMMA); + setState(2438); + expression(); + } + } + setState(2443); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReferenceContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public MethodReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReferenceContext methodReference() throws RecognitionException { + MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_methodReference); + int _la; + try { + setState(2491); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2444); + expressionName(); + setState(2445); + match(COLONCOLON); + setState(2447); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2446); + typeArguments(); + } + } + + setState(2449); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2451); + referenceType(); + setState(2452); + match(COLONCOLON); + setState(2454); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2453); + typeArguments(); + } + } + + setState(2456); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2458); + primary(); + setState(2459); + match(COLONCOLON); + setState(2461); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2460); + typeArguments(); + } + } + + setState(2463); + match(Identifier); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2465); + match(SUPER); + setState(2466); + match(COLONCOLON); + setState(2468); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2467); + typeArguments(); + } + } + + setState(2470); + match(Identifier); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2471); + typeName(); + setState(2472); + match(DOT); + setState(2473); + match(SUPER); + setState(2474); + match(COLONCOLON); + setState(2476); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2475); + typeArguments(); + } + } + + setState(2478); + match(Identifier); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2480); + classType(); + setState(2481); + match(COLONCOLON); + setState(2483); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2482); + typeArguments(); + } + } + + setState(2485); + match(NEW); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2487); + arrayType(); + setState(2488); + match(COLONCOLON); + setState(2489); + match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReference_lf_primaryContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference_lf_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference_lf_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException { + MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState()); + enterRule(_localctx, 402, RULE_methodReference_lf_primary); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2493); + match(COLONCOLON); + setState(2495); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2494); + typeArguments(); + } + } + + setState(2497); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodReference_lfno_primaryContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public TypeNameContext typeName() { + return getRuleContext(TypeNameContext.class,0); + } + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public ArrayTypeContext arrayType() { + return getRuleContext(ArrayTypeContext.class,0); + } + public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodReference_lfno_primary; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMethodReference_lfno_primary(this); + else return visitor.visitChildren(this); + } + } + + public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException { + MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState()); + enterRule(_localctx, 404, RULE_methodReference_lfno_primary); + int _la; + try { + setState(2539); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2499); + expressionName(); + setState(2500); + match(COLONCOLON); + setState(2502); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2501); + typeArguments(); + } + } + + setState(2504); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2506); + referenceType(); + setState(2507); + match(COLONCOLON); + setState(2509); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2508); + typeArguments(); + } + } + + setState(2511); + match(Identifier); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2513); + match(SUPER); + setState(2514); + match(COLONCOLON); + setState(2516); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2515); + typeArguments(); + } + } + + setState(2518); + match(Identifier); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2519); + typeName(); + setState(2520); + match(DOT); + setState(2521); + match(SUPER); + setState(2522); + match(COLONCOLON); + setState(2524); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2523); + typeArguments(); + } + } + + setState(2526); + match(Identifier); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2528); + classType(); + setState(2529); + match(COLONCOLON); + setState(2531); + _la = _input.LA(1); + if (_la==LT) { + { + setState(2530); + typeArguments(); + } + } + + setState(2533); + match(NEW); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2535); + arrayType(); + setState(2536); + match(COLONCOLON); + setState(2537); + match(NEW); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayCreationExpressionContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public DimExprsContext dimExprs() { + return getRuleContext(DimExprsContext.class,0); + } + public DimsContext dims() { + return getRuleContext(DimsContext.class,0); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayCreationExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitArrayCreationExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException { + ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState()); + enterRule(_localctx, 406, RULE_arrayCreationExpression); + try { + setState(2563); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,290,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2541); + match(NEW); + setState(2542); + primitiveType(); + setState(2543); + dimExprs(); + setState(2545); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,288,_ctx) ) { + case 1: + { + setState(2544); + dims(); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2547); + match(NEW); + setState(2548); + classOrInterfaceType(); + setState(2549); + dimExprs(); + setState(2551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,289,_ctx) ) { + case 1: + { + setState(2550); + dims(); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2553); + match(NEW); + setState(2554); + primitiveType(); + setState(2555); + dims(); + setState(2556); + arrayInitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2558); + match(NEW); + setState(2559); + classOrInterfaceType(); + setState(2560); + dims(); + setState(2561); + arrayInitializer(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimExprsContext extends ParserRuleContext { + public List<DimExprContext> dimExpr() { + return getRuleContexts(DimExprContext.class); + } + public DimExprContext dimExpr(int i) { + return getRuleContext(DimExprContext.class,i); + } + public DimExprsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dimExprs; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDimExprs(this); + else return visitor.visitChildren(this); + } + } + + public final DimExprsContext dimExprs() throws RecognitionException { + DimExprsContext _localctx = new DimExprsContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_dimExprs); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2565); + dimExpr(); + setState(2569); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,291,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(2566); + dimExpr(); + } + } + } + setState(2571); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,291,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DimExprContext extends ParserRuleContext { + 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 DimExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dimExpr; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitDimExpr(this); + else return visitor.visitChildren(this); + } + } + + public final DimExprContext dimExpr() throws RecognitionException { + DimExprContext _localctx = new DimExprContext(_ctx, getState()); + enterRule(_localctx, 410, RULE_dimExpr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2575); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT) { + { + { + setState(2572); + annotation(); + } + } + setState(2577); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2578); + match(LBRACK); + setState(2579); + expression(); + setState(2580); + match(RBRACK); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantExpressionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConstantExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantExpressionContext constantExpression() throws RecognitionException { + ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); + enterRule(_localctx, 412, RULE_constantExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2582); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionContext extends ParserRuleContext { + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class,0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 414, RULE_expression); + try { + setState(2586); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2584); + lambdaExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2585); + assignmentExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaExpressionContext extends ParserRuleContext { + public LambdaParametersContext lambdaParameters() { + return getRuleContext(LambdaParametersContext.class,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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaExpression(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 416, RULE_lambdaExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2588); + lambdaParameters(); + setState(2589); + match(ARROW); + setState(2590); + lambdaBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaParametersContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public InferredFormalParameterListContext inferredFormalParameterList() { + return getRuleContext(InferredFormalParameterListContext.class,0); + } + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaParameters; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaParameters(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 418, RULE_lambdaParameters); + int _la; + try { + setState(2602); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2592); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2593); + match(LPAREN); + setState(2595); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { + { + setState(2594); + formalParameterList(); + } + } + + setState(2597); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2598); + match(LPAREN); + setState(2599); + inferredFormalParameterList(); + setState(2600); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InferredFormalParameterListContext extends ParserRuleContext { + public List<TerminalNode> Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inferredFormalParameterList; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInferredFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException { + InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 420, RULE_inferredFormalParameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2604); + match(Identifier); + setState(2609); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2605); + match(COMMA); + setState(2606); + match(Identifier); + } + } + setState(2611); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class 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 <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLambdaBody(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaBodyContext lambdaBody() throws RecognitionException { + LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); + enterRule(_localctx, 422, RULE_lambdaBody); + try { + setState(2614); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case Identifier: + case AT: + enterOuterAlt(_localctx, 1); + { + setState(2612); + expression(); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(2613); + 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; + } + + public static class AssignmentExpressionContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class,0); + } + public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignmentExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentExpressionContext assignmentExpression() throws RecognitionException { + AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState()); + enterRule(_localctx, 424, RULE_assignmentExpression); + try { + setState(2618); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2616); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2617); + assignment(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentContext extends ParserRuleContext { + public LeftHandSideContext leftHandSide() { + return getRuleContext(LeftHandSideContext.class,0); + } + public AssignmentOperatorContext assignmentOperator() { + return getRuleContext(AssignmentOperatorContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignment; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignment(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 426, RULE_assignment); + try { + enterOuterAlt(_localctx, 1); + { + setState(2620); + leftHandSide(); + setState(2621); + assignmentOperator(); + setState(2622); + expression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LeftHandSideContext extends ParserRuleContext { + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public FieldAccessContext fieldAccess() { + return getRuleContext(FieldAccessContext.class,0); + } + public ArrayAccessContext arrayAccess() { + return getRuleContext(ArrayAccessContext.class,0); + } + public LeftHandSideContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_leftHandSide; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitLeftHandSide(this); + else return visitor.visitChildren(this); + } + } + + public final LeftHandSideContext leftHandSide() throws RecognitionException { + LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState()); + enterRule(_localctx, 428, RULE_leftHandSide); + try { + setState(2627); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,299,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2624); + expressionName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2625); + fieldAccess(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2626); + arrayAccess(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentOperatorContext extends ParserRuleContext { + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentOperator; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAssignmentOperator(this); + else return visitor.visitChildren(this); + } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 430, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2629); + _la = _input.LA(1); + if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ASSIGN - 66)) | (1L << (ADD_ASSIGN - 66)) | (1L << (SUB_ASSIGN - 66)) | (1L << (MUL_ASSIGN - 66)) | (1L << (DIV_ASSIGN - 66)) | (1L << (AND_ASSIGN - 66)) | (1L << (OR_ASSIGN - 66)) | (1L << (XOR_ASSIGN - 66)) | (1L << (MOD_ASSIGN - 66)) | (1L << (LSHIFT_ASSIGN - 66)) | (1L << (RSHIFT_ASSIGN - 66)) | (1L << (URSHIFT_ASSIGN - 66)))) != 0)) ) { + _errHandler.recoverInline(this); + } else { + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionalExpressionContext extends ParserRuleContext { + public ConditionalOrExpressionContext conditionalOrExpression() { + return getRuleContext(ConditionalOrExpressionContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalExpressionContext conditionalExpression() throws RecognitionException { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); + enterRule(_localctx, 432, RULE_conditionalExpression); + try { + setState(2638); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,300,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2631); + conditionalOrExpression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2632); + conditionalOrExpression(0); + setState(2633); + match(QUESTION); + setState(2634); + expression(); + setState(2635); + match(COLON); + setState(2636); + conditionalExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionalOrExpressionContext extends ParserRuleContext { + public ConditionalAndExpressionContext conditionalAndExpression() { + return getRuleContext(ConditionalAndExpressionContext.class,0); + } + public ConditionalOrExpressionContext conditionalOrExpression() { + return getRuleContext(ConditionalOrExpressionContext.class,0); + } + public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException { + return conditionalOrExpression(0); + } + + private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState); + ConditionalOrExpressionContext _prevctx = _localctx; + int _startState = 434; + enterRecursionRule(_localctx, 434, RULE_conditionalOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2641); + conditionalAndExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2648); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,301,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression); + setState(2643); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2644); + match(OR); + setState(2645); + conditionalAndExpression(0); + } + } + } + setState(2650); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,301,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ConditionalAndExpressionContext extends ParserRuleContext { + public InclusiveOrExpressionContext inclusiveOrExpression() { + return getRuleContext(InclusiveOrExpressionContext.class,0); + } + public ConditionalAndExpressionContext conditionalAndExpression() { + return getRuleContext(ConditionalAndExpressionContext.class,0); + } + public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalAndExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitConditionalAndExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException { + return conditionalAndExpression(0); + } + + private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState); + ConditionalAndExpressionContext _prevctx = _localctx; + int _startState = 436; + enterRecursionRule(_localctx, 436, RULE_conditionalAndExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2652); + inclusiveOrExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2659); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,302,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ConditionalAndExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression); + setState(2654); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2655); + match(AND); + setState(2656); + inclusiveOrExpression(0); + } + } + } + setState(2661); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,302,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class InclusiveOrExpressionContext extends ParserRuleContext { + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return getRuleContext(ExclusiveOrExpressionContext.class,0); + } + public InclusiveOrExpressionContext inclusiveOrExpression() { + return getRuleContext(InclusiveOrExpressionContext.class,0); + } + public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inclusiveOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitInclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException { + return inclusiveOrExpression(0); + } + + private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState); + InclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 438; + enterRecursionRule(_localctx, 438, RULE_inclusiveOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2663); + exclusiveOrExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2670); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,303,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new InclusiveOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression); + setState(2665); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2666); + match(BITOR); + setState(2667); + exclusiveOrExpression(0); + } + } + } + setState(2672); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,303,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ExclusiveOrExpressionContext extends ParserRuleContext { + public AndExpressionContext andExpression() { + return getRuleContext(AndExpressionContext.class,0); + } + public ExclusiveOrExpressionContext exclusiveOrExpression() { + return getRuleContext(ExclusiveOrExpressionContext.class,0); + } + public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusiveOrExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitExclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException { + return exclusiveOrExpression(0); + } + + private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState); + ExclusiveOrExpressionContext _prevctx = _localctx; + int _startState = 440; + enterRecursionRule(_localctx, 440, RULE_exclusiveOrExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2674); + andExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2681); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,304,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression); + setState(2676); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2677); + match(CARET); + setState(2678); + andExpression(0); + } + } + } + setState(2683); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,304,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AndExpressionContext extends ParserRuleContext { + public EqualityExpressionContext equalityExpression() { + return getRuleContext(EqualityExpressionContext.class,0); + } + public AndExpressionContext andExpression() { + return getRuleContext(AndExpressionContext.class,0); + } + public AndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_andExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAndExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AndExpressionContext andExpression() throws RecognitionException { + return andExpression(0); + } + + private AndExpressionContext andExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState); + AndExpressionContext _prevctx = _localctx; + int _startState = 442; + enterRecursionRule(_localctx, 442, RULE_andExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2685); + equalityExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2692); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,305,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new AndExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_andExpression); + setState(2687); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2688); + match(BITAND); + setState(2689); + equalityExpression(0); + } + } + } + setState(2694); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,305,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class EqualityExpressionContext extends ParserRuleContext { + public RelationalExpressionContext relationalExpression() { + return getRuleContext(RelationalExpressionContext.class,0); + } + public EqualityExpressionContext equalityExpression() { + return getRuleContext(EqualityExpressionContext.class,0); + } + public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_equalityExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitEqualityExpression(this); + else return visitor.visitChildren(this); + } + } + + public final EqualityExpressionContext equalityExpression() throws RecognitionException { + return equalityExpression(0); + } + + private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState); + EqualityExpressionContext _prevctx = _localctx; + int _startState = 444; + enterRecursionRule(_localctx, 444, RULE_equalityExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2696); + relationalExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2706); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,307,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2704); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) { + case 1: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + setState(2698); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2699); + match(EQUAL); + setState(2700); + relationalExpression(0); + } + break; + case 2: + { + _localctx = new EqualityExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression); + setState(2701); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2702); + match(NOTEQUAL); + setState(2703); + relationalExpression(0); + } + break; + } + } + } + setState(2708); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,307,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class RelationalExpressionContext extends ParserRuleContext { + public ShiftExpressionContext shiftExpression() { + return getRuleContext(ShiftExpressionContext.class,0); + } + public RelationalExpressionContext relationalExpression() { + return getRuleContext(RelationalExpressionContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public RelationalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relationalExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitRelationalExpression(this); + else return visitor.visitChildren(this); + } + } + + public final RelationalExpressionContext relationalExpression() throws RecognitionException { + return relationalExpression(0); + } + + private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState); + RelationalExpressionContext _prevctx = _localctx; + int _startState = 446; + enterRecursionRule(_localctx, 446, RULE_relationalExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2710); + shiftExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2729); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,309,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2727); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) { + case 1: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2712); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(2713); + match(LT); + setState(2714); + shiftExpression(0); + } + break; + case 2: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2715); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(2716); + match(GT); + setState(2717); + shiftExpression(0); + } + break; + case 3: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2718); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2719); + match(LE); + setState(2720); + shiftExpression(0); + } + break; + case 4: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2721); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2722); + match(GE); + setState(2723); + shiftExpression(0); + } + break; + case 5: + { + _localctx = new RelationalExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression); + setState(2724); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2725); + match(INSTANCEOF); + setState(2726); + referenceType(); + } + break; + } + } + } + setState(2731); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,309,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ShiftExpressionContext extends ParserRuleContext { + public AdditiveExpressionContext additiveExpression() { + return getRuleContext(AdditiveExpressionContext.class,0); + } + public ShiftExpressionContext shiftExpression() { + return getRuleContext(ShiftExpressionContext.class,0); + } + public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shiftExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitShiftExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ShiftExpressionContext shiftExpression() throws RecognitionException { + return shiftExpression(0); + } + + private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState); + ShiftExpressionContext _prevctx = _localctx; + int _startState = 448; + enterRecursionRule(_localctx, 448, RULE_shiftExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2733); + additiveExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2750); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2748); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) { + case 1: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2735); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2736); + match(LT); + setState(2737); + match(LT); + setState(2738); + additiveExpression(0); + } + break; + case 2: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2739); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2740); + match(GT); + setState(2741); + match(GT); + setState(2742); + additiveExpression(0); + } + break; + case 3: + { + _localctx = new ShiftExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression); + setState(2743); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2744); + match(GT); + setState(2745); + match(GT); + setState(2746); + match(GT); + setState(2747); + additiveExpression(0); + } + break; + } + } + } + setState(2752); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,311,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AdditiveExpressionContext extends ParserRuleContext { + public MultiplicativeExpressionContext multiplicativeExpression() { + return getRuleContext(MultiplicativeExpressionContext.class,0); + } + public AdditiveExpressionContext additiveExpression() { + return getRuleContext(AdditiveExpressionContext.class,0); + } + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additiveExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitAdditiveExpression(this); + else return visitor.visitChildren(this); + } + } + + public final AdditiveExpressionContext additiveExpression() throws RecognitionException { + return additiveExpression(0); + } + + private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState); + AdditiveExpressionContext _prevctx = _localctx; + int _startState = 450; + enterRecursionRule(_localctx, 450, RULE_additiveExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2754); + multiplicativeExpression(0); + } + _ctx.stop = _input.LT(-1); + setState(2764); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,313,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2762); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,312,_ctx) ) { + case 1: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + setState(2756); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2757); + match(ADD); + setState(2758); + multiplicativeExpression(0); + } + break; + case 2: + { + _localctx = new AdditiveExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression); + setState(2759); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2760); + match(SUB); + setState(2761); + multiplicativeExpression(0); + } + break; + } + } + } + setState(2766); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,313,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public MultiplicativeExpressionContext multiplicativeExpression() { + return getRuleContext(MultiplicativeExpressionContext.class,0); + } + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multiplicativeExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitMultiplicativeExpression(this); + else return visitor.visitChildren(this); + } + } + + public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { + return multiplicativeExpression(0); + } + + private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState); + MultiplicativeExpressionContext _prevctx = _localctx; + int _startState = 452; + enterRecursionRule(_localctx, 452, RULE_multiplicativeExpression, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(2768); + unaryExpression(); + } + _ctx.stop = _input.LT(-1); + setState(2781); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,315,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(2779); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,314,_ctx) ) { + case 1: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2770); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(2771); + match(MUL); + setState(2772); + unaryExpression(); + } + break; + case 2: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2773); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(2774); + match(DIV); + setState(2775); + unaryExpression(); + } + break; + case 3: + { + _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression); + setState(2776); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(2777); + match(MOD); + setState(2778); + unaryExpression(); + } + break; + } + } + } + setState(2783); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,315,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class UnaryExpressionContext extends ParserRuleContext { + public PreIncrementExpressionContext preIncrementExpression() { + return getRuleContext(PreIncrementExpressionContext.class,0); + } + public PreDecrementExpressionContext preDecrementExpression() { + return getRuleContext(PreDecrementExpressionContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0); + } + public UnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnaryExpression(this); + else return visitor.visitChildren(this); + } + } + + public final UnaryExpressionContext unaryExpression() throws RecognitionException { + UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 454, RULE_unaryExpression); + try { + setState(2791); + switch (_input.LA(1)) { + case INC: + enterOuterAlt(_localctx, 1); + { + setState(2784); + preIncrementExpression(); + } + break; + case DEC: + enterOuterAlt(_localctx, 2); + { + setState(2785); + preDecrementExpression(); + } + break; + case ADD: + enterOuterAlt(_localctx, 3); + { + setState(2786); + match(ADD); + setState(2787); + unaryExpression(); + } + break; + case SUB: + enterOuterAlt(_localctx, 4); + { + setState(2788); + match(SUB); + setState(2789); + unaryExpression(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case IntegerLiteral: + case FloatingPointLiteral: + case BooleanLiteral: + case CharacterLiteral: + case StringLiteral: + case NullLiteral: + case LPAREN: + case BANG: + case TILDE: + case Identifier: + case AT: + enterOuterAlt(_localctx, 5); + { + setState(2790); + unaryExpressionNotPlusMinus(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PreIncrementExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preIncrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPreIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException { + PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 456, RULE_preIncrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2793); + match(INC); + setState(2794); + unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PreDecrementExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_preDecrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPreDecrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException { + PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 458, RULE_preDecrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2796); + match(DEC); + setState(2797); + unaryExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public CastExpressionContext castExpression() { + return getRuleContext(CastExpressionContext.class,0); + } + public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitUnaryExpressionNotPlusMinus(this); + else return visitor.visitChildren(this); + } + } + + public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException { + UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState()); + enterRule(_localctx, 460, RULE_unaryExpressionNotPlusMinus); + try { + setState(2805); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,317,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2799); + postfixExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2800); + match(TILDE); + setState(2801); + unaryExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2802); + match(BANG); + setState(2803); + unaryExpression(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2804); + castExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostfixExpressionContext extends ParserRuleContext { + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public ExpressionNameContext expressionName() { + return getRuleContext(ExpressionNameContext.class,0); + } + public List<PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() { + return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class); + } + public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) { + return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class,i); + } + public List<PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() { + return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class); + } + public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) { + return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class,i); + } + public PostfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostfixExpressionContext postfixExpression() throws RecognitionException { + PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 462, RULE_postfixExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2809); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,318,_ctx) ) { + case 1: + { + setState(2807); + primary(); + } + break; + case 2: + { + setState(2808); + expressionName(); + } + break; + } + setState(2815); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,320,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(2813); + switch (_input.LA(1)) { + case INC: + { + setState(2811); + postIncrementExpression_lf_postfixExpression(); + } + break; + case DEC: + { + setState(2812); + postDecrementExpression_lf_postfixExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(2817); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,320,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostIncrementExpressionContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postIncrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostIncrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException { + PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 464, RULE_postIncrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2818); + postfixExpression(); + setState(2819); + match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postIncrementExpression_lf_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostIncrementExpression_lf_postfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException { + PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 466, RULE_postIncrementExpression_lf_postfixExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2821); + match(INC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostDecrementExpressionContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postDecrementExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostDecrementExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException { + PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState()); + enterRule(_localctx, 468, RULE_postDecrementExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2823); + postfixExpression(); + setState(2824); + match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext { + public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postDecrementExpression_lf_postfixExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitPostDecrementExpression_lf_postfixExpression(this); + else return visitor.visitChildren(this); + } + } + + public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException { + PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState()); + enterRule(_localctx, 470, RULE_postDecrementExpression_lf_postfixExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2826); + match(DEC); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CastExpressionContext extends ParserRuleContext { + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public ReferenceTypeContext referenceType() { + return getRuleContext(ReferenceTypeContext.class,0); + } + public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() { + return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0); + } + public List<AdditionalBoundContext> additionalBound() { + return getRuleContexts(AdditionalBoundContext.class); + } + public AdditionalBoundContext additionalBound(int i) { + return getRuleContext(AdditionalBoundContext.class,i); + } + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public CastExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_castExpression; } + @Override + public <T> T accept(ParseTreeVisitor<? extends T> visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor<? extends T>)visitor).visitCastExpression(this); + else return visitor.visitChildren(this); + } + } + + public final CastExpressionContext castExpression() throws RecognitionException { + CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState()); + enterRule(_localctx, 472, RULE_castExpression); + int _la; + try { + setState(2855); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,323,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2828); + match(LPAREN); + setState(2829); + primitiveType(); + setState(2830); + match(RPAREN); + setState(2831); + unaryExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2833); + match(LPAREN); + setState(2834); + referenceType(); + setState(2838); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(2835); + additionalBound(); + } + } + setState(2840); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2841); + match(RPAREN); + setState(2842); + unaryExpressionNotPlusMinus(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2844); + match(LPAREN); + setState(2845); + referenceType(); + setState(2849); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(2846); + additionalBound(); + } + } + setState(2851); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2852); + match(RPAREN); + setState(2853); + lambdaExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 26: + return packageName_sempred((PackageNameContext)_localctx, predIndex); + case 28: + return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex); + case 31: + return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex); + case 217: + return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex); + case 218: + return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex); + case 219: + return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex); + case 220: + return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex); + case 221: + return andExpression_sempred((AndExpressionContext)_localctx, predIndex); + case 222: + return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex); + case 223: + return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex); + case 224: + return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex); + case 225: + return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex); + case 226: + return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 1); + } + return true; + } + private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 1); + } + return true; + } + private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) { + switch (predIndex) { + case 2: + return precpred(_ctx, 1); + } + return true; + } + private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 3: + return precpred(_ctx, 1); + } + return true; + } + private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 4: + return precpred(_ctx, 1); + } + return true; + } + private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return precpred(_ctx, 1); + } + return true; + } + private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return precpred(_ctx, 1); + } + return true; + } + private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return precpred(_ctx, 1); + } + return true; + } + private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 8: + return precpred(_ctx, 2); + case 9: + return precpred(_ctx, 1); + } + return true; + } + private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 10: + return precpred(_ctx, 5); + case 11: + return precpred(_ctx, 4); + case 12: + return precpred(_ctx, 3); + case 13: + return precpred(_ctx, 2); + case 14: + return precpred(_ctx, 1); + } + return true; + } + private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 15: + return precpred(_ctx, 3); + case 16: + return precpred(_ctx, 2); + case 17: + return precpred(_ctx, 1); + } + return true; + } + private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 18: + return precpred(_ctx, 2); + case 19: + return precpred(_ctx, 1); + } + return true; + } + private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 20: + return precpred(_ctx, 3); + case 21: + return precpred(_ctx, 2); + case 22: + return precpred(_ctx, 1); + } + return true; + } + + private static final int _serializedATNSegments = 2; + private static final String _serializedATNSegment0 = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3m\u0b2c\4\2\t\2\4"+ + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ + "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ + "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ + "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ + "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ + "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ + "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+ + "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+ + "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+ + "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+ + "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+ + "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+ + "\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+ + "\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+ + "\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+ + "\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+ + "\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+ + "\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+ + "\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+ + "\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+ + "\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+ + "\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+ + "\4\u00ed\t\u00ed\4\u00ee\t\u00ee\3\2\3\2\3\3\3\3\5\3\u01e1\n\3\3\4\7\4"+ + "\u01e4\n\4\f\4\16\4\u01e7\13\4\3\4\3\4\7\4\u01eb\n\4\f\4\16\4\u01ee\13"+ + "\4\3\4\5\4\u01f1\n\4\3\5\3\5\5\5\u01f5\n\5\3\6\3\6\3\7\3\7\3\b\3\b\3\b"+ + "\5\b\u01fe\n\b\3\t\3\t\5\t\u0202\n\t\3\t\3\t\7\t\u0206\n\t\f\t\16\t\u0209"+ + "\13\t\3\n\7\n\u020c\n\n\f\n\16\n\u020f\13\n\3\n\3\n\5\n\u0213\n\n\3\n"+ + "\3\n\3\n\7\n\u0218\n\n\f\n\16\n\u021b\13\n\3\n\3\n\5\n\u021f\n\n\5\n\u0221"+ + "\n\n\3\13\3\13\7\13\u0225\n\13\f\13\16\13\u0228\13\13\3\13\3\13\5\13\u022c"+ + "\n\13\3\f\7\f\u022f\n\f\f\f\16\f\u0232\13\f\3\f\3\f\5\f\u0236\n\f\3\r"+ + "\3\r\3\16\3\16\3\17\3\17\3\20\7\20\u023f\n\20\f\20\16\20\u0242\13\20\3"+ + "\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u024f\n\21"+ + "\3\22\7\22\u0252\n\22\f\22\16\22\u0255\13\22\3\22\3\22\3\22\7\22\u025a"+ + "\n\22\f\22\16\22\u025d\13\22\3\22\3\22\7\22\u0261\n\22\f\22\16\22\u0264"+ + "\13\22\3\23\7\23\u0267\n\23\f\23\16\23\u026a\13\23\3\23\3\23\5\23\u026e"+ + "\n\23\3\24\3\24\3\25\3\25\3\25\3\25\3\25\7\25\u0277\n\25\f\25\16\25\u027a"+ + "\13\25\5\25\u027c\n\25\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\30\3\30\3"+ + "\30\7\30\u0288\n\30\f\30\16\30\u028b\13\30\3\31\3\31\5\31\u028f\n\31\3"+ + "\32\7\32\u0292\n\32\f\32\16\32\u0295\13\32\3\32\3\32\5\32\u0299\n\32\3"+ + "\33\3\33\3\33\3\33\5\33\u029f\n\33\3\34\3\34\3\34\3\34\3\34\3\34\7\34"+ + "\u02a7\n\34\f\34\16\34\u02aa\13\34\3\35\3\35\3\35\3\35\3\35\5\35\u02b1"+ + "\n\35\3\36\3\36\3\36\3\36\3\36\3\36\7\36\u02b9\n\36\f\36\16\36\u02bc\13"+ + "\36\3\37\3\37\3\37\3\37\3\37\5\37\u02c3\n\37\3 \3 \3!\3!\3!\3!\3!\3!\7"+ + "!\u02cd\n!\f!\16!\u02d0\13!\3\"\5\"\u02d3\n\"\3\"\7\"\u02d6\n\"\f\"\16"+ + "\"\u02d9\13\"\3\"\7\"\u02dc\n\"\f\"\16\"\u02df\13\"\3\"\3\"\3#\7#\u02e4"+ + "\n#\f#\16#\u02e7\13#\3#\3#\3#\3#\7#\u02ed\n#\f#\16#\u02f0\13#\3#\3#\3"+ + "$\3$\3%\3%\3%\3%\5%\u02fa\n%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3"+ + "(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3*\5*\u0317\n*\3+\3+\5+\u031b"+ + "\n+\3,\7,\u031e\n,\f,\16,\u0321\13,\3,\3,\3,\5,\u0326\n,\3,\5,\u0329\n"+ + ",\3,\5,\u032c\n,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0338\n-\3.\3.\3.\3"+ + ".\3/\3/\3/\7/\u0341\n/\f/\16/\u0344\13/\3\60\3\60\3\60\3\61\3\61\3\61"+ + "\3\62\3\62\3\62\7\62\u034f\n\62\f\62\16\62\u0352\13\62\3\63\3\63\7\63"+ + "\u0356\n\63\f\63\16\63\u0359\13\63\3\63\3\63\3\64\3\64\3\64\3\64\5\64"+ + "\u0361\n\64\3\65\3\65\3\65\3\65\3\65\5\65\u0368\n\65\3\66\7\66\u036b\n"+ + "\66\f\66\16\66\u036e\13\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67"+ + "\3\67\3\67\3\67\5\67\u037c\n\67\38\38\38\78\u0381\n8\f8\168\u0384\138"+ + "\39\39\39\59\u0389\n9\3:\3:\5:\u038d\n:\3;\3;\5;\u0391\n;\3<\3<\5<\u0395"+ + "\n<\3=\3=\5=\u0399\n=\3>\3>\3>\5>\u039e\n>\3?\3?\5?\u03a2\n?\3?\3?\7?"+ + "\u03a6\n?\f?\16?\u03a9\13?\3@\3@\5@\u03ad\n@\3@\3@\3@\7@\u03b2\n@\f@\16"+ + "@\u03b5\13@\3@\3@\5@\u03b9\n@\5@\u03bb\n@\3A\3A\7A\u03bf\nA\fA\16A\u03c2"+ + "\13A\3A\3A\5A\u03c6\nA\3B\3B\5B\u03ca\nB\3C\3C\3D\3D\3E\3E\3F\3F\3G\3"+ + "G\3G\3G\3G\3G\3G\3G\3G\5G\u03dd\nG\3H\7H\u03e0\nH\fH\16H\u03e3\13H\3H"+ + "\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03f2\nI\3J\3J\3J\5J\u03f7\nJ"+ + "\3J\3J\7J\u03fb\nJ\fJ\16J\u03fe\13J\3J\3J\3J\5J\u0403\nJ\5J\u0405\nJ\3"+ + "K\3K\5K\u0409\nK\3L\3L\3L\5L\u040e\nL\3L\3L\5L\u0412\nL\3M\3M\3M\3M\3"+ + "M\5M\u0419\nM\3N\3N\3N\7N\u041e\nN\fN\16N\u0421\13N\3N\3N\3N\7N\u0426"+ + "\nN\fN\16N\u0429\13N\5N\u042b\nN\3O\7O\u042e\nO\fO\16O\u0431\13O\3O\3"+ + "O\3O\3P\3P\5P\u0438\nP\3Q\7Q\u043b\nQ\fQ\16Q\u043e\13Q\3Q\3Q\7Q\u0442"+ + "\nQ\fQ\16Q\u0445\13Q\3Q\3Q\3Q\3Q\5Q\u044b\nQ\3R\7R\u044e\nR\fR\16R\u0451"+ + "\13R\3R\3R\3R\5R\u0456\nR\3R\3R\3S\3S\3S\3T\3T\3T\7T\u0460\nT\fT\16T\u0463"+ + "\13T\3U\3U\5U\u0467\nU\3V\3V\5V\u046b\nV\3W\3W\3X\3X\3X\3Y\7Y\u0473\n"+ + "Y\fY\16Y\u0476\13Y\3Y\3Y\5Y\u047a\nY\3Y\3Y\3Z\3Z\3Z\3Z\5Z\u0482\nZ\3["+ + "\5[\u0485\n[\3[\3[\3[\5[\u048a\n[\3[\3[\3\\\3\\\3]\3]\5]\u0492\n]\3]\5"+ + "]\u0495\n]\3]\3]\3^\5^\u049a\n^\3^\3^\3^\5^\u049f\n^\3^\3^\3^\5^\u04a4"+ + "\n^\3^\3^\3^\5^\u04a9\n^\3^\3^\3^\3^\3^\5^\u04b0\n^\3^\3^\3^\5^\u04b5"+ + "\n^\3^\3^\3^\3^\3^\3^\5^\u04bd\n^\3^\3^\3^\5^\u04c2\n^\3^\3^\3^\5^\u04c7"+ + "\n^\3_\7_\u04ca\n_\f_\16_\u04cd\13_\3_\3_\3_\5_\u04d2\n_\3_\3_\3`\3`\5"+ + "`\u04d8\n`\3`\5`\u04db\n`\3`\5`\u04de\n`\3`\3`\3a\3a\3a\7a\u04e5\na\f"+ + "a\16a\u04e8\13a\3b\7b\u04eb\nb\fb\16b\u04ee\13b\3b\3b\3b\5b\u04f3\nb\3"+ + "b\5b\u04f6\nb\3b\5b\u04f9\nb\3c\3c\3d\3d\7d\u04ff\nd\fd\16d\u0502\13d"+ + "\3e\3e\5e\u0506\ne\3f\7f\u0509\nf\ff\16f\u050c\13f\3f\3f\3f\5f\u0511\n"+ + "f\3f\5f\u0514\nf\3f\3f\3g\3g\3g\3g\3g\3g\3g\5g\u051f\ng\3h\3h\3h\3i\3"+ + "i\7i\u0526\ni\fi\16i\u0529\13i\3i\3i\3j\3j\3j\3j\3j\5j\u0532\nj\3k\7k"+ + "\u0535\nk\fk\16k\u0538\13k\3k\3k\3k\3k\3l\3l\3l\3l\5l\u0542\nl\3m\7m\u0545"+ + "\nm\fm\16m\u0548\13m\3m\3m\3m\3n\3n\3n\3n\3n\3n\5n\u0553\nn\3o\7o\u0556"+ + "\no\fo\16o\u0559\13o\3o\3o\3o\3o\3o\3p\3p\7p\u0562\np\fp\16p\u0565\13"+ + "p\3p\3p\3q\3q\3q\3q\3q\5q\u056e\nq\3r\7r\u0571\nr\fr\16r\u0574\13r\3r"+ + "\3r\3r\3r\3r\5r\u057b\nr\3r\5r\u057e\nr\3r\3r\3s\3s\3s\5s\u0585\ns\3t"+ + "\3t\3t\3u\3u\3u\5u\u058d\nu\3v\3v\3v\3v\5v\u0593\nv\3v\3v\3w\3w\3w\7w"+ + "\u059a\nw\fw\16w\u059d\13w\3x\3x\3x\3x\3y\3y\3y\5y\u05a6\ny\3z\3z\5z\u05aa"+ + "\nz\3z\5z\u05ad\nz\3z\3z\3{\3{\3{\7{\u05b4\n{\f{\16{\u05b7\13{\3|\3|\3"+ + "|\3}\3}\3}\3}\3}\3}\3~\3~\5~\u05c4\n~\3~\5~\u05c7\n~\3~\3~\3\177\3\177"+ + "\3\177\7\177\u05ce\n\177\f\177\16\177\u05d1\13\177\3\u0080\3\u0080\5\u0080"+ + "\u05d5\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\7\u0081\u05db\n\u0081\f"+ + "\u0081\16\u0081\u05de\13\u0081\3\u0082\3\u0082\3\u0082\5\u0082\u05e3\n"+ + "\u0082\3\u0083\3\u0083\3\u0083\3\u0084\7\u0084\u05e9\n\u0084\f\u0084\16"+ + "\u0084\u05ec\13\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\3\u0085\5\u0085\u05f7\n\u0085\3\u0086\3\u0086\3\u0086"+ + "\3\u0086\3\u0086\5\u0086\u05fe\n\u0086\3\u0087\3\u0087\3\u0087\3\u0087"+ + "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\5\u0087"+ + "\u060c\n\u0087\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u008a"+ + "\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c"+ + "\3\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u0622\n\u008c\3\u008d\3\u008d"+ + "\3\u008d\3\u008d\3\u008d\3\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+ + "\3\u008e\3\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f"+ + "\3\u008f\3\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090"+ + "\3\u0090\3\u0090\3\u0090\5\u0090\u0644\n\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\3\u0091\3\u0091\3\u0092\3\u0092\7\u0092\u064e\n\u0092\f\u0092"+ + "\16\u0092\u0651\13\u0092\3\u0092\7\u0092\u0654\n\u0092\f\u0092\16\u0092"+ + "\u0657\13\u0092\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094"+ + "\7\u0094\u0660\n\u0094\f\u0094\16\u0094\u0663\13\u0094\3\u0095\3\u0095"+ + "\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\3\u0095\5\u0095"+ + "\u066f\n\u0095\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+ + "\3\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099"+ + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\5\u009a"+ + "\u0689\n\u009a\3\u009b\3\u009b\5\u009b\u068d\n\u009b\3\u009c\3\u009c\3"+ + "\u009c\5\u009c\u0692\n\u009c\3\u009c\3\u009c\5\u009c\u0696\n\u009c\3\u009c"+ + "\3\u009c\5\u009c\u069a\n\u009c\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d"+ + "\3\u009d\5\u009d\u06a2\n\u009d\3\u009d\3\u009d\5\u009d\u06a6\n\u009d\3"+ + "\u009d\3\u009d\5\u009d\u06aa\n\u009d\3\u009d\3\u009d\3\u009d\3\u009e\3"+ + "\u009e\5\u009e\u06b1\n\u009e\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\7"+ + "\u00a0\u06b8\n\u00a0\f\u00a0\16\u00a0\u06bb\13\u00a0\3\u00a1\3\u00a1\3"+ + "\u00a1\7\u00a1\u06c0\n\u00a1\f\u00a1\16\u00a1\u06c3\13\u00a1\3\u00a1\3"+ + "\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2"+ + "\7\u00a2\u06cf\n\u00a2\f\u00a2\16\u00a2\u06d2\13\u00a2\3\u00a2\3\u00a2"+ + "\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u06dd"+ + "\n\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\5\u00a4\u06e3\n\u00a4\3\u00a4"+ + "\3\u00a4\3\u00a5\3\u00a5\5\u00a5\u06e9\n\u00a5\3\u00a5\3\u00a5\3\u00a6"+ + "\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7"+ + "\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u06fe"+ + "\n\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0703\n\u00a8\3\u00a9\3\u00a9"+ + "\7\u00a9\u0707\n\u00a9\f\u00a9\16\u00a9\u070a\13\u00a9\3\u00aa\3\u00aa"+ + "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00ab\7\u00ab\u0713\n\u00ab\f\u00ab"+ + "\16\u00ab\u0716\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac"+ + "\7\u00ac\u071e\n\u00ac\f\u00ac\16\u00ac\u0721\13\u00ac\3\u00ad\3\u00ad"+ + "\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u072a\n\u00ae\3\u00ae"+ + "\5\u00ae\u072d\n\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u0732\n\u00af\3"+ + "\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\7\u00b0\u0739\n\u00b0\f\u00b0\16"+ + "\u00b0\u073c\13\u00b0\3\u00b1\7\u00b1\u073f\n\u00b1\f\u00b1\16\u00b1\u0742"+ + "\13\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\5\u00b2"+ + "\u074b\n\u00b2\3\u00b2\7\u00b2\u074e\n\u00b2\f\u00b2\16\u00b2\u0751\13"+ + "\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3\7\u00b3\u0757\n\u00b3\f\u00b3\16"+ + "\u00b3\u075a\13\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3"+ + "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3"+ + "\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\5\u00b3\u0770\n\u00b3\3\u00b4"+ + "\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5\7\u00b5\u0778\n\u00b5\f\u00b5"+ + "\16\u00b5\u077b\13\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5"+ + "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5"+ + "\3\u00b5\3\u00b5\3\u00b5\3\u00b5\5\u00b5\u0790\n\u00b5\3\u00b6\3\u00b6"+ + "\3\u00b6\3\u00b6\3\u00b6\5\u00b6\u0797\n\u00b6\3\u00b7\3\u00b7\3\u00b8"+ + "\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u079f\n\u00b8\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\7\u00b9\u07a5\n\u00b9\f\u00b9\16\u00b9\u07a8\13\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\7\u00b9\u07b0\n\u00b9\f\u00b9"+ + "\16\u00b9\u07b3\13\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9"+ + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07c9\n\u00b9\3\u00ba"+ + "\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\7\u00bb\u07d1\n\u00bb\f\u00bb"+ + "\16\u00bb\u07d4\13\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+ + "\7\u00bb\u07dc\n\u00bb\f\u00bb\16\u00bb\u07df\13\u00bb\3\u00bb\3\u00bb"+ + "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+ + "\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb"+ + "\u07f4\n\u00bb\3\u00bc\3\u00bc\5\u00bc\u07f8\n\u00bc\3\u00bc\7\u00bc\u07fb"+ + "\n\u00bc\f\u00bc\16\u00bc\u07fe\13\u00bc\3\u00bc\3\u00bc\3\u00bc\7\u00bc"+ + "\u0803\n\u00bc\f\u00bc\16\u00bc\u0806\13\u00bc\3\u00bc\7\u00bc\u0809\n"+ + "\u00bc\f\u00bc\16\u00bc\u080c\13\u00bc\3\u00bc\5\u00bc\u080f\n\u00bc\3"+ + "\u00bc\3\u00bc\5\u00bc\u0813\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0817\n\u00bc"+ + "\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u081d\n\u00bc\3\u00bc\7\u00bc"+ + "\u0820\n\u00bc\f\u00bc\16\u00bc\u0823\13\u00bc\3\u00bc\3\u00bc\5\u00bc"+ + "\u0827\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u082b\n\u00bc\3\u00bc\3\u00bc\5"+ + "\u00bc\u082f\n\u00bc\3\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u0835\n\u00bc"+ + "\3\u00bc\7\u00bc\u0838\n\u00bc\f\u00bc\16\u00bc\u083b\13\u00bc\3\u00bc"+ + "\3\u00bc\5\u00bc\u083f\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0843\n\u00bc\3"+ + "\u00bc\3\u00bc\5\u00bc\u0847\n\u00bc\5\u00bc\u0849\n\u00bc\3\u00bd\3\u00bd"+ + "\3\u00bd\5\u00bd\u084e\n\u00bd\3\u00bd\7\u00bd\u0851\n\u00bd\f\u00bd\16"+ + "\u00bd\u0854\13\u00bd\3\u00bd\3\u00bd\5\u00bd\u0858\n\u00bd\3\u00bd\3"+ + "\u00bd\5\u00bd\u085c\n\u00bd\3\u00bd\3\u00bd\5\u00bd\u0860\n\u00bd\3\u00be"+ + "\3\u00be\5\u00be\u0864\n\u00be\3\u00be\7\u00be\u0867\n\u00be\f\u00be\16"+ + "\u00be\u086a\13\u00be\3\u00be\3\u00be\3\u00be\7\u00be\u086f\n\u00be\f"+ + "\u00be\16\u00be\u0872\13\u00be\3\u00be\7\u00be\u0875\n\u00be\f\u00be\16"+ + "\u00be\u0878\13\u00be\3\u00be\5\u00be\u087b\n\u00be\3\u00be\3\u00be\5"+ + "\u00be\u087f\n\u00be\3\u00be\3\u00be\5\u00be\u0883\n\u00be\3\u00be\3\u00be"+ + "\3\u00be\3\u00be\5\u00be\u0889\n\u00be\3\u00be\7\u00be\u088c\n\u00be\f"+ + "\u00be\16\u00be\u088f\13\u00be\3\u00be\3\u00be\5\u00be\u0893\n\u00be\3"+ + "\u00be\3\u00be\5\u00be\u0897\n\u00be\3\u00be\3\u00be\5\u00be\u089b\n\u00be"+ + "\5\u00be\u089d\n\u00be\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u08a2\n\u00bf\3"+ + "\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+ + "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u08b1\n\u00c0\3\u00c1\3\u00c1"+ + "\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2\3\u00c2"+ + "\3\u00c2\5\u00c2\u08bf\n\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3"+ + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3\u08cb\n\u00c3\3\u00c3"+ + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\7\u00c3\u08d2\n\u00c3\f\u00c3\16\u00c3"+ + "\u08d5\13\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+ + "\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u08e1\n\u00c4\f\u00c4\16\u00c4\u08e4"+ + "\13\u00c4\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\3\u00c5\5\u00c5\u08f0\n\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5"+ + "\3\u00c5\7\u00c5\u08f7\n\u00c5\f\u00c5\16\u00c5\u08fa\13\u00c5\3\u00c6"+ + "\3\u00c6\3\u00c6\5\u00c6\u08ff\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\3\u00c6\5\u00c6\u0906\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u090b\n"+ + "\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0912\n\u00c6\3"+ + "\u00c6\3\u00c6\3\u00c6\5\u00c6\u0917\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3"+ + "\u00c6\3\u00c6\5\u00c6\u091e\n\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0923"+ + "\n\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092a\n\u00c6"+ + "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u092f\n\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0937\n\u00c6\3\u00c6\3\u00c6\3\u00c6"+ + "\5\u00c6\u093c\n\u00c6\3\u00c6\3\u00c6\5\u00c6\u0940\n\u00c6\3\u00c7\3"+ + "\u00c7\5\u00c7\u0944\n\u00c7\3\u00c7\3\u00c7\3\u00c7\5\u00c7\u0949\n\u00c7"+ + "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0950\n\u00c8\3\u00c8"+ + "\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0957\n\u00c8\3\u00c8\3\u00c8"+ + "\3\u00c8\5\u00c8\u095c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8"+ + "\5\u00c8\u0963\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0968\n\u00c8\3"+ + "\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u096f\n\u00c8\3\u00c8\3"+ + "\u00c8\3\u00c8\5\u00c8\u0974\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3"+ + "\u00c8\3\u00c8\5\u00c8\u097c\n\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u0981"+ + "\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0985\n\u00c8\3\u00c9\3\u00c9\3\u00c9"+ + "\7\u00c9\u098a\n\u00c9\f\u00c9\16\u00c9\u098d\13\u00c9\3\u00ca\3\u00ca"+ + "\3\u00ca\5\u00ca\u0992\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+ + "\5\u00ca\u0999\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca"+ + "\u09a0\n\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09a7\n"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09af\n"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09b6\n\u00ca\3"+ + "\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u09be\n\u00ca\3"+ + "\u00cb\3\u00cb\5\u00cb\u09c2\n\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3"+ + "\u00cc\5\u00cc\u09c9\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5"+ + "\u00cc\u09d0\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09d7"+ + "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09df"+ + "\n\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09e6\n\u00cc"+ + "\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u09ee\n\u00cc"+ + "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u09f4\n\u00cd\3\u00cd\3\u00cd"+ + "\3\u00cd\3\u00cd\5\u00cd\u09fa\n\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd"+ + "\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\3\u00cd\5\u00cd\u0a06\n\u00cd"+ + "\3\u00ce\3\u00ce\7\u00ce\u0a0a\n\u00ce\f\u00ce\16\u00ce\u0a0d\13\u00ce"+ + "\3\u00cf\7\u00cf\u0a10\n\u00cf\f\u00cf\16\u00cf\u0a13\13\u00cf\3\u00cf"+ + "\3\u00cf\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d1\3\u00d1\5\u00d1\u0a1d"+ + "\n\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\5\u00d3"+ + "\u0a26\n\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\3\u00d3\5\u00d3\u0a2d\n"+ + "\u00d3\3\u00d4\3\u00d4\3\u00d4\7\u00d4\u0a32\n\u00d4\f\u00d4\16\u00d4"+ + "\u0a35\13\u00d4\3\u00d5\3\u00d5\5\u00d5\u0a39\n\u00d5\3\u00d6\3\u00d6"+ + "\5\u00d6\u0a3d\n\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8"+ + "\3\u00d8\5\u00d8\u0a46\n\u00d8\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da"+ + "\3\u00da\3\u00da\3\u00da\3\u00da\5\u00da\u0a51\n\u00da\3\u00db\3\u00db"+ + "\3\u00db\3\u00db\3\u00db\3\u00db\7\u00db\u0a59\n\u00db\f\u00db\16\u00db"+ + "\u0a5c\13\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\3\u00dc\7\u00dc"+ + "\u0a64\n\u00dc\f\u00dc\16\u00dc\u0a67\13\u00dc\3\u00dd\3\u00dd\3\u00dd"+ + "\3\u00dd\3\u00dd\3\u00dd\7\u00dd\u0a6f\n\u00dd\f\u00dd\16\u00dd\u0a72"+ + "\13\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\3\u00de\7\u00de\u0a7a"+ + "\n\u00de\f\u00de\16\u00de\u0a7d\13\u00de\3\u00df\3\u00df\3\u00df\3\u00df"+ + "\3\u00df\3\u00df\7\u00df\u0a85\n\u00df\f\u00df\16\u00df\u0a88\13\u00df"+ + "\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0\3\u00e0"+ + "\7\u00e0\u0a93\n\u00e0\f\u00e0\16\u00e0\u0a96\13\u00e0\3\u00e1\3\u00e1"+ + "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1"+ + "\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e1\7\u00e1\u0aaa"+ + "\n\u00e1\f\u00e1\16\u00e1\u0aad\13\u00e1\3\u00e2\3\u00e2\3\u00e2\3\u00e2"+ + "\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2\3\u00e2"+ + "\3\u00e2\3\u00e2\3\u00e2\7\u00e2\u0abf\n\u00e2\f\u00e2\16\u00e2\u0ac2"+ + "\13\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e3"+ + "\3\u00e3\7\u00e3\u0acd\n\u00e3\f\u00e3\16\u00e3\u0ad0\13\u00e3\3\u00e4"+ + "\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4\3\u00e4"+ + "\3\u00e4\3\u00e4\7\u00e4\u0ade\n\u00e4\f\u00e4\16\u00e4\u0ae1\13\u00e4"+ + "\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e5\5\u00e5\u0aea"+ + "\n\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8"+ + "\3\u00e8\3\u00e8\3\u00e8\3\u00e8\5\u00e8\u0af8\n\u00e8\3\u00e9\3\u00e9"+ + "\5\u00e9\u0afc\n\u00e9\3\u00e9\3\u00e9\7\u00e9\u0b00\n\u00e9\f\u00e9\16"+ + "\u00e9\u0b03\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00ec"+ + "\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee"+ + "\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b17\n\u00ee\f\u00ee\16\u00ee\u0b1a"+ + "\13\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b22"+ + "\n\u00ee\f\u00ee\16\u00ee\u0b25\13\u00ee\3\u00ee\3\u00ee\3\u00ee\5\u00ee"+ + "\u0b2a\n\u00ee\3\u00ee\2\17\66:@\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0"+ + "\u01c2\u01c4\u01c6\u00ef\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ + "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ + "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c"+ + "\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4"+ + "\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc"+ + "\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4"+ + "\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc"+ + "\u00fe\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114"+ + "\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c"+ + "\u012e\u0130\u0132\u0134\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144"+ + "\u0146\u0148\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c"+ + "\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174"+ + "\u0176\u0178\u017a\u017c\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c"+ + "\u018e\u0190\u0192\u0194\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4"+ + "\u01a6\u01a8\u01aa\u01ac\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc"+ + "\u01be\u01c0\u01c2\u01c4\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4"+ + "\u01d6\u01d8\u01da\2\6\3\2\65:\7\2\7\7\n\n\35\35\37\37\'\'\4\2\20\20\26"+ + "\26\4\2DD]g\u0c1d\2\u01dc\3\2\2\2\4\u01e0\3\2\2\2\6\u01f0\3\2\2\2\b\u01f4"+ + "\3\2\2\2\n\u01f6\3\2\2\2\f\u01f8\3\2\2\2\16\u01fd\3\2\2\2\20\u0201\3\2"+ + "\2\2\22\u0220\3\2\2\2\24\u0222\3\2\2\2\26\u0230\3\2\2\2\30\u0237\3\2\2"+ + "\2\32\u0239\3\2\2\2\34\u023b\3\2\2\2\36\u0240\3\2\2\2 \u024e\3\2\2\2\""+ + "\u0253\3\2\2\2$\u0268\3\2\2\2&\u026f\3\2\2\2(\u027b\3\2\2\2*\u027d\3\2"+ + "\2\2,\u0280\3\2\2\2.\u0284\3\2\2\2\60\u028e\3\2\2\2\62\u0293\3\2\2\2\64"+ + "\u029e\3\2\2\2\66\u02a0\3\2\2\28\u02b0\3\2\2\2:\u02b2\3\2\2\2<\u02c2\3"+ + "\2\2\2>\u02c4\3\2\2\2@\u02c6\3\2\2\2B\u02d2\3\2\2\2D\u02e5\3\2\2\2F\u02f3"+ + "\3\2\2\2H\u02f9\3\2\2\2J\u02fb\3\2\2\2L\u02ff\3\2\2\2N\u0305\3\2\2\2P"+ + "\u030c\3\2\2\2R\u0316\3\2\2\2T\u031a\3\2\2\2V\u031f\3\2\2\2X\u0337\3\2"+ + "\2\2Z\u0339\3\2\2\2\\\u033d\3\2\2\2^\u0345\3\2\2\2`\u0348\3\2\2\2b\u034b"+ + "\3\2\2\2d\u0353\3\2\2\2f\u0360\3\2\2\2h\u0367\3\2\2\2j\u036c\3\2\2\2l"+ + "\u037b\3\2\2\2n\u037d\3\2\2\2p\u0385\3\2\2\2r\u038a\3\2\2\2t\u0390\3\2"+ + "\2\2v\u0394\3\2\2\2x\u0398\3\2\2\2z\u039d\3\2\2\2|\u03a1\3\2\2\2~\u03ba"+ + "\3\2\2\2\u0080\u03bc\3\2\2\2\u0082\u03c7\3\2\2\2\u0084\u03cb\3\2\2\2\u0086"+ + "\u03cd\3\2\2\2\u0088\u03cf\3\2\2\2\u008a\u03d1\3\2\2\2\u008c\u03dc\3\2"+ + "\2\2\u008e\u03e1\3\2\2\2\u0090\u03f1\3\2\2\2\u0092\u0404\3\2\2\2\u0094"+ + "\u0408\3\2\2\2\u0096\u040a\3\2\2\2\u0098\u0418\3\2\2\2\u009a\u042a\3\2"+ + "\2\2\u009c\u042f\3\2\2\2\u009e\u0437\3\2\2\2\u00a0\u044a\3\2\2\2\u00a2"+ + "\u044f\3\2\2\2\u00a4\u0459\3\2\2\2\u00a6\u045c\3\2\2\2\u00a8\u0466\3\2"+ + "\2\2\u00aa\u046a\3\2\2\2\u00ac\u046c\3\2\2\2\u00ae\u046e\3\2\2\2\u00b0"+ + "\u0474\3\2\2\2\u00b2\u0481\3\2\2\2\u00b4\u0484\3\2\2\2\u00b6\u048d\3\2"+ + "\2\2\u00b8\u048f\3\2\2\2\u00ba\u04c6\3\2\2\2\u00bc\u04cb\3\2\2\2\u00be"+ + "\u04d5\3\2\2\2\u00c0\u04e1\3\2\2\2\u00c2\u04ec\3\2\2\2\u00c4\u04fa\3\2"+ + "\2\2\u00c6\u04fc\3\2\2\2\u00c8\u0505\3\2\2\2\u00ca\u050a\3\2\2\2\u00cc"+ + "\u051e\3\2\2\2\u00ce\u0520\3\2\2\2\u00d0\u0523\3\2\2\2\u00d2\u0531\3\2"+ + "\2\2\u00d4\u0536\3\2\2\2\u00d6\u0541\3\2\2\2\u00d8\u0546\3\2\2\2\u00da"+ + "\u0552\3\2\2\2\u00dc\u0557\3\2\2\2\u00de\u055f\3\2\2\2\u00e0\u056d\3\2"+ + "\2\2\u00e2\u0572\3\2\2\2\u00e4\u0584\3\2\2\2\u00e6\u0586\3\2\2\2\u00e8"+ + "\u058c\3\2\2\2\u00ea\u058e\3\2\2\2\u00ec\u0596\3\2\2\2\u00ee\u059e\3\2"+ + "\2\2\u00f0\u05a5\3\2\2\2\u00f2\u05a7\3\2\2\2\u00f4\u05b0\3\2\2\2\u00f6"+ + "\u05b8\3\2\2\2\u00f8\u05bb\3\2\2\2\u00fa\u05c1\3\2\2\2\u00fc\u05ca\3\2"+ + "\2\2\u00fe\u05d2\3\2\2\2\u0100\u05d8\3\2\2\2\u0102\u05e2\3\2\2\2\u0104"+ + "\u05e4\3\2\2\2\u0106\u05ea\3\2\2\2\u0108\u05f6\3\2\2\2\u010a\u05fd\3\2"+ + "\2\2\u010c\u060b\3\2\2\2\u010e\u060d\3\2\2\2\u0110\u060f\3\2\2\2\u0112"+ + "\u0613\3\2\2\2\u0114\u0617\3\2\2\2\u0116\u0621\3\2\2\2\u0118\u0623\3\2"+ + "\2\2\u011a\u0629\3\2\2\2\u011c\u0631\3\2\2\2\u011e\u0643\3\2\2\2\u0120"+ + "\u0645\3\2\2\2\u0122\u064b\3\2\2\2\u0124\u065a\3\2\2\2\u0126\u065d\3\2"+ + "\2\2\u0128\u066e\3\2\2\2\u012a\u0670\3\2\2\2\u012c\u0672\3\2\2\2\u012e"+ + "\u0678\3\2\2\2\u0130\u067e\3\2\2\2\u0132\u0688\3\2\2\2\u0134\u068c\3\2"+ + "\2\2\u0136\u068e\3\2\2\2\u0138\u069e\3\2\2\2\u013a\u06b0\3\2\2\2\u013c"+ + "\u06b2\3\2\2\2\u013e\u06b4\3\2\2\2\u0140\u06bc\3\2\2\2\u0142\u06cb\3\2"+ + "\2\2\u0144\u06da\3\2\2\2\u0146\u06e0\3\2\2\2\u0148\u06e6\3\2\2\2\u014a"+ + "\u06ec\3\2\2\2\u014c\u06f0\3\2\2\2\u014e\u0702\3\2\2\2\u0150\u0704\3\2"+ + "\2\2\u0152\u070b\3\2\2\2\u0154\u0714\3\2\2\2\u0156\u071a\3\2\2\2\u0158"+ + "\u0722\3\2\2\2\u015a\u0725\3\2\2\2\u015c\u072e\3\2\2\2\u015e\u0735\3\2"+ + "\2\2\u0160\u0740\3\2\2\2\u0162\u074a\3\2\2\2\u0164\u076f\3\2\2\2\u0166"+ + "\u0771\3\2\2\2\u0168\u078f\3\2\2\2\u016a\u0796\3\2\2\2\u016c\u0798\3\2"+ + "\2\2\u016e\u079e\3\2\2\2\u0170\u07c8\3\2\2\2\u0172\u07ca\3\2\2\2\u0174"+ + "\u07f3\3\2\2\2\u0176\u0848\3\2\2\2\u0178\u084a\3\2\2\2\u017a\u089c\3\2"+ + "\2\2\u017c\u08a1\3\2\2\2\u017e\u08b0\3\2\2\2\u0180\u08b2\3\2\2\2\u0182"+ + "\u08be\3\2\2\2\u0184\u08ca\3\2\2\2\u0186\u08d6\3\2\2\2\u0188\u08ef\3\2"+ + "\2\2\u018a\u093f\3\2\2\2\u018c\u0941\3\2\2\2\u018e\u0984\3\2\2\2\u0190"+ + "\u0986\3\2\2\2\u0192\u09bd\3\2\2\2\u0194\u09bf\3\2\2\2\u0196\u09ed\3\2"+ + "\2\2\u0198\u0a05\3\2\2\2\u019a\u0a07\3\2\2\2\u019c\u0a11\3\2\2\2\u019e"+ + "\u0a18\3\2\2\2\u01a0\u0a1c\3\2\2\2\u01a2\u0a1e\3\2\2\2\u01a4\u0a2c\3\2"+ + "\2\2\u01a6\u0a2e\3\2\2\2\u01a8\u0a38\3\2\2\2\u01aa\u0a3c\3\2\2\2\u01ac"+ + "\u0a3e\3\2\2\2\u01ae\u0a45\3\2\2\2\u01b0\u0a47\3\2\2\2\u01b2\u0a50\3\2"+ + "\2\2\u01b4\u0a52\3\2\2\2\u01b6\u0a5d\3\2\2\2\u01b8\u0a68\3\2\2\2\u01ba"+ + "\u0a73\3\2\2\2\u01bc\u0a7e\3\2\2\2\u01be\u0a89\3\2\2\2\u01c0\u0a97\3\2"+ + "\2\2\u01c2\u0aae\3\2\2\2\u01c4\u0ac3\3\2\2\2\u01c6\u0ad1\3\2\2\2\u01c8"+ + "\u0ae9\3\2\2\2\u01ca\u0aeb\3\2\2\2\u01cc\u0aee\3\2\2\2\u01ce\u0af7\3\2"+ + "\2\2\u01d0\u0afb\3\2\2\2\u01d2\u0b04\3\2\2\2\u01d4\u0b07\3\2\2\2\u01d6"+ + "\u0b09\3\2\2\2\u01d8\u0b0c\3\2\2\2\u01da\u0b29\3\2\2\2\u01dc\u01dd\t\2"+ + "\2\2\u01dd\3\3\2\2\2\u01de\u01e1\5\6\4\2\u01df\u01e1\5\16\b\2\u01e0\u01de"+ + "\3\2\2\2\u01e0\u01df\3\2\2\2\u01e1\5\3\2\2\2\u01e2\u01e4\5\u00e8u\2\u01e3"+ + "\u01e2\3\2\2\2\u01e4\u01e7\3\2\2\2\u01e5\u01e3\3\2\2\2\u01e5\u01e6\3\2"+ + "\2\2\u01e6\u01e8\3\2\2\2\u01e7\u01e5\3\2\2\2\u01e8\u01f1\5\b\5\2\u01e9"+ + "\u01eb\5\u00e8u\2\u01ea\u01e9\3\2\2\2\u01eb\u01ee\3\2\2\2\u01ec\u01ea"+ + "\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ef\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ef"+ + "\u01f1\7\5\2\2\u01f0\u01e5\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f1\7\3\2\2\2"+ + "\u01f2\u01f5\5\n\6\2\u01f3\u01f5\5\f\7\2\u01f4\u01f2\3\2\2\2\u01f4\u01f3"+ + "\3\2\2\2\u01f5\t\3\2\2\2\u01f6\u01f7\t\3\2\2\u01f7\13\3\2\2\2\u01f8\u01f9"+ + "\t\4\2\2\u01f9\r\3\2\2\2\u01fa\u01fe\5\20\t\2\u01fb\u01fe\5\36\20\2\u01fc"+ + "\u01fe\5 \21\2\u01fd\u01fa\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fc\3\2"+ + "\2\2\u01fe\17\3\2\2\2\u01ff\u0202\5\26\f\2\u0200\u0202\5\34\17\2\u0201"+ + "\u01ff\3\2\2\2\u0201\u0200\3\2\2\2\u0202\u0207\3\2\2\2\u0203\u0206\5\24"+ + "\13\2\u0204\u0206\5\32\16\2\u0205\u0203\3\2\2\2\u0205\u0204\3\2\2\2\u0206"+ + "\u0209\3\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208\21\3\2\2"+ + "\2\u0209\u0207\3\2\2\2\u020a\u020c\5\u00e8u\2\u020b\u020a\3\2\2\2\u020c"+ + "\u020f\3\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2"+ + "\2\2\u020f\u020d\3\2\2\2\u0210\u0212\7h\2\2\u0211\u0213\5,\27\2\u0212"+ + "\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0221\3\2\2\2\u0214\u0215\5\20"+ + "\t\2\u0215\u0219\7C\2\2\u0216\u0218\5\u00e8u\2\u0217\u0216\3\2\2\2\u0218"+ + "\u021b\3\2\2\2\u0219\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021c\3\2"+ + "\2\2\u021b\u0219\3\2\2\2\u021c\u021e\7h\2\2\u021d\u021f\5,\27\2\u021e"+ + "\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0221\3\2\2\2\u0220\u020d\3\2"+ + "\2\2\u0220\u0214\3\2\2\2\u0221\23\3\2\2\2\u0222\u0226\7C\2\2\u0223\u0225"+ + "\5\u00e8u\2\u0224\u0223\3\2\2\2\u0225\u0228\3\2\2\2\u0226\u0224\3\2\2"+ + "\2\u0226\u0227\3\2\2\2\u0227\u0229\3\2\2\2\u0228\u0226\3\2\2\2\u0229\u022b"+ + "\7h\2\2\u022a\u022c\5,\27\2\u022b\u022a\3\2\2\2\u022b\u022c\3\2\2\2\u022c"+ + "\25\3\2\2\2\u022d\u022f\5\u00e8u\2\u022e\u022d\3\2\2\2\u022f\u0232\3\2"+ + "\2\2\u0230\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0233\3\2\2\2\u0232"+ + "\u0230\3\2\2\2\u0233\u0235\7h\2\2\u0234\u0236\5,\27\2\u0235\u0234\3\2"+ + "\2\2\u0235\u0236\3\2\2\2\u0236\27\3\2\2\2\u0237\u0238\5\22\n\2\u0238\31"+ + "\3\2\2\2\u0239\u023a\5\24\13\2\u023a\33\3\2\2\2\u023b\u023c\5\26\f\2\u023c"+ + "\35\3\2\2\2\u023d\u023f\5\u00e8u\2\u023e\u023d\3\2\2\2\u023f\u0242\3\2"+ + "\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2\u0241\u0243\3\2\2\2\u0242"+ + "\u0240\3\2\2\2\u0243\u0244\7h\2\2\u0244\37\3\2\2\2\u0245\u0246\5\6\4\2"+ + "\u0246\u0247\5\"\22\2\u0247\u024f\3\2\2\2\u0248\u0249\5\20\t\2\u0249\u024a"+ + "\5\"\22\2\u024a\u024f\3\2\2\2\u024b\u024c\5\36\20\2\u024c\u024d\5\"\22"+ + "\2\u024d\u024f\3\2\2\2\u024e\u0245\3\2\2\2\u024e\u0248\3\2\2\2\u024e\u024b"+ + "\3\2\2\2\u024f!\3\2\2\2\u0250\u0252\5\u00e8u\2\u0251\u0250\3\2\2\2\u0252"+ + "\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0256\3\2"+ + "\2\2\u0255\u0253\3\2\2\2\u0256\u0257\7?\2\2\u0257\u0262\7@\2\2\u0258\u025a"+ + "\5\u00e8u\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2"+ + "\2\u025b\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f"+ + "\7?\2\2\u025f\u0261\7@\2\2\u0260\u025b\3\2\2\2\u0261\u0264\3\2\2\2\u0262"+ + "\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263#\3\2\2\2\u0264\u0262\3\2\2\2"+ + "\u0265\u0267\5&\24\2\u0266\u0265\3\2\2\2\u0267\u026a\3\2\2\2\u0268\u0266"+ + "\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026b\3\2\2\2\u026a\u0268\3\2\2\2\u026b"+ + "\u026d\7h\2\2\u026c\u026e\5(\25\2\u026d\u026c\3\2\2\2\u026d\u026e\3\2"+ + "\2\2\u026e%\3\2\2\2\u026f\u0270\5\u00e8u\2\u0270\'\3\2\2\2\u0271\u0272"+ + "\7\23\2\2\u0272\u027c\5\36\20\2\u0273\u0274\7\23\2\2\u0274\u0278\5\20"+ + "\t\2\u0275\u0277\5*\26\2\u0276\u0275\3\2\2\2\u0277\u027a\3\2\2\2\u0278"+ + "\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278\3\2"+ + "\2\2\u027b\u0271\3\2\2\2\u027b\u0273\3\2\2\2\u027c)\3\2\2\2\u027d\u027e"+ + "\7W\2\2\u027e\u027f\5\30\r\2\u027f+\3\2\2\2\u0280\u0281\7F\2\2\u0281\u0282"+ + "\5.\30\2\u0282\u0283\7E\2\2\u0283-\3\2\2\2\u0284\u0289\5\60\31\2\u0285"+ + "\u0286\7B\2\2\u0286\u0288\5\60\31\2\u0287\u0285\3\2\2\2\u0288\u028b\3"+ + "\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a/\3\2\2\2\u028b\u0289"+ + "\3\2\2\2\u028c\u028f\5\16\b\2\u028d\u028f\5\62\32\2\u028e\u028c\3\2\2"+ + "\2\u028e\u028d\3\2\2\2\u028f\61\3\2\2\2\u0290\u0292\5\u00e8u\2\u0291\u0290"+ + "\3\2\2\2\u0292\u0295\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294"+ + "\u0296\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u0298\7I\2\2\u0297\u0299\5\64"+ + "\33\2\u0298\u0297\3\2\2\2\u0298\u0299\3\2\2\2\u0299\63\3\2\2\2\u029a\u029b"+ + "\7\23\2\2\u029b\u029f\5\16\b\2\u029c\u029d\7*\2\2\u029d\u029f\5\16\b\2"+ + "\u029e\u029a\3\2\2\2\u029e\u029c\3\2\2\2\u029f\65\3\2\2\2\u02a0\u02a1"+ + "\b\34\1\2\u02a1\u02a2\7h\2\2\u02a2\u02a8\3\2\2\2\u02a3\u02a4\f\3\2\2\u02a4"+ + "\u02a5\7C\2\2\u02a5\u02a7\7h\2\2\u02a6\u02a3\3\2\2\2\u02a7\u02aa\3\2\2"+ + "\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9\67\3\2\2\2\u02aa\u02a8"+ + "\3\2\2\2\u02ab\u02b1\7h\2\2\u02ac\u02ad\5:\36\2\u02ad\u02ae\7C\2\2\u02ae"+ + "\u02af\7h\2\2\u02af\u02b1\3\2\2\2\u02b0\u02ab\3\2\2\2\u02b0\u02ac\3\2"+ + "\2\2\u02b19\3\2\2\2\u02b2\u02b3\b\36\1\2\u02b3\u02b4\7h\2\2\u02b4\u02ba"+ + "\3\2\2\2\u02b5\u02b6\f\3\2\2\u02b6\u02b7\7C\2\2\u02b7\u02b9\7h\2\2\u02b8"+ + "\u02b5\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2\2\2\u02ba\u02bb\3\2"+ + "\2\2\u02bb;\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bd\u02c3\7h\2\2\u02be\u02bf"+ + "\5@!\2\u02bf\u02c0\7C\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c3\3\2\2\2\u02c2"+ + "\u02bd\3\2\2\2\u02c2\u02be\3\2\2\2\u02c3=\3\2\2\2\u02c4\u02c5\7h\2\2\u02c5"+ + "?\3\2\2\2\u02c6\u02c7\b!\1\2\u02c7\u02c8\7h\2\2\u02c8\u02ce\3\2\2\2\u02c9"+ + "\u02ca\f\3\2\2\u02ca\u02cb\7C\2\2\u02cb\u02cd\7h\2\2\u02cc\u02c9\3\2\2"+ + "\2\u02cd\u02d0\3\2\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cfA"+ + "\3\2\2\2\u02d0\u02ce\3\2\2\2\u02d1\u02d3\5D#\2\u02d2\u02d1\3\2\2\2\u02d2"+ + "\u02d3\3\2\2\2\u02d3\u02d7\3\2\2\2\u02d4\u02d6\5H%\2\u02d5\u02d4\3\2\2"+ + "\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02dd"+ + "\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02dc\5R*\2\u02db\u02da\3\2\2\2\u02dc"+ + "\u02df\3\2\2\2\u02dd\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e0\3\2"+ + "\2\2\u02df\u02dd\3\2\2\2\u02e0\u02e1\7\2\2\3\u02e1C\3\2\2\2\u02e2\u02e4"+ + "\5F$\2\u02e3\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5"+ + "\u02e6\3\2\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\7\""+ + "\2\2\u02e9\u02ee\7h\2\2\u02ea\u02eb\7C\2\2\u02eb\u02ed\7h\2\2\u02ec\u02ea"+ + "\3\2\2\2\u02ed\u02f0\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef"+ + "\u02f1\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f1\u02f2\7A\2\2\u02f2E\3\2\2\2\u02f3"+ + "\u02f4\5\u00e8u\2\u02f4G\3\2\2\2\u02f5\u02fa\5J&\2\u02f6\u02fa\5L\'\2"+ + "\u02f7\u02fa\5N(\2\u02f8\u02fa\5P)\2\u02f9\u02f5\3\2\2\2\u02f9\u02f6\3"+ + "\2\2\2\u02f9\u02f7\3\2\2\2\u02f9\u02f8\3\2\2\2\u02faI\3\2\2\2\u02fb\u02fc"+ + "\7\33\2\2\u02fc\u02fd\58\35\2\u02fd\u02fe\7A\2\2\u02feK\3\2\2\2\u02ff"+ + "\u0300\7\33\2\2\u0300\u0301\5:\36\2\u0301\u0302\7C\2\2\u0302\u0303\7U"+ + "\2\2\u0303\u0304\7A\2\2\u0304M\3\2\2\2\u0305\u0306\7\33\2\2\u0306\u0307"+ + "\7(\2\2\u0307\u0308\58\35\2\u0308\u0309\7C\2\2\u0309\u030a\7h\2\2\u030a"+ + "\u030b\7A\2\2\u030bO\3\2\2\2\u030c\u030d\7\33\2\2\u030d\u030e\7(\2\2\u030e"+ + "\u030f\58\35\2\u030f\u0310\7C\2\2\u0310\u0311\7U\2\2\u0311\u0312\7A\2"+ + "\2\u0312Q\3\2\2\2\u0313\u0317\5T+\2\u0314\u0317\5\u00c8e\2\u0315\u0317"+ + "\7A\2\2\u0316\u0313\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0315\3\2\2\2\u0317"+ + "S\3\2\2\2\u0318\u031b\5V,\2\u0319\u031b\5\u00bc_\2\u031a\u0318\3\2\2\2"+ + "\u031a\u0319\3\2\2\2\u031bU\3\2\2\2\u031c\u031e\5X-\2\u031d\u031c\3\2"+ + "\2\2\u031e\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+ + "\u0322\3\2\2\2\u0321\u031f\3\2\2\2\u0322\u0323\7\13\2\2\u0323\u0325\7"+ + "h\2\2\u0324\u0326\5Z.\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326"+ + "\u0328\3\2\2\2\u0327\u0329\5^\60\2\u0328\u0327\3\2\2\2\u0328\u0329\3\2"+ + "\2\2\u0329\u032b\3\2\2\2\u032a\u032c\5`\61\2\u032b\u032a\3\2\2\2\u032b"+ + "\u032c\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032e\5d\63\2\u032eW\3\2\2\2"+ + "\u032f\u0338\5\u00e8u\2\u0330\u0338\7%\2\2\u0331\u0338\7$\2\2\u0332\u0338"+ + "\7#\2\2\u0333\u0338\7\3\2\2\u0334\u0338\7(\2\2\u0335\u0338\7\24\2\2\u0336"+ + "\u0338\7)\2\2\u0337\u032f\3\2\2\2\u0337\u0330\3\2\2\2\u0337\u0331\3\2"+ + "\2\2\u0337\u0332\3\2\2\2\u0337\u0333\3\2\2\2\u0337\u0334\3\2\2\2\u0337"+ + "\u0335\3\2\2\2\u0337\u0336\3\2\2\2\u0338Y\3\2\2\2\u0339\u033a\7F\2\2\u033a"+ + "\u033b\5\\/\2\u033b\u033c\7E\2\2\u033c[\3\2\2\2\u033d\u0342\5$\23\2\u033e"+ + "\u033f\7B\2\2\u033f\u0341\5$\23\2\u0340\u033e\3\2\2\2\u0341\u0344\3\2"+ + "\2\2\u0342\u0340\3\2\2\2\u0342\u0343\3\2\2\2\u0343]\3\2\2\2\u0344\u0342"+ + "\3\2\2\2\u0345\u0346\7\23\2\2\u0346\u0347\5\22\n\2\u0347_\3\2\2\2\u0348"+ + "\u0349\7\32\2\2\u0349\u034a\5b\62\2\u034aa\3\2\2\2\u034b\u0350\5\30\r"+ + "\2\u034c\u034d\7B\2\2\u034d\u034f\5\30\r\2\u034e\u034c\3\2\2\2\u034f\u0352"+ + "\3\2\2\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351c\3\2\2\2\u0352"+ + "\u0350\3\2\2\2\u0353\u0357\7=\2\2\u0354\u0356\5f\64\2\u0355\u0354\3\2"+ + "\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358"+ + "\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\7>\2\2\u035be\3\2\2\2\u035c"+ + "\u0361\5h\65\2\u035d\u0361\5\u00acW\2\u035e\u0361\5\u00aeX\2\u035f\u0361"+ + "\5\u00b0Y\2\u0360\u035c\3\2\2\2\u0360\u035d\3\2\2\2\u0360\u035e\3\2\2"+ + "\2\u0360\u035f\3\2\2\2\u0361g\3\2\2\2\u0362\u0368\5j\66\2\u0363\u0368"+ + "\5\u008eH\2\u0364\u0368\5T+\2\u0365\u0368\5\u00c8e\2\u0366\u0368\7A\2"+ + "\2\u0367\u0362\3\2\2\2\u0367\u0363\3\2\2\2\u0367\u0364\3\2\2\2\u0367\u0365"+ + "\3\2\2\2\u0367\u0366\3\2\2\2\u0368i\3\2\2\2\u0369\u036b\5l\67\2\u036a"+ + "\u0369\3\2\2\2\u036b\u036e\3\2\2\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2"+ + "\2\2\u036d\u036f\3\2\2\2\u036e\u036c\3\2\2\2\u036f\u0370\5v<\2\u0370\u0371"+ + "\5n8\2\u0371\u0372\7A\2\2\u0372k\3\2\2\2\u0373\u037c\5\u00e8u\2\u0374"+ + "\u037c\7%\2\2\u0375\u037c\7$\2\2\u0376\u037c\7#\2\2\u0377\u037c\7(\2\2"+ + "\u0378\u037c\7\24\2\2\u0379\u037c\7\60\2\2\u037a\u037c\7\63\2\2\u037b"+ + "\u0373\3\2\2\2\u037b\u0374\3\2\2\2\u037b\u0375\3\2\2\2\u037b\u0376\3\2"+ + "\2\2\u037b\u0377\3\2\2\2\u037b\u0378\3\2\2\2\u037b\u0379\3\2\2\2\u037b"+ + "\u037a\3\2\2\2\u037cm\3\2\2\2\u037d\u0382\5p9\2\u037e\u037f\7B\2\2\u037f"+ + "\u0381\5p9\2\u0380\u037e\3\2\2\2\u0381\u0384\3\2\2\2\u0382\u0380\3\2\2"+ + "\2\u0382\u0383\3\2\2\2\u0383o\3\2\2\2\u0384\u0382\3\2\2\2\u0385\u0388"+ + "\5r:\2\u0386\u0387\7D\2\2\u0387\u0389\5t;\2\u0388\u0386\3\2\2\2\u0388"+ + "\u0389\3\2\2\2\u0389q\3\2\2\2\u038a\u038c\7h\2\2\u038b\u038d\5\"\22\2"+ + "\u038c\u038b\3\2\2\2\u038c\u038d\3\2\2\2\u038ds\3\2\2\2\u038e\u0391\5"+ + "\u01a0\u00d1\2\u038f\u0391\5\u00fa~\2\u0390\u038e\3\2\2\2\u0390\u038f"+ + "\3\2\2\2\u0391u\3\2\2\2\u0392\u0395\5x=\2\u0393\u0395\5z>\2\u0394\u0392"+ + "\3\2\2\2\u0394\u0393\3\2\2\2\u0395w\3\2\2\2\u0396\u0399\5\b\5\2\u0397"+ + "\u0399\7\5\2\2\u0398\u0396\3\2\2\2\u0398\u0397\3\2\2\2\u0399y\3\2\2\2"+ + "\u039a\u039e\5|?\2\u039b\u039e\5\u008aF\2\u039c\u039e\5\u008cG\2\u039d"+ + "\u039a\3\2\2\2\u039d\u039b\3\2\2\2\u039d\u039c\3\2\2\2\u039e{\3\2\2\2"+ + "\u039f\u03a2\5\u0082B\2\u03a0\u03a2\5\u0088E\2\u03a1\u039f\3\2\2\2\u03a1"+ + "\u03a0\3\2\2\2\u03a2\u03a7\3\2\2\2\u03a3\u03a6\5\u0080A\2\u03a4\u03a6"+ + "\5\u0086D\2\u03a5\u03a3\3\2\2\2\u03a5\u03a4\3\2\2\2\u03a6\u03a9\3\2\2"+ + "\2\u03a7\u03a5\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8}\3\2\2\2\u03a9\u03a7"+ + "\3\2\2\2\u03aa\u03ac\7h\2\2\u03ab\u03ad\5,\27\2\u03ac\u03ab\3\2\2\2\u03ac"+ + "\u03ad\3\2\2\2\u03ad\u03bb\3\2\2\2\u03ae\u03af\5|?\2\u03af\u03b3\7C\2"+ + "\2\u03b0\u03b2\5\u00e8u\2\u03b1\u03b0\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3"+ + "\u03b1\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b6\3\2\2\2\u03b5\u03b3\3\2"+ + "\2\2\u03b6\u03b8\7h\2\2\u03b7\u03b9\5,\27\2\u03b8\u03b7\3\2\2\2\u03b8"+ + "\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03aa\3\2\2\2\u03ba\u03ae\3\2"+ + "\2\2\u03bb\177\3\2\2\2\u03bc\u03c0\7C\2\2\u03bd\u03bf\5\u00e8u\2\u03be"+ + "\u03bd\3\2\2\2\u03bf\u03c2\3\2\2\2\u03c0\u03be\3\2\2\2\u03c0\u03c1\3\2"+ + "\2\2\u03c1\u03c3\3\2\2\2\u03c2\u03c0\3\2\2\2\u03c3\u03c5\7h\2\2\u03c4"+ + "\u03c6\5,\27\2\u03c5\u03c4\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u0081\3\2"+ + "\2\2\u03c7\u03c9\7h\2\2\u03c8\u03ca\5,\27\2\u03c9\u03c8\3\2\2\2\u03c9"+ + "\u03ca\3\2\2\2\u03ca\u0083\3\2\2\2\u03cb\u03cc\5~@\2\u03cc\u0085\3\2\2"+ + "\2\u03cd\u03ce\5\u0080A\2\u03ce\u0087\3\2\2\2\u03cf\u03d0\5\u0082B\2\u03d0"+ + "\u0089\3\2\2\2\u03d1\u03d2\7h\2\2\u03d2\u008b\3\2\2\2\u03d3\u03d4\5x="+ + "\2\u03d4\u03d5\5\"\22\2\u03d5\u03dd\3\2\2\2\u03d6\u03d7\5|?\2\u03d7\u03d8"+ + "\5\"\22\2\u03d8\u03dd\3\2\2\2\u03d9\u03da\5\u008aF\2\u03da\u03db\5\"\22"+ + "\2\u03db\u03dd\3\2\2\2\u03dc\u03d3\3\2\2\2\u03dc\u03d6\3\2\2\2\u03dc\u03d9"+ + "\3\2\2\2\u03dd\u008d\3\2\2\2\u03de\u03e0\5\u0090I\2\u03df\u03de\3\2\2"+ + "\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2\u03e4"+ + "\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5\u0092J\2\u03e5\u03e6\5\u00aa"+ + "V\2\u03e6\u008f\3\2\2\2\u03e7\u03f2\5\u00e8u\2\u03e8\u03f2\7%\2\2\u03e9"+ + "\u03f2\7$\2\2\u03ea\u03f2\7#\2\2\u03eb\u03f2\7\3\2\2\u03ec\u03f2\7(\2"+ + "\2\u03ed\u03f2\7\24\2\2\u03ee\u03f2\7,\2\2\u03ef\u03f2\7 \2\2\u03f0\u03f2"+ + "\7)\2\2\u03f1\u03e7\3\2\2\2\u03f1\u03e8\3\2\2\2\u03f1\u03e9\3\2\2\2\u03f1"+ + "\u03ea\3\2\2\2\u03f1\u03eb\3\2\2\2\u03f1\u03ec\3\2\2\2\u03f1\u03ed\3\2"+ + "\2\2\u03f1\u03ee\3\2\2\2\u03f1\u03ef\3\2\2\2\u03f1\u03f0\3\2\2\2\u03f2"+ + "\u0091\3\2\2\2\u03f3\u03f4\5\u0094K\2\u03f4\u03f6\5\u0096L\2\u03f5\u03f7"+ + "\5\u00a4S\2\u03f6\u03f5\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u0405\3\2\2"+ + "\2\u03f8\u03fc\5Z.\2\u03f9\u03fb\5\u00e8u\2\u03fa\u03f9\3\2\2\2\u03fb"+ + "\u03fe\3\2\2\2\u03fc\u03fa\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03ff\3\2"+ + "\2\2\u03fe\u03fc\3\2\2\2\u03ff\u0400\5\u0094K\2\u0400\u0402\5\u0096L\2"+ + "\u0401\u0403\5\u00a4S\2\u0402\u0401\3\2\2\2\u0402\u0403\3\2\2\2\u0403"+ + "\u0405\3\2\2\2\u0404\u03f3\3\2\2\2\u0404\u03f8\3\2\2\2\u0405\u0093\3\2"+ + "\2\2\u0406\u0409\5v<\2\u0407\u0409\7\62\2\2\u0408\u0406\3\2\2\2\u0408"+ + "\u0407\3\2\2\2\u0409\u0095\3\2\2\2\u040a\u040b\7h\2\2\u040b\u040d\7;\2"+ + "\2\u040c\u040e\5\u0098M\2\u040d\u040c\3\2\2\2\u040d\u040e\3\2\2\2\u040e"+ + "\u040f\3\2\2\2\u040f\u0411\7<\2\2\u0410\u0412\5\"\22\2\u0411\u0410\3\2"+ + "\2\2\u0411\u0412\3\2\2\2\u0412\u0097\3\2\2\2\u0413\u0414\5\u009aN\2\u0414"+ + "\u0415\7B\2\2\u0415\u0416\5\u00a0Q\2\u0416\u0419\3\2\2\2\u0417\u0419\5"+ + "\u00a0Q\2\u0418\u0413\3\2\2\2\u0418\u0417\3\2\2\2\u0419\u0099\3\2\2\2"+ + "\u041a\u041f\5\u009cO\2\u041b\u041c\7B\2\2\u041c\u041e\5\u009cO\2\u041d"+ + "\u041b\3\2\2\2\u041e\u0421\3\2\2\2\u041f\u041d\3\2\2\2\u041f\u0420\3\2"+ + "\2\2\u0420\u042b\3\2\2\2\u0421\u041f\3\2\2\2\u0422\u0427\5\u00a2R\2\u0423"+ + "\u0424\7B\2\2\u0424\u0426\5\u009cO\2\u0425\u0423\3\2\2\2\u0426\u0429\3"+ + "\2\2\2\u0427\u0425\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u042b\3\2\2\2\u0429"+ + "\u0427\3\2\2\2\u042a\u041a\3\2\2\2\u042a\u0422\3\2\2\2\u042b\u009b\3\2"+ + "\2\2\u042c\u042e\5\u009eP\2\u042d\u042c\3\2\2\2\u042e\u0431\3\2\2\2\u042f"+ + "\u042d\3\2\2\2\u042f\u0430\3\2\2\2\u0430\u0432\3\2\2\2\u0431\u042f\3\2"+ + "\2\2\u0432\u0433\5v<\2\u0433\u0434\5r:\2\u0434\u009d\3\2\2\2\u0435\u0438"+ + "\5\u00e8u\2\u0436\u0438\7\24\2\2\u0437\u0435\3\2\2\2\u0437\u0436\3\2\2"+ + "\2\u0438\u009f\3\2\2\2\u0439\u043b\5\u009eP\2\u043a\u0439\3\2\2\2\u043b"+ + "\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043f\3\2"+ + "\2\2\u043e\u043c\3\2\2\2\u043f\u0443\5v<\2\u0440\u0442\5\u00e8u\2\u0441"+ + "\u0440\3\2\2\2\u0442\u0445\3\2\2\2\u0443\u0441\3\2\2\2\u0443\u0444\3\2"+ + "\2\2\u0444\u0446\3\2\2\2\u0445\u0443\3\2\2\2\u0446\u0447\7j\2\2\u0447"+ + "\u0448\5r:\2\u0448\u044b\3\2\2\2\u0449\u044b\5\u009cO\2\u044a\u043c\3"+ + "\2\2\2\u044a\u0449\3\2\2\2\u044b\u00a1\3\2\2\2\u044c\u044e\5\u00e8u\2"+ + "\u044d\u044c\3\2\2\2\u044e\u0451\3\2\2\2\u044f\u044d\3\2\2\2\u044f\u0450"+ + "\3\2\2\2\u0450\u0452\3\2\2\2\u0451\u044f\3\2\2\2\u0452\u0455\5v<\2\u0453"+ + "\u0454\7h\2\2\u0454\u0456\7C\2\2\u0455\u0453\3\2\2\2\u0455\u0456\3\2\2"+ + "\2\u0456\u0457\3\2\2\2\u0457\u0458\7-\2\2\u0458\u00a3\3\2\2\2\u0459\u045a"+ + "\7/\2\2\u045a\u045b\5\u00a6T\2\u045b\u00a5\3\2\2\2\u045c\u0461\5\u00a8"+ + "U\2\u045d\u045e\7B\2\2\u045e\u0460\5\u00a8U\2\u045f\u045d\3\2\2\2\u0460"+ + "\u0463\3\2\2\2\u0461\u045f\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u00a7\3\2"+ + "\2\2\u0463\u0461\3\2\2\2\u0464\u0467\5\22\n\2\u0465\u0467\5\36\20\2\u0466"+ + "\u0464\3\2\2\2\u0466\u0465\3\2\2\2\u0467\u00a9\3\2\2\2\u0468\u046b\5\u00fe"+ + "\u0080\2\u0469\u046b\7A\2\2\u046a\u0468\3\2\2\2\u046a\u0469\3\2\2\2\u046b"+ + "\u00ab\3\2\2\2\u046c\u046d\5\u00fe\u0080\2\u046d\u00ad\3\2\2\2\u046e\u046f"+ + "\7(\2\2\u046f\u0470\5\u00fe\u0080\2\u0470\u00af\3\2\2\2\u0471\u0473\5"+ + "\u00b2Z\2\u0472\u0471\3\2\2\2\u0473\u0476\3\2\2\2\u0474\u0472\3\2\2\2"+ + "\u0474\u0475\3\2\2\2\u0475\u0477\3\2\2\2\u0476\u0474\3\2\2\2\u0477\u0479"+ + "\5\u00b4[\2\u0478\u047a\5\u00a4S\2\u0479\u0478\3\2\2\2\u0479\u047a\3\2"+ + "\2\2\u047a\u047b\3\2\2\2\u047b\u047c\5\u00b8]\2\u047c\u00b1\3\2\2\2\u047d"+ + "\u0482\5\u00e8u\2\u047e\u0482\7%\2\2\u047f\u0482\7$\2\2\u0480\u0482\7"+ + "#\2\2\u0481\u047d\3\2\2\2\u0481\u047e\3\2\2\2\u0481\u047f\3\2\2\2\u0481"+ + "\u0480\3\2\2\2\u0482\u00b3\3\2\2\2\u0483\u0485\5Z.\2\u0484\u0483\3\2\2"+ + "\2\u0484\u0485\3\2\2\2\u0485\u0486\3\2\2\2\u0486\u0487\5\u00b6\\\2\u0487"+ + "\u0489\7;\2\2\u0488\u048a\5\u0098M\2\u0489\u0488\3\2\2\2\u0489\u048a\3"+ + "\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\7<\2\2\u048c\u00b5\3\2\2\2\u048d"+ + "\u048e\7h\2\2\u048e\u00b7\3\2\2\2\u048f\u0491\7=\2\2\u0490\u0492\5\u00ba"+ + "^\2\u0491\u0490\3\2\2\2\u0491\u0492\3\2\2\2\u0492\u0494\3\2\2\2\u0493"+ + "\u0495\5\u0100\u0081\2\u0494\u0493\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0496"+ + "\3\2\2\2\u0496\u0497\7>\2\2\u0497\u00b9\3\2\2\2\u0498\u049a\5,\27\2\u0499"+ + "\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049c\7-"+ + "\2\2\u049c\u049e\7;\2\2\u049d\u049f\5\u0190\u00c9\2\u049e\u049d\3\2\2"+ + "\2\u049e\u049f\3\2\2\2\u049f\u04a0\3\2\2\2\u04a0\u04a1\7<\2\2\u04a1\u04c7"+ + "\7A\2\2\u04a2\u04a4\5,\27\2\u04a3\u04a2\3\2\2\2\u04a3\u04a4\3\2\2\2\u04a4"+ + "\u04a5\3\2\2\2\u04a5\u04a6\7*\2\2\u04a6\u04a8\7;\2\2\u04a7\u04a9\5\u0190"+ + "\u00c9\2\u04a8\u04a7\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa"+ + "\u04ab\7<\2\2\u04ab\u04c7\7A\2\2\u04ac\u04ad\5<\37\2\u04ad\u04af\7C\2"+ + "\2\u04ae\u04b0\5,\27\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1"+ + "\3\2\2\2\u04b1\u04b2\7*\2\2\u04b2\u04b4\7;\2\2\u04b3\u04b5\5\u0190\u00c9"+ + "\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b7"+ + "\7<\2\2\u04b7\u04b8\7A\2\2\u04b8\u04c7\3\2\2\2\u04b9\u04ba\5\u0162\u00b2"+ + "\2\u04ba\u04bc\7C\2\2\u04bb\u04bd\5,\27\2\u04bc\u04bb\3\2\2\2\u04bc\u04bd"+ + "\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04bf\7*\2\2\u04bf\u04c1\7;\2\2\u04c0"+ + "\u04c2\5\u0190\u00c9\2\u04c1\u04c0\3\2\2\2\u04c1\u04c2\3\2\2\2\u04c2\u04c3"+ + "\3\2\2\2\u04c3\u04c4\7<\2\2\u04c4\u04c5\7A\2\2\u04c5\u04c7\3\2\2\2\u04c6"+ + "\u0499\3\2\2\2\u04c6\u04a3\3\2\2\2\u04c6\u04ac\3\2\2\2\u04c6\u04b9\3\2"+ + "\2\2\u04c7\u00bb\3\2\2\2\u04c8\u04ca\5X-\2\u04c9\u04c8\3\2\2\2\u04ca\u04cd"+ + "\3\2\2\2\u04cb\u04c9\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04ce\3\2\2\2\u04cd"+ + "\u04cb\3\2\2\2\u04ce\u04cf\7\22\2\2\u04cf\u04d1\7h\2\2\u04d0\u04d2\5`"+ + "\61\2\u04d1\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3"+ + "\u04d4\5\u00be`\2\u04d4\u00bd\3\2\2\2\u04d5\u04d7\7=\2\2\u04d6\u04d8\5"+ + "\u00c0a\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2"+ + "\u04d9\u04db\7B\2\2\u04da\u04d9\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd"+ + "\3\2\2\2\u04dc\u04de\5\u00c6d\2\u04dd\u04dc\3\2\2\2\u04dd\u04de\3\2\2"+ + "\2\u04de\u04df\3\2\2\2\u04df\u04e0\7>\2\2\u04e0\u00bf\3\2\2\2\u04e1\u04e6"+ + "\5\u00c2b\2\u04e2\u04e3\7B\2\2\u04e3\u04e5\5\u00c2b\2\u04e4\u04e2\3\2"+ + "\2\2\u04e5\u04e8\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7"+ + "\u00c1\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e9\u04eb\5\u00c4c\2\u04ea\u04e9"+ + "\3\2\2\2\u04eb\u04ee\3\2\2\2\u04ec\u04ea\3\2\2\2\u04ec\u04ed\3\2\2\2\u04ed"+ + "\u04ef\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ef\u04f5\7h\2\2\u04f0\u04f2\7;\2"+ + "\2\u04f1\u04f3\5\u0190\u00c9\2\u04f2\u04f1\3\2\2\2\u04f2\u04f3\3\2\2\2"+ + "\u04f3\u04f4\3\2\2\2\u04f4\u04f6\7<\2\2\u04f5\u04f0\3\2\2\2\u04f5\u04f6"+ + "\3\2\2\2\u04f6\u04f8\3\2\2\2\u04f7\u04f9\5d\63\2\u04f8\u04f7\3\2\2\2\u04f8"+ + "\u04f9\3\2\2\2\u04f9\u00c3\3\2\2\2\u04fa\u04fb\5\u00e8u\2\u04fb\u00c5"+ + "\3\2\2\2\u04fc\u0500\7A\2\2\u04fd\u04ff\5f\64\2\u04fe\u04fd\3\2\2\2\u04ff"+ + "\u0502\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u0501\3\2\2\2\u0501\u00c7\3\2"+ + "\2\2\u0502\u0500\3\2\2\2\u0503\u0506\5\u00caf\2\u0504\u0506\5\u00dco\2"+ + "\u0505\u0503\3\2\2\2\u0505\u0504\3\2\2\2\u0506\u00c9\3\2\2\2\u0507\u0509"+ + "\5\u00ccg\2\u0508\u0507\3\2\2\2\u0509\u050c\3\2\2\2\u050a\u0508\3\2\2"+ + "\2\u050a\u050b\3\2\2\2\u050b\u050d\3\2\2\2\u050c\u050a\3\2\2\2\u050d\u050e"+ + "\7\36\2\2\u050e\u0510\7h\2\2\u050f\u0511\5Z.\2\u0510\u050f\3\2\2\2\u0510"+ + "\u0511\3\2\2\2\u0511\u0513\3\2\2\2\u0512\u0514\5\u00ceh\2\u0513\u0512"+ + "\3\2\2\2\u0513\u0514\3\2\2\2\u0514\u0515\3\2\2\2\u0515\u0516\5\u00d0i"+ + "\2\u0516\u00cb\3\2\2\2\u0517\u051f\5\u00e8u\2\u0518\u051f\7%\2\2\u0519"+ + "\u051f\7$\2\2\u051a\u051f\7#\2\2\u051b\u051f\7\3\2\2\u051c\u051f\7(\2"+ + "\2\u051d\u051f\7)\2\2\u051e\u0517\3\2\2\2\u051e\u0518\3\2\2\2\u051e\u0519"+ + "\3\2\2\2\u051e\u051a\3\2\2\2\u051e\u051b\3\2\2\2\u051e\u051c\3\2\2\2\u051e"+ + "\u051d\3\2\2\2\u051f\u00cd\3\2\2\2\u0520\u0521\7\23\2\2\u0521\u0522\5"+ + "b\62\2\u0522\u00cf\3\2\2\2\u0523\u0527\7=\2\2\u0524\u0526\5\u00d2j\2\u0525"+ + "\u0524\3\2\2\2\u0526\u0529\3\2\2\2\u0527\u0525\3\2\2\2\u0527\u0528\3\2"+ + "\2\2\u0528\u052a\3\2\2\2\u0529\u0527\3\2\2\2\u052a\u052b\7>\2\2\u052b"+ + "\u00d1\3\2\2\2\u052c\u0532\5\u00d4k\2\u052d\u0532\5\u00d8m\2\u052e\u0532"+ + "\5T+\2\u052f\u0532\5\u00c8e\2\u0530\u0532\7A\2\2\u0531\u052c\3\2\2\2\u0531"+ + "\u052d\3\2\2\2\u0531\u052e\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0530\3\2"+ + "\2\2\u0532\u00d3\3\2\2\2\u0533\u0535\5\u00d6l\2\u0534\u0533\3\2\2\2\u0535"+ + "\u0538\3\2\2\2\u0536\u0534\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2"+ + "\2\2\u0538\u0536\3\2\2\2\u0539\u053a\5v<\2\u053a\u053b\5n8\2\u053b\u053c"+ + "\7A\2\2\u053c\u00d5\3\2\2\2\u053d\u0542\5\u00e8u\2\u053e\u0542\7%\2\2"+ + "\u053f\u0542\7(\2\2\u0540\u0542\7\24\2\2\u0541\u053d\3\2\2\2\u0541\u053e"+ + "\3\2\2\2\u0541\u053f\3\2\2\2\u0541\u0540\3\2\2\2\u0542\u00d7\3\2\2\2\u0543"+ + "\u0545\5\u00dan\2\u0544\u0543\3\2\2\2\u0545\u0548\3\2\2\2\u0546\u0544"+ + "\3\2\2\2\u0546\u0547\3\2\2\2\u0547\u0549\3\2\2\2\u0548\u0546\3\2\2\2\u0549"+ + "\u054a\5\u0092J\2\u054a\u054b\5\u00aaV\2\u054b\u00d9\3\2\2\2\u054c\u0553"+ + "\5\u00e8u\2\u054d\u0553\7%\2\2\u054e\u0553\7\3\2\2\u054f\u0553\7\16\2"+ + "\2\u0550\u0553\7(\2\2\u0551\u0553\7)\2\2\u0552\u054c\3\2\2\2\u0552\u054d"+ + "\3\2\2\2\u0552\u054e\3\2\2\2\u0552\u054f\3\2\2\2\u0552\u0550\3\2\2\2\u0552"+ + "\u0551\3\2\2\2\u0553\u00db\3\2\2\2\u0554\u0556\5\u00ccg\2\u0555\u0554"+ + "\3\2\2\2\u0556\u0559\3\2\2\2\u0557\u0555\3\2\2\2\u0557\u0558\3\2\2\2\u0558"+ + "\u055a\3\2\2\2\u0559\u0557\3\2\2\2\u055a\u055b\7i\2\2\u055b\u055c\7\36"+ + "\2\2\u055c\u055d\7h\2\2\u055d\u055e\5\u00dep\2\u055e\u00dd\3\2\2\2\u055f"+ + "\u0563\7=\2\2\u0560\u0562\5\u00e0q\2\u0561\u0560\3\2\2\2\u0562\u0565\3"+ + "\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2\2\2\u0565"+ + "\u0563\3\2\2\2\u0566\u0567\7>\2\2\u0567\u00df\3\2\2\2\u0568\u056e\5\u00e2"+ + "r\2\u0569\u056e\5\u00d4k\2\u056a\u056e\5T+\2\u056b\u056e\5\u00c8e\2\u056c"+ + "\u056e\7A\2\2\u056d\u0568\3\2\2\2\u056d\u0569\3\2\2\2\u056d\u056a\3\2"+ + "\2\2\u056d\u056b\3\2\2\2\u056d\u056c\3\2\2\2\u056e\u00e1\3\2\2\2\u056f"+ + "\u0571\5\u00e4s\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2\2\2\u0572\u0570"+ + "\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574\u0572\3\2\2\2\u0575"+ + "\u0576\5v<\2\u0576\u0577\7h\2\2\u0577\u0578\7;\2\2\u0578\u057a\7<\2\2"+ + "\u0579\u057b\5\"\22\2\u057a\u0579\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d"+ + "\3\2\2\2\u057c\u057e\5\u00e6t\2\u057d\u057c\3\2\2\2\u057d\u057e\3\2\2"+ + "\2\u057e\u057f\3\2\2\2\u057f\u0580\7A\2\2\u0580\u00e3\3\2\2\2\u0581\u0585"+ + "\5\u00e8u\2\u0582\u0585\7%\2\2\u0583\u0585\7\3\2\2\u0584\u0581\3\2\2\2"+ + "\u0584\u0582\3\2\2\2\u0584\u0583\3\2\2\2\u0585\u00e5\3\2\2\2\u0586\u0587"+ + "\7\16\2\2\u0587\u0588\5\u00f0y\2\u0588\u00e7\3\2\2\2\u0589\u058d\5\u00ea"+ + "v\2\u058a\u058d\5\u00f6|\2\u058b\u058d\5\u00f8}\2\u058c\u0589\3\2\2\2"+ + "\u058c\u058a\3\2\2\2\u058c\u058b\3\2\2\2\u058d\u00e9\3\2\2\2\u058e\u058f"+ + "\7i\2\2\u058f\u0590\58\35\2\u0590\u0592\7;\2\2\u0591\u0593\5\u00ecw\2"+ + "\u0592\u0591\3\2\2\2\u0592\u0593\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0595"+ + "\7<\2\2\u0595\u00eb\3\2\2\2\u0596\u059b\5\u00eex\2\u0597\u0598\7B\2\2"+ + "\u0598\u059a\5\u00eex\2\u0599\u0597\3\2\2\2\u059a\u059d\3\2\2\2\u059b"+ + "\u0599\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u00ed\3\2\2\2\u059d\u059b\3\2"+ + "\2\2\u059e\u059f\7h\2\2\u059f\u05a0\7D\2\2\u05a0\u05a1\5\u00f0y\2\u05a1"+ + "\u00ef\3\2\2\2\u05a2\u05a6\5\u01b2\u00da\2\u05a3\u05a6\5\u00f2z\2\u05a4"+ + "\u05a6\5\u00e8u\2\u05a5\u05a2\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a4"+ + "\3\2\2\2\u05a6\u00f1\3\2\2\2\u05a7\u05a9\7=\2\2\u05a8\u05aa\5\u00f4{\2"+ + "\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ac\3\2\2\2\u05ab\u05ad"+ + "\7B\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad\u05ae\3\2\2\2\u05ae"+ + "\u05af\7>\2\2\u05af\u00f3\3\2\2\2\u05b0\u05b5\5\u00f0y\2\u05b1\u05b2\7"+ + "B\2\2\u05b2\u05b4\5\u00f0y\2\u05b3\u05b1\3\2\2\2\u05b4\u05b7\3\2\2\2\u05b5"+ + "\u05b3\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u00f5\3\2\2\2\u05b7\u05b5\3\2"+ + "\2\2\u05b8\u05b9\7i\2\2\u05b9\u05ba\58\35\2\u05ba\u00f7\3\2\2\2\u05bb"+ + "\u05bc\7i\2\2\u05bc\u05bd\58\35\2\u05bd\u05be\7;\2\2\u05be\u05bf\5\u00f0"+ + "y\2\u05bf\u05c0\7<\2\2\u05c0\u00f9\3\2\2\2\u05c1\u05c3\7=\2\2\u05c2\u05c4"+ + "\5\u00fc\177\2\u05c3\u05c2\3\2\2\2\u05c3\u05c4\3\2\2\2\u05c4\u05c6\3\2"+ + "\2\2\u05c5\u05c7\7B\2\2\u05c6\u05c5\3\2\2\2\u05c6\u05c7\3\2\2\2\u05c7"+ + "\u05c8\3\2\2\2\u05c8\u05c9\7>\2\2\u05c9\u00fb\3\2\2\2\u05ca\u05cf\5t;"+ + "\2\u05cb\u05cc\7B\2\2\u05cc\u05ce\5t;\2\u05cd\u05cb\3\2\2\2\u05ce\u05d1"+ + "\3\2\2\2\u05cf\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u00fd\3\2\2\2\u05d1"+ + "\u05cf\3\2\2\2\u05d2\u05d4\7=\2\2\u05d3\u05d5\5\u0100\u0081\2\u05d4\u05d3"+ + "\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d6\3\2\2\2\u05d6\u05d7\7>\2\2\u05d7"+ + "\u00ff\3\2\2\2\u05d8\u05dc\5\u0102\u0082\2\u05d9\u05db\5\u0102\u0082\2"+ + "\u05da\u05d9\3\2\2\2\u05db\u05de\3\2\2\2\u05dc\u05da\3\2\2\2\u05dc\u05dd"+ + "\3\2\2\2\u05dd\u0101\3\2\2\2\u05de\u05dc\3\2\2\2\u05df\u05e3\5\u0104\u0083"+ + "\2\u05e0\u05e3\5T+\2\u05e1\u05e3\5\u0108\u0085\2\u05e2\u05df\3\2\2\2\u05e2"+ + "\u05e0\3\2\2\2\u05e2\u05e1\3\2\2\2\u05e3\u0103\3\2\2\2\u05e4\u05e5\5\u0106"+ + "\u0084\2\u05e5\u05e6\7A\2\2\u05e6\u0105\3\2\2\2\u05e7\u05e9\5\u009eP\2"+ + "\u05e8\u05e7\3\2\2\2\u05e9\u05ec\3\2\2\2\u05ea\u05e8\3\2\2\2\u05ea\u05eb"+ + "\3\2\2\2\u05eb\u05ed\3\2\2\2\u05ec\u05ea\3\2\2\2\u05ed\u05ee\5v<\2\u05ee"+ + "\u05ef\5n8\2\u05ef\u0107\3\2\2\2\u05f0\u05f7\5\u010c\u0087\2\u05f1\u05f7"+ + "\5\u0110\u0089\2\u05f2\u05f7\5\u0118\u008d\2\u05f3\u05f7\5\u011a\u008e"+ + "\2\u05f4\u05f7\5\u012c\u0097\2\u05f5\u05f7\5\u0132\u009a\2\u05f6\u05f0"+ + "\3\2\2\2\u05f6\u05f1\3\2\2\2\u05f6\u05f2\3\2\2\2\u05f6\u05f3\3\2\2\2\u05f6"+ + "\u05f4\3\2\2\2\u05f6\u05f5\3\2\2\2\u05f7\u0109\3\2\2\2\u05f8\u05fe\5\u010c"+ + "\u0087\2\u05f9\u05fe\5\u0112\u008a\2\u05fa\u05fe\5\u011c\u008f\2\u05fb"+ + "\u05fe\5\u012e\u0098\2\u05fc\u05fe\5\u0134\u009b\2\u05fd\u05f8\3\2\2\2"+ + "\u05fd\u05f9\3\2\2\2\u05fd\u05fa\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fd\u05fc"+ + "\3\2\2\2\u05fe\u010b\3\2\2\2\u05ff\u060c\5\u00fe\u0080\2\u0600\u060c\5"+ + "\u010e\u0088\2\u0601\u060c\5\u0114\u008b\2\u0602\u060c\5\u011e\u0090\2"+ + "\u0603\u060c\5\u0120\u0091\2\u0604\u060c\5\u0130\u0099\2\u0605\u060c\5"+ + "\u0144\u00a3\2\u0606\u060c\5\u0146\u00a4\2\u0607\u060c\5\u0148\u00a5\2"+ + "\u0608\u060c\5\u014c\u00a7\2\u0609\u060c\5\u014a\u00a6\2\u060a\u060c\5"+ + "\u014e\u00a8\2\u060b\u05ff\3\2\2\2\u060b\u0600\3\2\2\2\u060b\u0601\3\2"+ + "\2\2\u060b\u0602\3\2\2\2\u060b\u0603\3\2\2\2\u060b\u0604\3\2\2\2\u060b"+ + "\u0605\3\2\2\2\u060b\u0606\3\2\2\2\u060b\u0607\3\2\2\2\u060b\u0608\3\2"+ + "\2\2\u060b\u0609\3\2\2\2\u060b\u060a\3\2\2\2\u060c\u010d\3\2\2\2\u060d"+ + "\u060e\7A\2\2\u060e\u010f\3\2\2\2\u060f\u0610\7h\2\2\u0610\u0611\7J\2"+ + "\2\u0611\u0612\5\u0108\u0085\2\u0612\u0111\3\2\2\2\u0613\u0614\7h\2\2"+ + "\u0614\u0615\7J\2\2\u0615\u0616\5\u010a\u0086\2\u0616\u0113\3\2\2\2\u0617"+ + "\u0618\5\u0116\u008c\2\u0618\u0619\7A\2\2\u0619\u0115\3\2\2\2\u061a\u0622"+ + "\5\u01ac\u00d7\2\u061b\u0622\5\u01ca\u00e6\2\u061c\u0622\5\u01cc\u00e7"+ + "\2\u061d\u0622\5\u01d2\u00ea\2\u061e\u0622\5\u01d6\u00ec\2\u061f\u0622"+ + "\5\u018a\u00c6\2\u0620\u0622\5\u0176\u00bc\2\u0621\u061a\3\2\2\2\u0621"+ + "\u061b\3\2\2\2\u0621\u061c\3\2\2\2\u0621\u061d\3\2\2\2\u0621\u061e\3\2"+ + "\2\2\u0621\u061f\3\2\2\2\u0621\u0620\3\2\2\2\u0622\u0117\3\2\2\2\u0623"+ + "\u0624\7\30\2\2\u0624\u0625\7;\2\2\u0625\u0626\5\u01a0\u00d1\2\u0626\u0627"+ + "\7<\2\2\u0627\u0628\5\u0108\u0085\2\u0628\u0119\3\2\2\2\u0629\u062a\7"+ + "\30\2\2\u062a\u062b\7;\2\2\u062b\u062c\5\u01a0\u00d1\2\u062c\u062d\7<"+ + "\2\2\u062d\u062e\5\u010a\u0086\2\u062e\u062f\7\21\2\2\u062f\u0630\5\u0108"+ + "\u0085\2\u0630\u011b\3\2\2\2\u0631\u0632\7\30\2\2\u0632\u0633\7;\2\2\u0633"+ + "\u0634\5\u01a0\u00d1\2\u0634\u0635\7<\2\2\u0635\u0636\5\u010a\u0086\2"+ + "\u0636\u0637\7\21\2\2\u0637\u0638\5\u010a\u0086\2\u0638\u011d\3\2\2\2"+ + "\u0639\u063a\7\4\2\2\u063a\u063b\5\u01a0\u00d1\2\u063b\u063c\7A\2\2\u063c"+ + "\u0644\3\2\2\2\u063d\u063e\7\4\2\2\u063e\u063f\5\u01a0\u00d1\2\u063f\u0640"+ + "\7J\2\2\u0640\u0641\5\u01a0\u00d1\2\u0641\u0642\7A\2\2\u0642\u0644\3\2"+ + "\2\2\u0643\u0639\3\2\2\2\u0643\u063d\3\2\2\2\u0644\u011f\3\2\2\2\u0645"+ + "\u0646\7+\2\2\u0646\u0647\7;\2\2\u0647\u0648\5\u01a0\u00d1\2\u0648\u0649"+ + "\7<\2\2\u0649\u064a\5\u0122\u0092\2\u064a\u0121\3\2\2\2\u064b\u064f\7"+ + "=\2\2\u064c\u064e\5\u0124\u0093\2\u064d\u064c\3\2\2\2\u064e\u0651\3\2"+ + "\2\2\u064f\u064d\3\2\2\2\u064f\u0650\3\2\2\2\u0650\u0655\3\2\2\2\u0651"+ + "\u064f\3\2\2\2\u0652\u0654\5\u0128\u0095\2\u0653\u0652\3\2\2\2\u0654\u0657"+ + "\3\2\2\2\u0655\u0653\3\2\2\2\u0655\u0656\3\2\2\2\u0656\u0658\3\2\2\2\u0657"+ + "\u0655\3\2\2\2\u0658\u0659\7>\2\2\u0659\u0123\3\2\2\2\u065a\u065b\5\u0126"+ + "\u0094\2\u065b\u065c\5\u0100\u0081\2\u065c\u0125\3\2\2\2\u065d\u0661\5"+ + "\u0128\u0095\2\u065e\u0660\5\u0128\u0095\2\u065f\u065e\3\2\2\2\u0660\u0663"+ + "\3\2\2\2\u0661\u065f\3\2\2\2\u0661\u0662\3\2\2\2\u0662\u0127\3\2\2\2\u0663"+ + "\u0661\3\2\2\2\u0664\u0665\7\b\2\2\u0665\u0666\5\u019e\u00d0\2\u0666\u0667"+ + "\7J\2\2\u0667\u066f\3\2\2\2\u0668\u0669\7\b\2\2\u0669\u066a\5\u012a\u0096"+ + "\2\u066a\u066b\7J\2\2\u066b\u066f\3\2\2\2\u066c\u066d\7\16\2\2\u066d\u066f"+ + "\7J\2\2\u066e\u0664\3\2\2\2\u066e\u0668\3\2\2\2\u066e\u066c\3\2\2\2\u066f"+ + "\u0129\3\2\2\2\u0670\u0671\7h\2\2\u0671\u012b\3\2\2\2\u0672\u0673\7\64"+ + "\2\2\u0673\u0674\7;\2\2\u0674\u0675\5\u01a0\u00d1\2\u0675\u0676\7<\2\2"+ + "\u0676\u0677\5\u0108\u0085\2\u0677\u012d\3\2\2\2\u0678\u0679\7\64\2\2"+ + "\u0679\u067a\7;\2\2\u067a\u067b\5\u01a0\u00d1\2\u067b\u067c\7<\2\2\u067c"+ + "\u067d\5\u010a\u0086\2\u067d\u012f\3\2\2\2\u067e\u067f\7\17\2\2\u067f"+ + "\u0680\5\u0108\u0085\2\u0680\u0681\7\64\2\2\u0681\u0682\7;\2\2\u0682\u0683"+ + "\5\u01a0\u00d1\2\u0683\u0684\7<\2\2\u0684\u0685\7A\2\2\u0685\u0131\3\2"+ + "\2\2\u0686\u0689\5\u0136\u009c\2\u0687\u0689\5\u0140\u00a1\2\u0688\u0686"+ + "\3\2\2\2\u0688\u0687\3\2\2\2\u0689\u0133\3\2\2\2\u068a\u068d\5\u0138\u009d"+ + "\2\u068b\u068d\5\u0142\u00a2\2\u068c\u068a\3\2\2\2\u068c\u068b\3\2\2\2"+ + "\u068d\u0135\3\2\2\2\u068e\u068f\7\27\2\2\u068f\u0691\7;\2\2\u0690\u0692"+ + "\5\u013a\u009e\2\u0691\u0690\3\2\2\2\u0691\u0692\3\2\2\2\u0692\u0693\3"+ + "\2\2\2\u0693\u0695\7A\2\2\u0694\u0696\5\u01a0\u00d1\2\u0695\u0694\3\2"+ + "\2\2\u0695\u0696\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0699\7A\2\2\u0698"+ + "\u069a\5\u013c\u009f\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069b"+ + "\3\2\2\2\u069b\u069c\7<\2\2\u069c\u069d\5\u0108\u0085\2\u069d\u0137\3"+ + "\2\2\2\u069e\u069f\7\27\2\2\u069f\u06a1\7;\2\2\u06a0\u06a2\5\u013a\u009e"+ + "\2\u06a1\u06a0\3\2\2\2\u06a1\u06a2\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06a5"+ + "\7A\2\2\u06a4\u06a6\5\u01a0\u00d1\2\u06a5\u06a4\3\2\2\2\u06a5\u06a6\3"+ + "\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u06a9\7A\2\2\u06a8\u06aa\5\u013c\u009f"+ + "\2\u06a9\u06a8\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab\u06ac"+ + "\7<\2\2\u06ac\u06ad\5\u010a\u0086\2\u06ad\u0139\3\2\2\2\u06ae\u06b1\5"+ + "\u013e\u00a0\2\u06af\u06b1\5\u0106\u0084\2\u06b0\u06ae\3\2\2\2\u06b0\u06af"+ + "\3\2\2\2\u06b1\u013b\3\2\2\2\u06b2\u06b3\5\u013e\u00a0\2\u06b3\u013d\3"+ + "\2\2\2\u06b4\u06b9\5\u0116\u008c\2\u06b5\u06b6\7B\2\2\u06b6\u06b8\5\u0116"+ + "\u008c\2\u06b7\u06b5\3\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9"+ + "\u06ba\3\2\2\2\u06ba\u013f\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06bd\7\27"+ + "\2\2\u06bd\u06c1\7;\2\2\u06be\u06c0\5\u009eP\2\u06bf\u06be\3\2\2\2\u06c0"+ + "\u06c3\3\2\2\2\u06c1\u06bf\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06c4\3\2"+ + "\2\2\u06c3\u06c1\3\2\2\2\u06c4\u06c5\5v<\2\u06c5\u06c6\5r:\2\u06c6\u06c7"+ + "\7J\2\2\u06c7\u06c8\5\u01a0\u00d1\2\u06c8\u06c9\7<\2\2\u06c9\u06ca\5\u0108"+ + "\u0085\2\u06ca\u0141\3\2\2\2\u06cb\u06cc\7\27\2\2\u06cc\u06d0\7;\2\2\u06cd"+ + "\u06cf\5\u009eP\2\u06ce\u06cd\3\2\2\2\u06cf\u06d2\3\2\2\2\u06d0\u06ce"+ + "\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1\u06d3\3\2\2\2\u06d2\u06d0\3\2\2\2\u06d3"+ + "\u06d4\5v<\2\u06d4\u06d5\5r:\2\u06d5\u06d6\7J\2\2\u06d6\u06d7\5\u01a0"+ + "\u00d1\2\u06d7\u06d8\7<\2\2\u06d8\u06d9\5\u010a\u0086\2\u06d9\u0143\3"+ + "\2\2\2\u06da\u06dc\7\6\2\2\u06db\u06dd\7h\2\2\u06dc\u06db\3\2\2\2\u06dc"+ + "\u06dd\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06df\7A\2\2\u06df\u0145\3\2"+ + "\2\2\u06e0\u06e2\7\r\2\2\u06e1\u06e3\7h\2\2\u06e2\u06e1\3\2\2\2\u06e2"+ + "\u06e3\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\7A\2\2\u06e5\u0147\3\2"+ + "\2\2\u06e6\u06e8\7&\2\2\u06e7\u06e9\5\u01a0\u00d1\2\u06e8\u06e7\3\2\2"+ + "\2\u06e8\u06e9\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06eb\7A\2\2\u06eb\u0149"+ + "\3\2\2\2\u06ec\u06ed\7.\2\2\u06ed\u06ee\5\u01a0\u00d1\2\u06ee\u06ef\7"+ + "A\2\2\u06ef\u014b\3\2\2\2\u06f0\u06f1\7,\2\2\u06f1\u06f2\7;\2\2\u06f2"+ + "\u06f3\5\u01a0\u00d1\2\u06f3\u06f4\7<\2\2\u06f4\u06f5\5\u00fe\u0080\2"+ + "\u06f5\u014d\3\2\2\2\u06f6\u06f7\7\61\2\2\u06f7\u06f8\5\u00fe\u0080\2"+ + "\u06f8\u06f9\5\u0150\u00a9\2\u06f9\u0703\3\2\2\2\u06fa\u06fb\7\61\2\2"+ + "\u06fb\u06fd\5\u00fe\u0080\2\u06fc\u06fe\5\u0150\u00a9\2\u06fd\u06fc\3"+ + "\2\2\2\u06fd\u06fe\3\2\2\2\u06fe\u06ff\3\2\2\2\u06ff\u0700\5\u0158\u00ad"+ + "\2\u0700\u0703\3\2\2\2\u0701\u0703\5\u015a\u00ae\2\u0702\u06f6\3\2\2\2"+ + "\u0702\u06fa\3\2\2\2\u0702\u0701\3\2\2\2\u0703\u014f\3\2\2\2\u0704\u0708"+ + "\5\u0152\u00aa\2\u0705\u0707\5\u0152\u00aa\2\u0706\u0705\3\2\2\2\u0707"+ + "\u070a\3\2\2\2\u0708\u0706\3\2\2\2\u0708\u0709\3\2\2\2\u0709\u0151\3\2"+ + "\2\2\u070a\u0708\3\2\2\2\u070b\u070c\7\t\2\2\u070c\u070d\7;\2\2\u070d"+ + "\u070e\5\u0154\u00ab\2\u070e\u070f\7<\2\2\u070f\u0710\5\u00fe\u0080\2"+ + "\u0710\u0153\3\2\2\2\u0711\u0713\5\u009eP\2\u0712\u0711\3\2\2\2\u0713"+ + "\u0716\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0717\3\2"+ + "\2\2\u0716\u0714\3\2\2\2\u0717\u0718\5\u0156\u00ac\2\u0718\u0719\5r:\2"+ + "\u0719\u0155\3\2\2\2\u071a\u071f\5~@\2\u071b\u071c\7X\2\2\u071c\u071e"+ + "\5\22\n\2\u071d\u071b\3\2\2\2\u071e\u0721\3\2\2\2\u071f\u071d\3\2\2\2"+ + "\u071f\u0720\3\2\2\2\u0720\u0157\3\2\2\2\u0721\u071f\3\2\2\2\u0722\u0723"+ + "\7\25\2\2\u0723\u0724\5\u00fe\u0080\2\u0724\u0159\3\2\2\2\u0725\u0726"+ + "\7\61\2\2\u0726\u0727\5\u015c\u00af\2\u0727\u0729\5\u00fe\u0080\2\u0728"+ + "\u072a\5\u0150\u00a9\2\u0729\u0728\3\2\2\2\u0729\u072a\3\2\2\2\u072a\u072c"+ + "\3\2\2\2\u072b\u072d\5\u0158\u00ad\2\u072c\u072b\3\2\2\2\u072c\u072d\3"+ + "\2\2\2\u072d\u015b\3\2\2\2\u072e\u072f\7;\2\2\u072f\u0731\5\u015e\u00b0"+ + "\2\u0730\u0732\7A\2\2\u0731\u0730\3\2\2\2\u0731\u0732\3\2\2\2\u0732\u0733"+ + "\3\2\2\2\u0733\u0734\7<\2\2\u0734\u015d\3\2\2\2\u0735\u073a\5\u0160\u00b1"+ + "\2\u0736\u0737\7A\2\2\u0737\u0739\5\u0160\u00b1\2\u0738\u0736\3\2\2\2"+ + "\u0739\u073c\3\2\2\2\u073a\u0738\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u015f"+ + "\3\2\2\2\u073c\u073a\3\2\2\2\u073d\u073f\5\u009eP\2\u073e\u073d\3\2\2"+ + "\2\u073f\u0742\3\2\2\2\u0740\u073e\3\2\2\2\u0740\u0741\3\2\2\2\u0741\u0743"+ + "\3\2\2\2\u0742\u0740\3\2\2\2\u0743\u0744\5v<\2\u0744\u0745\5r:\2\u0745"+ + "\u0746\7D\2\2\u0746\u0747\5\u01a0\u00d1\2\u0747\u0161\3\2\2\2\u0748\u074b"+ + "\5\u0170\u00b9\2\u0749\u074b\5\u0198\u00cd\2\u074a\u0748\3\2\2\2\u074a"+ + "\u0749\3\2\2\2\u074b\u074f\3\2\2\2\u074c\u074e\5\u016a\u00b6\2\u074d\u074c"+ + "\3\2\2\2\u074e\u0751\3\2\2\2\u074f\u074d\3\2\2\2\u074f\u0750\3\2\2\2\u0750"+ + "\u0163\3\2\2\2\u0751\u074f\3\2\2\2\u0752\u0770\5\2\2\2\u0753\u0758\58"+ + "\35\2\u0754\u0755\7?\2\2\u0755\u0757\7@\2\2\u0756\u0754\3\2\2\2\u0757"+ + "\u075a\3\2\2\2\u0758\u0756\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075b\3\2"+ + "\2\2\u075a\u0758\3\2\2\2\u075b\u075c\7C\2\2\u075c\u075d\7\13\2\2\u075d"+ + "\u0770\3\2\2\2\u075e\u075f\7\62\2\2\u075f\u0760\7C\2\2\u0760\u0770\7\13"+ + "\2\2\u0761\u0770\7-\2\2\u0762\u0763\58\35\2\u0763\u0764\7C\2\2\u0764\u0765"+ + "\7-\2\2\u0765\u0770\3\2\2\2\u0766\u0767\7;\2\2\u0767\u0768\5\u01a0\u00d1"+ + "\2\u0768\u0769\7<\2\2\u0769\u0770\3\2\2\2\u076a\u0770\5\u0176\u00bc\2"+ + "\u076b\u0770\5\u017e\u00c0\2\u076c\u0770\5\u0184\u00c3\2\u076d\u0770\5"+ + "\u018a\u00c6\2\u076e\u0770\5\u0192\u00ca\2\u076f\u0752\3\2\2\2\u076f\u0753"+ + "\3\2\2\2\u076f\u075e\3\2\2\2\u076f\u0761\3\2\2\2\u076f\u0762\3\2\2\2\u076f"+ + "\u0766\3\2\2\2\u076f\u076a\3\2\2\2\u076f\u076b\3\2\2\2\u076f\u076c\3\2"+ + "\2\2\u076f\u076d\3\2\2\2\u076f\u076e\3\2\2\2\u0770\u0165\3\2\2\2\u0771"+ + "\u0772\3\2\2\2\u0772\u0167\3\2\2\2\u0773\u0790\5\2\2\2\u0774\u0779\58"+ + "\35\2\u0775\u0776\7?\2\2\u0776\u0778\7@\2\2\u0777\u0775\3\2\2\2\u0778"+ + "\u077b\3\2\2\2\u0779\u0777\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077c\3\2"+ + "\2\2\u077b\u0779\3\2\2\2\u077c\u077d\7C\2\2\u077d\u077e\7\13\2\2\u077e"+ + "\u0790\3\2\2\2\u077f\u0780\7\62\2\2\u0780\u0781\7C\2\2\u0781\u0790\7\13"+ + "\2\2\u0782\u0790\7-\2\2\u0783\u0784\58\35\2\u0784\u0785\7C\2\2\u0785\u0786"+ + "\7-\2\2\u0786\u0790\3\2\2\2\u0787\u0788\7;\2\2\u0788\u0789\5\u01a0\u00d1"+ + "\2\u0789\u078a\7<\2\2\u078a\u0790\3\2\2\2\u078b\u0790\5\u0176\u00bc\2"+ + "\u078c\u0790\5\u017e\u00c0\2\u078d\u0790\5\u018a\u00c6\2\u078e\u0790\5"+ + "\u0192\u00ca\2\u078f\u0773\3\2\2\2\u078f\u0774\3\2\2\2\u078f\u077f\3\2"+ + "\2\2\u078f\u0782\3\2\2\2\u078f\u0783\3\2\2\2\u078f\u0787\3\2\2\2\u078f"+ + "\u078b\3\2\2\2\u078f\u078c\3\2\2\2\u078f\u078d\3\2\2\2\u078f\u078e\3\2"+ + "\2\2\u0790\u0169\3\2\2\2\u0791\u0797\5\u0178\u00bd\2\u0792\u0797\5\u0180"+ + "\u00c1\2\u0793\u0797\5\u0186\u00c4\2\u0794\u0797\5\u018c\u00c7\2\u0795"+ + "\u0797\5\u0194\u00cb\2\u0796\u0791\3\2\2\2\u0796\u0792\3\2\2\2\u0796\u0793"+ + "\3\2\2\2\u0796\u0794\3\2\2\2\u0796\u0795\3\2\2\2\u0797\u016b\3\2\2\2\u0798"+ + "\u0799\3\2\2\2\u0799\u016d\3\2\2\2\u079a\u079f\5\u0178\u00bd\2\u079b\u079f"+ + "\5\u0180\u00c1\2\u079c\u079f\5\u018c\u00c7\2\u079d\u079f\5\u0194\u00cb"+ + "\2\u079e\u079a\3\2\2\2\u079e\u079b\3\2\2\2\u079e\u079c\3\2\2\2\u079e\u079d"+ + "\3\2\2\2\u079f\u016f\3\2\2\2\u07a0\u07c9\5\2\2\2\u07a1\u07a6\58\35\2\u07a2"+ + "\u07a3\7?\2\2\u07a3\u07a5\7@\2\2\u07a4\u07a2\3\2\2\2\u07a5\u07a8\3\2\2"+ + "\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7\u07a9\3\2\2\2\u07a8\u07a6"+ + "\3\2\2\2\u07a9\u07aa\7C\2\2\u07aa\u07ab\7\13\2\2\u07ab\u07c9\3\2\2\2\u07ac"+ + "\u07b1\5x=\2\u07ad\u07ae\7?\2\2\u07ae\u07b0\7@\2\2\u07af\u07ad\3\2\2\2"+ + "\u07b0\u07b3\3\2\2\2\u07b1\u07af\3\2\2\2\u07b1\u07b2\3\2\2\2\u07b2\u07b4"+ + "\3\2\2\2\u07b3\u07b1\3\2\2\2\u07b4\u07b5\7C\2\2\u07b5\u07b6\7\13\2\2\u07b6"+ + "\u07c9\3\2\2\2\u07b7\u07b8\7\62\2\2\u07b8\u07b9\7C\2\2\u07b9\u07c9\7\13"+ + "\2\2\u07ba\u07c9\7-\2\2\u07bb\u07bc\58\35\2\u07bc\u07bd\7C\2\2\u07bd\u07be"+ + "\7-\2\2\u07be\u07c9\3\2\2\2\u07bf\u07c0\7;\2\2\u07c0\u07c1\5\u01a0\u00d1"+ + "\2\u07c1\u07c2\7<\2\2\u07c2\u07c9\3\2\2\2\u07c3\u07c9\5\u017a\u00be\2"+ + "\u07c4\u07c9\5\u0182\u00c2\2\u07c5\u07c9\5\u0188\u00c5\2\u07c6\u07c9\5"+ + "\u018e\u00c8\2\u07c7\u07c9\5\u0196\u00cc\2\u07c8\u07a0\3\2\2\2\u07c8\u07a1"+ + "\3\2\2\2\u07c8\u07ac\3\2\2\2\u07c8\u07b7\3\2\2\2\u07c8\u07ba\3\2\2\2\u07c8"+ + "\u07bb\3\2\2\2\u07c8\u07bf\3\2\2\2\u07c8\u07c3\3\2\2\2\u07c8\u07c4\3\2"+ + "\2\2\u07c8\u07c5\3\2\2\2\u07c8\u07c6\3\2\2\2\u07c8\u07c7\3\2\2\2\u07c9"+ + "\u0171\3\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u0173\3\2\2\2\u07cc\u07f4\5\2"+ + "\2\2\u07cd\u07d2\58\35\2\u07ce\u07cf\7?\2\2\u07cf\u07d1\7@\2\2\u07d0\u07ce"+ + "\3\2\2\2\u07d1\u07d4\3\2\2\2\u07d2\u07d0\3\2\2\2\u07d2\u07d3\3\2\2\2\u07d3"+ + "\u07d5\3\2\2\2\u07d4\u07d2\3\2\2\2\u07d5\u07d6\7C\2\2\u07d6\u07d7\7\13"+ + "\2\2\u07d7\u07f4\3\2\2\2\u07d8\u07dd\5x=\2\u07d9\u07da\7?\2\2\u07da\u07dc"+ + "\7@\2\2\u07db\u07d9\3\2\2\2\u07dc\u07df\3\2\2\2\u07dd\u07db\3\2\2\2\u07dd"+ + "\u07de\3\2\2\2\u07de\u07e0\3\2\2\2\u07df\u07dd\3\2\2\2\u07e0\u07e1\7C"+ + "\2\2\u07e1\u07e2\7\13\2\2\u07e2\u07f4\3\2\2\2\u07e3\u07e4\7\62\2\2\u07e4"+ + "\u07e5\7C\2\2\u07e5\u07f4\7\13\2\2\u07e6\u07f4\7-\2\2\u07e7\u07e8\58\35"+ + "\2\u07e8\u07e9\7C\2\2\u07e9\u07ea\7-\2\2\u07ea\u07f4\3\2\2\2\u07eb\u07ec"+ + "\7;\2\2\u07ec\u07ed\5\u01a0\u00d1\2\u07ed\u07ee\7<\2\2\u07ee\u07f4\3\2"+ + "\2\2\u07ef\u07f4\5\u017a\u00be\2\u07f0\u07f4\5\u0182\u00c2\2\u07f1\u07f4"+ + "\5\u018e\u00c8\2\u07f2\u07f4\5\u0196\u00cc\2\u07f3\u07cc\3\2\2\2\u07f3"+ + "\u07cd\3\2\2\2\u07f3\u07d8\3\2\2\2\u07f3\u07e3\3\2\2\2\u07f3\u07e6\3\2"+ + "\2\2\u07f3\u07e7\3\2\2\2\u07f3\u07eb\3\2\2\2\u07f3\u07ef\3\2\2\2\u07f3"+ + "\u07f0\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f2\3\2\2\2\u07f4\u0175\3\2"+ + "\2\2\u07f5\u07f7\7!\2\2\u07f6\u07f8\5,\27\2\u07f7\u07f6\3\2\2\2\u07f7"+ + "\u07f8\3\2\2\2\u07f8\u07fc\3\2\2\2\u07f9\u07fb\5\u00e8u\2\u07fa\u07f9"+ + "\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd"+ + "\u07ff\3\2\2\2\u07fe\u07fc\3\2\2\2\u07ff\u080a\7h\2\2\u0800\u0804\7C\2"+ + "\2\u0801\u0803\5\u00e8u\2\u0802\u0801\3\2\2\2\u0803\u0806\3\2\2\2\u0804"+ + "\u0802\3\2\2\2\u0804\u0805\3\2\2\2\u0805\u0807\3\2\2\2\u0806\u0804\3\2"+ + "\2\2\u0807\u0809\7h\2\2\u0808\u0800\3\2\2\2\u0809\u080c\3\2\2\2\u080a"+ + "\u0808\3\2\2\2\u080a\u080b\3\2\2\2\u080b\u080e\3\2\2\2\u080c\u080a\3\2"+ + "\2\2\u080d\u080f\5\u017c\u00bf\2\u080e\u080d\3\2\2\2\u080e\u080f\3\2\2"+ + "\2\u080f\u0810\3\2\2\2\u0810\u0812\7;\2\2\u0811\u0813\5\u0190\u00c9\2"+ + "\u0812\u0811\3\2\2\2\u0812\u0813\3\2\2\2\u0813\u0814\3\2\2\2\u0814\u0816"+ + "\7<\2\2\u0815\u0817\5d\63\2\u0816\u0815\3\2\2\2\u0816\u0817\3\2\2\2\u0817"+ + "\u0849\3\2\2\2\u0818\u0819\5<\37\2\u0819\u081a\7C\2\2\u081a\u081c\7!\2"+ + "\2\u081b\u081d\5,\27\2\u081c\u081b\3\2\2\2\u081c\u081d\3\2\2\2\u081d\u0821"+ + "\3\2\2\2\u081e\u0820\5\u00e8u\2\u081f\u081e\3\2\2\2\u0820\u0823\3\2\2"+ + "\2\u0821\u081f\3\2\2\2\u0821\u0822\3\2\2\2\u0822\u0824\3\2\2\2\u0823\u0821"+ + "\3\2\2\2\u0824\u0826\7h\2\2\u0825\u0827\5\u017c\u00bf\2\u0826\u0825\3"+ + "\2\2\2\u0826\u0827\3\2\2\2\u0827\u0828\3\2\2\2\u0828\u082a\7;\2\2\u0829"+ + "\u082b\5\u0190\u00c9\2\u082a\u0829\3\2\2\2\u082a\u082b\3\2\2\2\u082b\u082c"+ + "\3\2\2\2\u082c\u082e\7<\2\2\u082d\u082f\5d\63\2\u082e\u082d\3\2\2\2\u082e"+ + "\u082f\3\2\2\2\u082f\u0849\3\2\2\2\u0830\u0831\5\u0162\u00b2\2\u0831\u0832"+ + "\7C\2\2\u0832\u0834\7!\2\2\u0833\u0835\5,\27\2\u0834\u0833\3\2\2\2\u0834"+ + "\u0835\3\2\2\2\u0835\u0839\3\2\2\2\u0836\u0838\5\u00e8u\2\u0837\u0836"+ + "\3\2\2\2\u0838\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a"+ + "\u083c\3\2\2\2\u083b\u0839\3\2\2\2\u083c\u083e\7h\2\2\u083d\u083f\5\u017c"+ + "\u00bf\2\u083e\u083d\3\2\2\2\u083e\u083f\3\2\2\2\u083f\u0840\3\2\2\2\u0840"+ + "\u0842\7;\2\2\u0841\u0843\5\u0190\u00c9\2\u0842\u0841\3\2\2\2\u0842\u0843"+ + "\3\2\2\2\u0843\u0844\3\2\2\2\u0844\u0846\7<\2\2\u0845\u0847\5d\63\2\u0846"+ + "\u0845\3\2\2\2\u0846\u0847\3\2\2\2\u0847\u0849\3\2\2\2\u0848\u07f5\3\2"+ + "\2\2\u0848\u0818\3\2\2\2\u0848\u0830\3\2\2\2\u0849\u0177\3\2\2\2\u084a"+ + "\u084b\7C\2\2\u084b\u084d\7!\2\2\u084c\u084e\5,\27\2\u084d\u084c\3\2\2"+ + "\2\u084d\u084e\3\2\2\2\u084e\u0852\3\2\2\2\u084f\u0851\5\u00e8u\2\u0850"+ + "\u084f\3\2\2\2\u0851\u0854\3\2\2\2\u0852\u0850\3\2\2\2\u0852\u0853\3\2"+ + "\2\2\u0853\u0855\3\2\2\2\u0854\u0852\3\2\2\2\u0855\u0857\7h\2\2\u0856"+ + "\u0858\5\u017c\u00bf\2\u0857\u0856\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0859"+ + "\3\2\2\2\u0859\u085b\7;\2\2\u085a\u085c\5\u0190\u00c9\2\u085b\u085a\3"+ + "\2\2\2\u085b\u085c\3\2\2\2\u085c\u085d\3\2\2\2\u085d\u085f\7<\2\2\u085e"+ + "\u0860\5d\63\2\u085f\u085e\3\2\2\2\u085f\u0860\3\2\2\2\u0860\u0179\3\2"+ + "\2\2\u0861\u0863\7!\2\2\u0862\u0864\5,\27\2\u0863\u0862\3\2\2\2\u0863"+ + "\u0864\3\2\2\2\u0864\u0868\3\2\2\2\u0865\u0867\5\u00e8u\2\u0866\u0865"+ + "\3\2\2\2\u0867\u086a\3\2\2\2\u0868\u0866\3\2\2\2\u0868\u0869\3\2\2\2\u0869"+ + "\u086b\3\2\2\2\u086a\u0868\3\2\2\2\u086b\u0876\7h\2\2\u086c\u0870\7C\2"+ + "\2\u086d\u086f\5\u00e8u\2\u086e\u086d\3\2\2\2\u086f\u0872\3\2\2\2\u0870"+ + "\u086e\3\2\2\2\u0870\u0871\3\2\2\2\u0871\u0873\3\2\2\2\u0872\u0870\3\2"+ + "\2\2\u0873\u0875\7h\2\2\u0874\u086c\3\2\2\2\u0875\u0878\3\2\2\2\u0876"+ + "\u0874\3\2\2\2\u0876\u0877\3\2\2\2\u0877\u087a\3\2\2\2\u0878\u0876\3\2"+ + "\2\2\u0879\u087b\5\u017c\u00bf\2\u087a\u0879\3\2\2\2\u087a\u087b\3\2\2"+ + "\2\u087b\u087c\3\2\2\2\u087c\u087e\7;\2\2\u087d\u087f\5\u0190\u00c9\2"+ + "\u087e\u087d\3\2\2\2\u087e\u087f\3\2\2\2\u087f\u0880\3\2\2\2\u0880\u0882"+ + "\7<\2\2\u0881\u0883\5d\63\2\u0882\u0881\3\2\2\2\u0882\u0883\3\2\2\2\u0883"+ + "\u089d\3\2\2\2\u0884\u0885\5<\37\2\u0885\u0886\7C\2\2\u0886\u0888\7!\2"+ + "\2\u0887\u0889\5,\27\2\u0888\u0887\3\2\2\2\u0888\u0889\3\2\2\2\u0889\u088d"+ + "\3\2\2\2\u088a\u088c\5\u00e8u\2\u088b\u088a\3\2\2\2\u088c\u088f\3\2\2"+ + "\2\u088d\u088b\3\2\2\2\u088d\u088e\3\2\2\2\u088e\u0890\3\2\2\2\u088f\u088d"+ + "\3\2\2\2\u0890\u0892\7h\2\2\u0891\u0893\5\u017c\u00bf\2\u0892\u0891\3"+ + "\2\2\2\u0892\u0893\3\2\2\2\u0893\u0894\3\2\2\2\u0894\u0896\7;\2\2\u0895"+ + "\u0897\5\u0190\u00c9\2\u0896\u0895\3\2\2\2\u0896\u0897\3\2\2\2\u0897\u0898"+ + "\3\2\2\2\u0898\u089a\7<\2\2\u0899\u089b\5d\63\2\u089a\u0899\3\2\2\2\u089a"+ + "\u089b\3\2\2\2\u089b\u089d\3\2\2\2\u089c\u0861\3\2\2\2\u089c\u0884\3\2"+ + "\2\2\u089d\u017b\3\2\2\2\u089e\u08a2\5,\27\2\u089f\u08a0\7F\2\2\u08a0"+ + "\u08a2\7E\2\2\u08a1\u089e\3\2\2\2\u08a1\u089f\3\2\2\2\u08a2\u017d\3\2"+ + "\2\2\u08a3\u08a4\5\u0162\u00b2\2\u08a4\u08a5\7C\2\2\u08a5\u08a6\7h\2\2"+ + "\u08a6\u08b1\3\2\2\2\u08a7\u08a8\7*\2\2\u08a8\u08a9\7C\2\2\u08a9\u08b1"+ + "\7h\2\2\u08aa\u08ab\58\35\2\u08ab\u08ac\7C\2\2\u08ac\u08ad\7*\2\2\u08ad"+ + "\u08ae\7C\2\2\u08ae\u08af\7h\2\2\u08af\u08b1\3\2\2\2\u08b0\u08a3\3\2\2"+ + "\2\u08b0\u08a7\3\2\2\2\u08b0\u08aa\3\2\2\2\u08b1\u017f\3\2\2\2\u08b2\u08b3"+ + "\7C\2\2\u08b3\u08b4\7h\2\2\u08b4\u0181\3\2\2\2\u08b5\u08b6\7*\2\2\u08b6"+ + "\u08b7\7C\2\2\u08b7\u08bf\7h\2\2\u08b8\u08b9\58\35\2\u08b9\u08ba\7C\2"+ + "\2\u08ba\u08bb\7*\2\2\u08bb\u08bc\7C\2\2\u08bc\u08bd\7h\2\2\u08bd\u08bf"+ + "\3\2\2\2\u08be\u08b5\3\2\2\2\u08be\u08b8\3\2\2\2\u08bf\u0183\3\2\2\2\u08c0"+ + "\u08c1\5<\37\2\u08c1\u08c2\7?\2\2\u08c2\u08c3\5\u01a0\u00d1\2\u08c3\u08c4"+ + "\7@\2\2\u08c4\u08cb\3\2\2\2\u08c5\u08c6\5\u0168\u00b5\2\u08c6\u08c7\7"+ + "?\2\2\u08c7\u08c8\5\u01a0\u00d1\2\u08c8\u08c9\7@\2\2\u08c9\u08cb\3\2\2"+ + "\2\u08ca\u08c0\3\2\2\2\u08ca\u08c5\3\2\2\2\u08cb\u08d3\3\2\2\2\u08cc\u08cd"+ + "\5\u0166\u00b4\2\u08cd\u08ce\7?\2\2\u08ce\u08cf\5\u01a0\u00d1\2\u08cf"+ + "\u08d0\7@\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cc\3\2\2\2\u08d2\u08d5\3\2"+ + "\2\2\u08d3\u08d1\3\2\2\2\u08d3\u08d4\3\2\2\2\u08d4\u0185\3\2\2\2\u08d5"+ + "\u08d3\3\2\2\2\u08d6\u08d7\5\u016e\u00b8\2\u08d7\u08d8\7?\2\2\u08d8\u08d9"+ + "\5\u01a0\u00d1\2\u08d9\u08da\7@\2\2\u08da\u08e2\3\2\2\2\u08db\u08dc\5"+ + "\u016c\u00b7\2\u08dc\u08dd\7?\2\2\u08dd\u08de\5\u01a0\u00d1\2\u08de\u08df"+ + "\7@\2\2\u08df\u08e1\3\2\2\2\u08e0\u08db\3\2\2\2\u08e1\u08e4\3\2\2\2\u08e2"+ + "\u08e0\3\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u0187\3\2\2\2\u08e4\u08e2\3\2"+ + "\2\2\u08e5\u08e6\5<\37\2\u08e6\u08e7\7?\2\2\u08e7\u08e8\5\u01a0\u00d1"+ + "\2\u08e8\u08e9\7@\2\2\u08e9\u08f0\3\2\2\2\u08ea\u08eb\5\u0174\u00bb\2"+ + "\u08eb\u08ec\7?\2\2\u08ec\u08ed\5\u01a0\u00d1\2\u08ed\u08ee\7@\2\2\u08ee"+ + "\u08f0\3\2\2\2\u08ef\u08e5\3\2\2\2\u08ef\u08ea\3\2\2\2\u08f0\u08f8\3\2"+ + "\2\2\u08f1\u08f2\5\u0172\u00ba\2\u08f2\u08f3\7?\2\2\u08f3\u08f4\5\u01a0"+ + "\u00d1\2\u08f4\u08f5\7@\2\2\u08f5\u08f7\3\2\2\2\u08f6\u08f1\3\2\2\2\u08f7"+ + "\u08fa\3\2\2\2\u08f8\u08f6\3\2\2\2\u08f8\u08f9\3\2\2\2\u08f9\u0189\3\2"+ + "\2\2\u08fa\u08f8\3\2\2\2\u08fb\u08fc\5> \2\u08fc\u08fe\7;\2\2\u08fd\u08ff"+ + "\5\u0190\u00c9\2\u08fe\u08fd\3\2\2\2\u08fe\u08ff\3\2\2\2\u08ff\u0900\3"+ + "\2\2\2\u0900\u0901\7<\2\2\u0901\u0940\3\2\2\2\u0902\u0903\58\35\2\u0903"+ + "\u0905\7C\2\2\u0904\u0906\5,\27\2\u0905\u0904\3\2\2\2\u0905\u0906\3\2"+ + "\2\2\u0906\u0907\3\2\2\2\u0907\u0908\7h\2\2\u0908\u090a\7;\2\2\u0909\u090b"+ + "\5\u0190\u00c9\2\u090a\u0909\3\2\2\2\u090a\u090b\3\2\2\2\u090b\u090c\3"+ + "\2\2\2\u090c\u090d\7<\2\2\u090d\u0940\3\2\2\2\u090e\u090f\5<\37\2\u090f"+ + "\u0911\7C\2\2\u0910\u0912\5,\27\2\u0911\u0910\3\2\2\2\u0911\u0912\3\2"+ + "\2\2\u0912\u0913\3\2\2\2\u0913\u0914\7h\2\2\u0914\u0916\7;\2\2\u0915\u0917"+ + "\5\u0190\u00c9\2\u0916\u0915\3\2\2\2\u0916\u0917\3\2\2\2\u0917\u0918\3"+ + "\2\2\2\u0918\u0919\7<\2\2\u0919\u0940\3\2\2\2\u091a\u091b\5\u0162\u00b2"+ + "\2\u091b\u091d\7C\2\2\u091c\u091e\5,\27\2\u091d\u091c\3\2\2\2\u091d\u091e"+ + "\3\2\2\2\u091e\u091f\3\2\2\2\u091f\u0920\7h\2\2\u0920\u0922\7;\2\2\u0921"+ + "\u0923\5\u0190\u00c9\2\u0922\u0921\3\2\2\2\u0922\u0923\3\2\2\2\u0923\u0924"+ + "\3\2\2\2\u0924\u0925\7<\2\2\u0925\u0940\3\2\2\2\u0926\u0927\7*\2\2\u0927"+ + "\u0929\7C\2\2\u0928\u092a\5,\27\2\u0929\u0928\3\2\2\2\u0929\u092a\3\2"+ + "\2\2\u092a\u092b\3\2\2\2\u092b\u092c\7h\2\2\u092c\u092e\7;\2\2\u092d\u092f"+ + "\5\u0190\u00c9\2\u092e\u092d\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0930\3"+ + "\2\2\2\u0930\u0940\7<\2\2\u0931\u0932\58\35\2\u0932\u0933\7C\2\2\u0933"+ + "\u0934\7*\2\2\u0934\u0936\7C\2\2\u0935\u0937\5,\27\2\u0936\u0935\3\2\2"+ + "\2\u0936\u0937\3\2\2\2\u0937\u0938\3\2\2\2\u0938\u0939\7h\2\2\u0939\u093b"+ + "\7;\2\2\u093a\u093c\5\u0190\u00c9\2\u093b\u093a\3\2\2\2\u093b\u093c\3"+ + "\2\2\2\u093c\u093d\3\2\2\2\u093d\u093e\7<\2\2\u093e\u0940\3\2\2\2\u093f"+ + "\u08fb\3\2\2\2\u093f\u0902\3\2\2\2\u093f\u090e\3\2\2\2\u093f\u091a\3\2"+ + "\2\2\u093f\u0926\3\2\2\2\u093f\u0931\3\2\2\2\u0940\u018b\3\2\2\2\u0941"+ + "\u0943\7C\2\2\u0942\u0944\5,\27\2\u0943\u0942\3\2\2\2\u0943\u0944\3\2"+ + "\2\2\u0944\u0945\3\2\2\2\u0945\u0946\7h\2\2\u0946\u0948\7;\2\2\u0947\u0949"+ + "\5\u0190\u00c9\2\u0948\u0947\3\2\2\2\u0948\u0949\3\2\2\2\u0949\u094a\3"+ + "\2\2\2\u094a\u094b\7<\2\2\u094b\u018d\3\2\2\2\u094c\u094d\5> \2\u094d"+ + "\u094f\7;\2\2\u094e\u0950\5\u0190\u00c9\2\u094f\u094e\3\2\2\2\u094f\u0950"+ + "\3\2\2\2\u0950\u0951\3\2\2\2\u0951\u0952\7<\2\2\u0952\u0985\3\2\2\2\u0953"+ + "\u0954\58\35\2\u0954\u0956\7C\2\2\u0955\u0957\5,\27\2\u0956\u0955\3\2"+ + "\2\2\u0956\u0957\3\2\2\2\u0957\u0958\3\2\2\2\u0958\u0959\7h\2\2\u0959"+ + "\u095b\7;\2\2\u095a\u095c\5\u0190\u00c9\2\u095b\u095a\3\2\2\2\u095b\u095c"+ + "\3\2\2\2\u095c\u095d\3\2\2\2\u095d\u095e\7<\2\2\u095e\u0985\3\2\2\2\u095f"+ + "\u0960\5<\37\2\u0960\u0962\7C\2\2\u0961\u0963\5,\27\2\u0962\u0961\3\2"+ + "\2\2\u0962\u0963\3\2\2\2\u0963\u0964\3\2\2\2\u0964\u0965\7h\2\2\u0965"+ + "\u0967\7;\2\2\u0966\u0968\5\u0190\u00c9\2\u0967\u0966\3\2\2\2\u0967\u0968"+ + "\3\2\2\2\u0968\u0969\3\2\2\2\u0969\u096a\7<\2\2\u096a\u0985\3\2\2\2\u096b"+ + "\u096c\7*"; + private static final String _serializedATNSegment1 = + "\2\2\u096c\u096e\7C\2\2\u096d\u096f\5,\27\2\u096e\u096d\3\2\2\2\u096e"+ + "\u096f\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0971\7h\2\2\u0971\u0973\7;\2"+ + "\2\u0972\u0974\5\u0190\u00c9\2\u0973\u0972\3\2\2\2\u0973\u0974\3\2\2\2"+ + "\u0974\u0975\3\2\2\2\u0975\u0985\7<\2\2\u0976\u0977\58\35\2\u0977\u0978"+ + "\7C\2\2\u0978\u0979\7*\2\2\u0979\u097b\7C\2\2\u097a\u097c\5,\27\2\u097b"+ + "\u097a\3\2\2\2\u097b\u097c\3\2\2\2\u097c\u097d\3\2\2\2\u097d\u097e\7h"+ + "\2\2\u097e\u0980\7;\2\2\u097f\u0981\5\u0190\u00c9\2\u0980\u097f\3\2\2"+ + "\2\u0980\u0981\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0983\7<\2\2\u0983\u0985"+ + "\3\2\2\2\u0984\u094c\3\2\2\2\u0984\u0953\3\2\2\2\u0984\u095f\3\2\2\2\u0984"+ + "\u096b\3\2\2\2\u0984\u0976\3\2\2\2\u0985\u018f\3\2\2\2\u0986\u098b\5\u01a0"+ + "\u00d1\2\u0987\u0988\7B\2\2\u0988\u098a\5\u01a0\u00d1\2\u0989\u0987\3"+ + "\2\2\2\u098a\u098d\3\2\2\2\u098b\u0989\3\2\2\2\u098b\u098c\3\2\2\2\u098c"+ + "\u0191\3\2\2\2\u098d\u098b\3\2\2\2\u098e\u098f\5<\37\2\u098f\u0991\7\\"+ + "\2\2\u0990\u0992\5,\27\2\u0991\u0990\3\2\2\2\u0991\u0992\3\2\2\2\u0992"+ + "\u0993\3\2\2\2\u0993\u0994\7h\2\2\u0994\u09be\3\2\2\2\u0995\u0996\5\16"+ + "\b\2\u0996\u0998\7\\\2\2\u0997\u0999\5,\27\2\u0998\u0997\3\2\2\2\u0998"+ + "\u0999\3\2\2\2\u0999\u099a\3\2\2\2\u099a\u099b\7h\2\2\u099b\u09be\3\2"+ + "\2\2\u099c\u099d\5\u0162\u00b2\2\u099d\u099f\7\\\2\2\u099e\u09a0\5,\27"+ + "\2\u099f\u099e\3\2\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a1\3\2\2\2\u09a1\u09a2"+ + "\7h\2\2\u09a2\u09be\3\2\2\2\u09a3\u09a4\7*\2\2\u09a4\u09a6\7\\\2\2\u09a5"+ + "\u09a7\5,\27\2\u09a6\u09a5\3\2\2\2\u09a6\u09a7\3\2\2\2\u09a7\u09a8\3\2"+ + "\2\2\u09a8\u09be\7h\2\2\u09a9\u09aa\58\35\2\u09aa\u09ab\7C\2\2\u09ab\u09ac"+ + "\7*\2\2\u09ac\u09ae\7\\\2\2\u09ad\u09af\5,\27\2\u09ae\u09ad\3\2\2\2\u09ae"+ + "\u09af\3\2\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1\7h\2\2\u09b1\u09be\3\2"+ + "\2\2\u09b2\u09b3\5\22\n\2\u09b3\u09b5\7\\\2\2\u09b4\u09b6\5,\27\2\u09b5"+ + "\u09b4\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\3\2\2\2\u09b7\u09b8\7!"+ + "\2\2\u09b8\u09be\3\2\2\2\u09b9\u09ba\5 \21\2\u09ba\u09bb\7\\\2\2\u09bb"+ + "\u09bc\7!\2\2\u09bc\u09be\3\2\2\2\u09bd\u098e\3\2\2\2\u09bd\u0995\3\2"+ + "\2\2\u09bd\u099c\3\2\2\2\u09bd\u09a3\3\2\2\2\u09bd\u09a9\3\2\2\2\u09bd"+ + "\u09b2\3\2\2\2\u09bd\u09b9\3\2\2\2\u09be\u0193\3\2\2\2\u09bf\u09c1\7\\"+ + "\2\2\u09c0\u09c2\5,\27\2\u09c1\u09c0\3\2\2\2\u09c1\u09c2\3\2\2\2\u09c2"+ + "\u09c3\3\2\2\2\u09c3\u09c4\7h\2\2\u09c4\u0195\3\2\2\2\u09c5\u09c6\5<\37"+ + "\2\u09c6\u09c8\7\\\2\2\u09c7\u09c9\5,\27\2\u09c8\u09c7\3\2\2\2\u09c8\u09c9"+ + "\3\2\2\2\u09c9\u09ca\3\2\2\2\u09ca\u09cb\7h\2\2\u09cb\u09ee\3\2\2\2\u09cc"+ + "\u09cd\5\16\b\2\u09cd\u09cf\7\\\2\2\u09ce\u09d0\5,\27\2\u09cf\u09ce\3"+ + "\2\2\2\u09cf\u09d0\3\2\2\2\u09d0\u09d1\3\2\2\2\u09d1\u09d2\7h\2\2\u09d2"+ + "\u09ee\3\2\2\2\u09d3\u09d4\7*\2\2\u09d4\u09d6\7\\\2\2\u09d5\u09d7\5,\27"+ + "\2\u09d6\u09d5\3\2\2\2\u09d6\u09d7\3\2\2\2\u09d7\u09d8\3\2\2\2\u09d8\u09ee"+ + "\7h\2\2\u09d9\u09da\58\35\2\u09da\u09db\7C\2\2\u09db\u09dc\7*\2\2\u09dc"+ + "\u09de\7\\\2\2\u09dd\u09df\5,\27\2\u09de\u09dd\3\2\2\2\u09de\u09df\3\2"+ + "\2\2\u09df\u09e0\3\2\2\2\u09e0\u09e1\7h\2\2\u09e1\u09ee\3\2\2\2\u09e2"+ + "\u09e3\5\22\n\2\u09e3\u09e5\7\\\2\2\u09e4\u09e6\5,\27\2\u09e5\u09e4\3"+ + "\2\2\2\u09e5\u09e6\3\2\2\2\u09e6\u09e7\3\2\2\2\u09e7\u09e8\7!\2\2\u09e8"+ + "\u09ee\3\2\2\2\u09e9\u09ea\5 \21\2\u09ea\u09eb\7\\\2\2\u09eb\u09ec\7!"+ + "\2\2\u09ec\u09ee\3\2\2\2\u09ed\u09c5\3\2\2\2\u09ed\u09cc\3\2\2\2\u09ed"+ + "\u09d3\3\2\2\2\u09ed\u09d9\3\2\2\2\u09ed\u09e2\3\2\2\2\u09ed\u09e9\3\2"+ + "\2\2\u09ee\u0197\3\2\2\2\u09ef\u09f0\7!\2\2\u09f0\u09f1\5\6\4\2\u09f1"+ + "\u09f3\5\u019a\u00ce\2\u09f2\u09f4\5\"\22\2\u09f3\u09f2\3\2\2\2\u09f3"+ + "\u09f4\3\2\2\2\u09f4\u0a06\3\2\2\2\u09f5\u09f6\7!\2\2\u09f6\u09f7\5\20"+ + "\t\2\u09f7\u09f9\5\u019a\u00ce\2\u09f8\u09fa\5\"\22\2\u09f9\u09f8\3\2"+ + "\2\2\u09f9\u09fa\3\2\2\2\u09fa\u0a06\3\2\2\2\u09fb\u09fc\7!\2\2\u09fc"+ + "\u09fd\5\6\4\2\u09fd\u09fe\5\"\22\2\u09fe\u09ff\5\u00fa~\2\u09ff\u0a06"+ + "\3\2\2\2\u0a00\u0a01\7!\2\2\u0a01\u0a02\5\20\t\2\u0a02\u0a03\5\"\22\2"+ + "\u0a03\u0a04\5\u00fa~\2\u0a04\u0a06\3\2\2\2\u0a05\u09ef\3\2\2\2\u0a05"+ + "\u09f5\3\2\2\2\u0a05\u09fb\3\2\2\2\u0a05\u0a00\3\2\2\2\u0a06\u0199\3\2"+ + "\2\2\u0a07\u0a0b\5\u019c\u00cf\2\u0a08\u0a0a\5\u019c\u00cf\2\u0a09\u0a08"+ + "\3\2\2\2\u0a0a\u0a0d\3\2\2\2\u0a0b\u0a09\3\2\2\2\u0a0b\u0a0c\3\2\2\2\u0a0c"+ + "\u019b\3\2\2\2\u0a0d\u0a0b\3\2\2\2\u0a0e\u0a10\5\u00e8u\2\u0a0f\u0a0e"+ + "\3\2\2\2\u0a10\u0a13\3\2\2\2\u0a11\u0a0f\3\2\2\2\u0a11\u0a12\3\2\2\2\u0a12"+ + "\u0a14\3\2\2\2\u0a13\u0a11\3\2\2\2\u0a14\u0a15\7?\2\2\u0a15\u0a16\5\u01a0"+ + "\u00d1\2\u0a16\u0a17\7@\2\2\u0a17\u019d\3\2\2\2\u0a18\u0a19\5\u01a0\u00d1"+ + "\2\u0a19\u019f\3\2\2\2\u0a1a\u0a1d\5\u01a2\u00d2\2\u0a1b\u0a1d\5\u01aa"+ + "\u00d6\2\u0a1c\u0a1a\3\2\2\2\u0a1c\u0a1b\3\2\2\2\u0a1d\u01a1\3\2\2\2\u0a1e"+ + "\u0a1f\5\u01a4\u00d3\2\u0a1f\u0a20\7[\2\2\u0a20\u0a21\5\u01a8\u00d5\2"+ + "\u0a21\u01a3\3\2\2\2\u0a22\u0a2d\7h\2\2\u0a23\u0a25\7;\2\2\u0a24\u0a26"+ + "\5\u0098M\2\u0a25\u0a24\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26\u0a27\3\2\2"+ + "\2\u0a27\u0a2d\7<\2\2\u0a28\u0a29\7;\2\2\u0a29\u0a2a\5\u01a6\u00d4\2\u0a2a"+ + "\u0a2b\7<\2\2\u0a2b\u0a2d\3\2\2\2\u0a2c\u0a22\3\2\2\2\u0a2c\u0a23\3\2"+ + "\2\2\u0a2c\u0a28\3\2\2\2\u0a2d\u01a5\3\2\2\2\u0a2e\u0a33\7h\2\2\u0a2f"+ + "\u0a30\7B\2\2\u0a30\u0a32\7h\2\2\u0a31\u0a2f\3\2\2\2\u0a32\u0a35\3\2\2"+ + "\2\u0a33\u0a31\3\2\2\2\u0a33\u0a34\3\2\2\2\u0a34\u01a7\3\2\2\2\u0a35\u0a33"+ + "\3\2\2\2\u0a36\u0a39\5\u01a0\u00d1\2\u0a37\u0a39\5\u00fe\u0080\2\u0a38"+ + "\u0a36\3\2\2\2\u0a38\u0a37\3\2\2\2\u0a39\u01a9\3\2\2\2\u0a3a\u0a3d\5\u01b2"+ + "\u00da\2\u0a3b\u0a3d\5\u01ac\u00d7\2\u0a3c\u0a3a\3\2\2\2\u0a3c\u0a3b\3"+ + "\2\2\2\u0a3d\u01ab\3\2\2\2\u0a3e\u0a3f\5\u01ae\u00d8\2\u0a3f\u0a40\5\u01b0"+ + "\u00d9\2\u0a40\u0a41\5\u01a0\u00d1\2\u0a41\u01ad\3\2\2\2\u0a42\u0a46\5"+ + "<\37\2\u0a43\u0a46\5\u017e\u00c0\2\u0a44\u0a46\5\u0184\u00c3\2\u0a45\u0a42"+ + "\3\2\2\2\u0a45\u0a43\3\2\2\2\u0a45\u0a44\3\2\2\2\u0a46\u01af\3\2\2\2\u0a47"+ + "\u0a48\t\5\2\2\u0a48\u01b1\3\2\2\2\u0a49\u0a51\5\u01b4\u00db\2\u0a4a\u0a4b"+ + "\5\u01b4\u00db\2\u0a4b\u0a4c\7I\2\2\u0a4c\u0a4d\5\u01a0\u00d1\2\u0a4d"+ + "\u0a4e\7J\2\2\u0a4e\u0a4f\5\u01b2\u00da\2\u0a4f\u0a51\3\2\2\2\u0a50\u0a49"+ + "\3\2\2\2\u0a50\u0a4a\3\2\2\2\u0a51\u01b3\3\2\2\2\u0a52\u0a53\b\u00db\1"+ + "\2\u0a53\u0a54\5\u01b6\u00dc\2\u0a54\u0a5a\3\2\2\2\u0a55\u0a56\f\3\2\2"+ + "\u0a56\u0a57\7P\2\2\u0a57\u0a59\5\u01b6\u00dc\2\u0a58\u0a55\3\2\2\2\u0a59"+ + "\u0a5c\3\2\2\2\u0a5a\u0a58\3\2\2\2\u0a5a\u0a5b\3\2\2\2\u0a5b\u01b5\3\2"+ + "\2\2\u0a5c\u0a5a\3\2\2\2\u0a5d\u0a5e\b\u00dc\1\2\u0a5e\u0a5f\5\u01b8\u00dd"+ + "\2\u0a5f\u0a65\3\2\2\2\u0a60\u0a61\f\3\2\2\u0a61\u0a62\7O\2\2\u0a62\u0a64"+ + "\5\u01b8\u00dd\2\u0a63\u0a60\3\2\2\2\u0a64\u0a67\3\2\2\2\u0a65\u0a63\3"+ + "\2\2\2\u0a65\u0a66\3\2\2\2\u0a66\u01b7\3\2\2\2\u0a67\u0a65\3\2\2\2\u0a68"+ + "\u0a69\b\u00dd\1\2\u0a69\u0a6a\5\u01ba\u00de\2\u0a6a\u0a70\3\2\2\2\u0a6b"+ + "\u0a6c\f\3\2\2\u0a6c\u0a6d\7X\2\2\u0a6d\u0a6f\5\u01ba\u00de\2\u0a6e\u0a6b"+ + "\3\2\2\2\u0a6f\u0a72\3\2\2\2\u0a70\u0a6e\3\2\2\2\u0a70\u0a71\3\2\2\2\u0a71"+ + "\u01b9\3\2\2\2\u0a72\u0a70\3\2\2\2\u0a73\u0a74\b\u00de\1\2\u0a74\u0a75"+ + "\5\u01bc\u00df\2\u0a75\u0a7b\3\2\2\2\u0a76\u0a77\f\3\2\2\u0a77\u0a78\7"+ + "Y\2\2\u0a78\u0a7a\5\u01bc\u00df\2\u0a79\u0a76\3\2\2\2\u0a7a\u0a7d\3\2"+ + "\2\2\u0a7b\u0a79\3\2\2\2\u0a7b\u0a7c\3\2\2\2\u0a7c\u01bb\3\2\2\2\u0a7d"+ + "\u0a7b\3\2\2\2\u0a7e\u0a7f\b\u00df\1\2\u0a7f\u0a80\5\u01be\u00e0\2\u0a80"+ + "\u0a86\3\2\2\2\u0a81\u0a82\f\3\2\2\u0a82\u0a83\7W\2\2\u0a83\u0a85\5\u01be"+ + "\u00e0\2\u0a84\u0a81\3\2\2\2\u0a85\u0a88\3\2\2\2\u0a86\u0a84\3\2\2\2\u0a86"+ + "\u0a87\3\2\2\2\u0a87\u01bd\3\2\2\2\u0a88\u0a86\3\2\2\2\u0a89\u0a8a\b\u00e0"+ + "\1\2\u0a8a\u0a8b\5\u01c0\u00e1\2\u0a8b\u0a94\3\2\2\2\u0a8c\u0a8d\f\4\2"+ + "\2\u0a8d\u0a8e\7K\2\2\u0a8e\u0a93\5\u01c0\u00e1\2\u0a8f\u0a90\f\3\2\2"+ + "\u0a90\u0a91\7N\2\2\u0a91\u0a93\5\u01c0\u00e1\2\u0a92\u0a8c\3\2\2\2\u0a92"+ + "\u0a8f\3\2\2\2\u0a93\u0a96\3\2\2\2\u0a94\u0a92\3\2\2\2\u0a94\u0a95\3\2"+ + "\2\2\u0a95\u01bf\3\2\2\2\u0a96\u0a94\3\2\2\2\u0a97\u0a98\b\u00e1\1\2\u0a98"+ + "\u0a99\5\u01c2\u00e2\2\u0a99\u0aab\3\2\2\2\u0a9a\u0a9b\f\7\2\2\u0a9b\u0a9c"+ + "\7F\2\2\u0a9c\u0aaa\5\u01c2\u00e2\2\u0a9d\u0a9e\f\6\2\2\u0a9e\u0a9f\7"+ + "E\2\2\u0a9f\u0aaa\5\u01c2\u00e2\2\u0aa0\u0aa1\f\5\2\2\u0aa1\u0aa2\7L\2"+ + "\2\u0aa2\u0aaa\5\u01c2\u00e2\2\u0aa3\u0aa4\f\4\2\2\u0aa4\u0aa5\7M\2\2"+ + "\u0aa5\u0aaa\5\u01c2\u00e2\2\u0aa6\u0aa7\f\3\2\2\u0aa7\u0aa8\7\34\2\2"+ + "\u0aa8\u0aaa\5\16\b\2\u0aa9\u0a9a\3\2\2\2\u0aa9\u0a9d\3\2\2\2\u0aa9\u0aa0"+ + "\3\2\2\2\u0aa9\u0aa3\3\2\2\2\u0aa9\u0aa6\3\2\2\2\u0aaa\u0aad\3\2\2\2\u0aab"+ + "\u0aa9\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u01c1\3\2\2\2\u0aad\u0aab\3\2"+ + "\2\2\u0aae\u0aaf\b\u00e2\1\2\u0aaf\u0ab0\5\u01c4\u00e3\2\u0ab0\u0ac0\3"+ + "\2\2\2\u0ab1\u0ab2\f\5\2\2\u0ab2\u0ab3\7F\2\2\u0ab3\u0ab4\7F\2\2\u0ab4"+ + "\u0abf\5\u01c4\u00e3\2\u0ab5\u0ab6\f\4\2\2\u0ab6\u0ab7\7E\2\2\u0ab7\u0ab8"+ + "\7E\2\2\u0ab8\u0abf\5\u01c4\u00e3\2\u0ab9\u0aba\f\3\2\2\u0aba\u0abb\7"+ + "E\2\2\u0abb\u0abc\7E\2\2\u0abc\u0abd\7E\2\2\u0abd\u0abf\5\u01c4\u00e3"+ + "\2\u0abe\u0ab1\3\2\2\2\u0abe\u0ab5\3\2\2\2\u0abe\u0ab9\3\2\2\2\u0abf\u0ac2"+ + "\3\2\2\2\u0ac0\u0abe\3\2\2\2\u0ac0\u0ac1\3\2\2\2\u0ac1\u01c3\3\2\2\2\u0ac2"+ + "\u0ac0\3\2\2\2\u0ac3\u0ac4\b\u00e3\1\2\u0ac4\u0ac5\5\u01c6\u00e4\2\u0ac5"+ + "\u0ace\3\2\2\2\u0ac6\u0ac7\f\4\2\2\u0ac7\u0ac8\7S\2\2\u0ac8\u0acd\5\u01c6"+ + "\u00e4\2\u0ac9\u0aca\f\3\2\2\u0aca\u0acb\7T\2\2\u0acb\u0acd\5\u01c6\u00e4"+ + "\2\u0acc\u0ac6\3\2\2\2\u0acc\u0ac9\3\2\2\2\u0acd\u0ad0\3\2\2\2\u0ace\u0acc"+ + "\3\2\2\2\u0ace\u0acf\3\2\2\2\u0acf\u01c5\3\2\2\2\u0ad0\u0ace\3\2\2\2\u0ad1"+ + "\u0ad2\b\u00e4\1\2\u0ad2\u0ad3\5\u01c8\u00e5\2\u0ad3\u0adf\3\2\2\2\u0ad4"+ + "\u0ad5\f\5\2\2\u0ad5\u0ad6\7U\2\2\u0ad6\u0ade\5\u01c8\u00e5\2\u0ad7\u0ad8"+ + "\f\4\2\2\u0ad8\u0ad9\7V\2\2\u0ad9\u0ade\5\u01c8\u00e5\2\u0ada\u0adb\f"+ + "\3\2\2\u0adb\u0adc\7Z\2\2\u0adc\u0ade\5\u01c8\u00e5\2\u0add\u0ad4\3\2"+ + "\2\2\u0add\u0ad7\3\2\2\2\u0add\u0ada\3\2\2\2\u0ade\u0ae1\3\2\2\2\u0adf"+ + "\u0add\3\2\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u01c7\3\2\2\2\u0ae1\u0adf\3\2"+ + "\2\2\u0ae2\u0aea\5\u01ca\u00e6\2\u0ae3\u0aea\5\u01cc\u00e7\2\u0ae4\u0ae5"+ + "\7S\2\2\u0ae5\u0aea\5\u01c8\u00e5\2\u0ae6\u0ae7\7T\2\2\u0ae7\u0aea\5\u01c8"+ + "\u00e5\2\u0ae8\u0aea\5\u01ce\u00e8\2\u0ae9\u0ae2\3\2\2\2\u0ae9\u0ae3\3"+ + "\2\2\2\u0ae9\u0ae4\3\2\2\2\u0ae9\u0ae6\3\2\2\2\u0ae9\u0ae8\3\2\2\2\u0aea"+ + "\u01c9\3\2\2\2\u0aeb\u0aec\7Q\2\2\u0aec\u0aed\5\u01c8\u00e5\2\u0aed\u01cb"+ + "\3\2\2\2\u0aee\u0aef\7R\2\2\u0aef\u0af0\5\u01c8\u00e5\2\u0af0\u01cd\3"+ + "\2\2\2\u0af1\u0af8\5\u01d0\u00e9\2\u0af2\u0af3\7H\2\2\u0af3\u0af8\5\u01c8"+ + "\u00e5\2\u0af4\u0af5\7G\2\2\u0af5\u0af8\5\u01c8\u00e5\2\u0af6\u0af8\5"+ + "\u01da\u00ee\2\u0af7\u0af1\3\2\2\2\u0af7\u0af2\3\2\2\2\u0af7\u0af4\3\2"+ + "\2\2\u0af7\u0af6\3\2\2\2\u0af8\u01cf\3\2\2\2\u0af9\u0afc\5\u0162\u00b2"+ + "\2\u0afa\u0afc\5<\37\2\u0afb\u0af9\3\2\2\2\u0afb\u0afa\3\2\2\2\u0afc\u0b01"+ + "\3\2\2\2\u0afd\u0b00\5\u01d4\u00eb\2\u0afe\u0b00\5\u01d8\u00ed\2\u0aff"+ + "\u0afd\3\2\2\2\u0aff\u0afe\3\2\2\2\u0b00\u0b03\3\2\2\2\u0b01\u0aff\3\2"+ + "\2\2\u0b01\u0b02\3\2\2\2\u0b02\u01d1\3\2\2\2\u0b03\u0b01\3\2\2\2\u0b04"+ + "\u0b05\5\u01d0\u00e9\2\u0b05\u0b06\7Q\2\2\u0b06\u01d3\3\2\2\2\u0b07\u0b08"+ + "\7Q\2\2\u0b08\u01d5\3\2\2\2\u0b09\u0b0a\5\u01d0\u00e9\2\u0b0a\u0b0b\7"+ + "R\2\2\u0b0b\u01d7\3\2\2\2\u0b0c\u0b0d\7R\2\2\u0b0d\u01d9\3\2\2\2\u0b0e"+ + "\u0b0f\7;\2\2\u0b0f\u0b10\5\6\4\2\u0b10\u0b11\7<\2\2\u0b11\u0b12\5\u01c8"+ + "\u00e5\2\u0b12\u0b2a\3\2\2\2\u0b13\u0b14\7;\2\2\u0b14\u0b18\5\16\b\2\u0b15"+ + "\u0b17\5*\26\2\u0b16\u0b15\3\2\2\2\u0b17\u0b1a\3\2\2\2\u0b18\u0b16\3\2"+ + "\2\2\u0b18\u0b19\3\2\2\2\u0b19\u0b1b\3\2\2\2\u0b1a\u0b18\3\2\2\2\u0b1b"+ + "\u0b1c\7<\2\2\u0b1c\u0b1d\5\u01ce\u00e8\2\u0b1d\u0b2a\3\2\2\2\u0b1e\u0b1f"+ + "\7;\2\2\u0b1f\u0b23\5\16\b\2\u0b20\u0b22\5*\26\2\u0b21\u0b20\3\2\2\2\u0b22"+ + "\u0b25\3\2\2\2\u0b23\u0b21\3\2\2\2\u0b23\u0b24\3\2\2\2\u0b24\u0b26\3\2"+ + "\2\2\u0b25\u0b23\3\2\2\2\u0b26\u0b27\7<\2\2\u0b27\u0b28\5\u01a2\u00d2"+ + "\2\u0b28\u0b2a\3\2\2\2\u0b29\u0b0e\3\2\2\2\u0b29\u0b13\3\2\2\2\u0b29\u0b1e"+ + "\3\2\2\2\u0b2a\u01db\3\2\2\2\u0146\u01e0\u01e5\u01ec\u01f0\u01f4\u01fd"+ + "\u0201\u0205\u0207\u020d\u0212\u0219\u021e\u0220\u0226\u022b\u0230\u0235"+ + "\u0240\u024e\u0253\u025b\u0262\u0268\u026d\u0278\u027b\u0289\u028e\u0293"+ + "\u0298\u029e\u02a8\u02b0\u02ba\u02c2\u02ce\u02d2\u02d7\u02dd\u02e5\u02ee"+ + "\u02f9\u0316\u031a\u031f\u0325\u0328\u032b\u0337\u0342\u0350\u0357\u0360"+ + "\u0367\u036c\u037b\u0382\u0388\u038c\u0390\u0394\u0398\u039d\u03a1\u03a5"+ + "\u03a7\u03ac\u03b3\u03b8\u03ba\u03c0\u03c5\u03c9\u03dc\u03e1\u03f1\u03f6"+ + "\u03fc\u0402\u0404\u0408\u040d\u0411\u0418\u041f\u0427\u042a\u042f\u0437"+ + "\u043c\u0443\u044a\u044f\u0455\u0461\u0466\u046a\u0474\u0479\u0481\u0484"+ + "\u0489\u0491\u0494\u0499\u049e\u04a3\u04a8\u04af\u04b4\u04bc\u04c1\u04c6"+ + "\u04cb\u04d1\u04d7\u04da\u04dd\u04e6\u04ec\u04f2\u04f5\u04f8\u0500\u0505"+ + "\u050a\u0510\u0513\u051e\u0527\u0531\u0536\u0541\u0546\u0552\u0557\u0563"+ + "\u056d\u0572\u057a\u057d\u0584\u058c\u0592\u059b\u05a5\u05a9\u05ac\u05b5"+ + "\u05c3\u05c6\u05cf\u05d4\u05dc\u05e2\u05ea\u05f6\u05fd\u060b\u0621\u0643"+ + "\u064f\u0655\u0661\u066e\u0688\u068c\u0691\u0695\u0699\u06a1\u06a5\u06a9"+ + "\u06b0\u06b9\u06c1\u06d0\u06dc\u06e2\u06e8\u06fd\u0702\u0708\u0714\u071f"+ + "\u0729\u072c\u0731\u073a\u0740\u074a\u074f\u0758\u076f\u0779\u078f\u0796"+ + "\u079e\u07a6\u07b1\u07c8\u07d2\u07dd\u07f3\u07f7\u07fc\u0804\u080a\u080e"+ + "\u0812\u0816\u081c\u0821\u0826\u082a\u082e\u0834\u0839\u083e\u0842\u0846"+ + "\u0848\u084d\u0852\u0857\u085b\u085f\u0863\u0868\u0870\u0876\u087a\u087e"+ + "\u0882\u0888\u088d\u0892\u0896\u089a\u089c\u08a1\u08b0\u08be\u08ca\u08d3"+ + "\u08e2\u08ef\u08f8\u08fe\u0905\u090a\u0911\u0916\u091d\u0922\u0929\u092e"+ + "\u0936\u093b\u093f\u0943\u0948\u094f\u0956\u095b\u0962\u0967\u096e\u0973"+ + "\u097b\u0980\u0984\u098b\u0991\u0998\u099f\u09a6\u09ae\u09b5\u09bd\u09c1"+ + "\u09c8\u09cf\u09d6\u09de\u09e5\u09ed\u09f3\u09f9\u0a05\u0a0b\u0a11\u0a1c"+ + "\u0a25\u0a2c\u0a33\u0a38\u0a3c\u0a45\u0a50\u0a5a\u0a65\u0a70\u0a7b\u0a86"+ + "\u0a92\u0a94\u0aa9\u0aab\u0abe\u0ac0\u0acc\u0ace\u0add\u0adf\u0ae9\u0af7"+ + "\u0afb\u0aff\u0b01\u0b18\u0b23\u0b29"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Visitor.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Visitor.java new file mode 100644 index 0000000..1a03da0 --- /dev/null +++ b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java8Visitor.java @@ -0,0 +1,1460 @@ +// Generated from i18n-maven-plugin/src/main/antlr4/Java8.g4 by ANTLR 4.5.2 +package org.nuiton.i18n.plugin.parser.java; + +/* + * #%L + * I18n :: Maven Plugin + * $Id$ + * $HeadURL$ + * %% + * Copyright (C) 2016 CodeLutin + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * <http://www.gnu.org/licenses/lgpl-3.0.html>. + * #L% + */ + +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link Java8Parser}. + * + * @param <T> The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface Java8Visitor<T> extends ParseTreeVisitor<T> { + /** + * Visit a parse tree produced by {@link Java8Parser#literal}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(Java8Parser.LiteralContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#type}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitType(Java8Parser.TypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimitiveType(Java8Parser.PrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#numericType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNumericType(Java8Parser.NumericTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#integralType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIntegralType(Java8Parser.IntegralTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#floatingPointType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFloatingPointType(Java8Parser.FloatingPointTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#referenceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReferenceType(Java8Parser.ReferenceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceType(Java8Parser.ClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType(Java8Parser.ClassTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType_lf_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType_lf_classOrInterfaceType(Java8Parser.ClassType_lf_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classType_lfno_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType_lfno_classOrInterfaceType(Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType(Java8Parser.InterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType_lf_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType_lf_classOrInterfaceType(Java8Parser.InterfaceType_lf_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceType_lfno_classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceType_lfno_classOrInterfaceType(Java8Parser.InterfaceType_lfno_classOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeVariable}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeVariable(Java8Parser.TypeVariableContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayType(Java8Parser.ArrayTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dims}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDims(Java8Parser.DimsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(Java8Parser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameterModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterModifier(Java8Parser.TypeParameterModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeBound(Java8Parser.TypeBoundContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#additionalBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditionalBound(Java8Parser.AdditionalBoundContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(Java8Parser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentList(Java8Parser.TypeArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgument(Java8Parser.TypeArgumentContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#wildcard}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWildcard(Java8Parser.WildcardContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#wildcardBounds}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWildcardBounds(Java8Parser.WildcardBoundsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageName(Java8Parser.PackageNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeName(Java8Parser.TypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageOrTypeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageOrTypeName(Java8Parser.PackageOrTypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expressionName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionName(Java8Parser.ExpressionNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodName(Java8Parser.MethodNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ambiguousName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAmbiguousName(Java8Parser.AmbiguousNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#compilationUnit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompilationUnit(Java8Parser.CompilationUnitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageDeclaration(Java8Parser.PackageDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageModifier(Java8Parser.PackageModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#importDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportDeclaration(Java8Parser.ImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleTypeImportDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleTypeImportDeclaration(Java8Parser.SingleTypeImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeImportOnDemandDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeImportOnDemandDeclaration(Java8Parser.TypeImportOnDemandDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleStaticImportDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleStaticImportDeclaration(Java8Parser.SingleStaticImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#staticImportOnDemandDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStaticImportOnDemandDeclaration(Java8Parser.StaticImportOnDemandDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeDeclaration(Java8Parser.TypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(Java8Parser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalClassDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalClassDeclaration(Java8Parser.NormalClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassModifier(Java8Parser.ClassModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(Java8Parser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterList(Java8Parser.TypeParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#superclass}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperclass(Java8Parser.SuperclassContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#superinterfaces}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperinterfaces(Java8Parser.SuperinterfacesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceTypeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceTypeList(Java8Parser.InterfaceTypeListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBody(Java8Parser.ClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBodyDeclaration(Java8Parser.ClassBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassMemberDeclaration(Java8Parser.ClassMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldDeclaration(Java8Parser.FieldDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldModifier(Java8Parser.FieldModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorList(Java8Parser.VariableDeclaratorListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarator(Java8Parser.VariableDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorId}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorId(Java8Parser.VariableDeclaratorIdContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializer(Java8Parser.VariableInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannType(Java8Parser.UnannTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannPrimitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannPrimitiveType(Java8Parser.UnannPrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannReferenceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannReferenceType(Java8Parser.UnannReferenceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassOrInterfaceType(Java8Parser.UnannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType(Java8Parser.UnannClassTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType_lf_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType_lf_unannClassOrInterfaceType(Java8Parser.UnannClassType_lf_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannClassType_lfno_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannClassType_lfno_unannClassOrInterfaceType(Java8Parser.UnannClassType_lfno_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType(Java8Parser.UnannInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lf_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType_lf_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lf_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannInterfaceType_lfno_unannClassOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannInterfaceType_lfno_unannClassOrInterfaceType(Java8Parser.UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannTypeVariable}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannTypeVariable(Java8Parser.UnannTypeVariableContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unannArrayType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnannArrayType(Java8Parser.UnannArrayTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclaration(Java8Parser.MethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodModifier(Java8Parser.MethodModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodHeader}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodHeader(Java8Parser.MethodHeaderContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#result}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResult(Java8Parser.ResultContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclarator(Java8Parser.MethodDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterList(Java8Parser.FormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameters(Java8Parser.FormalParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameter(Java8Parser.FormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableModifier(Java8Parser.VariableModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lastFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLastFormalParameter(Java8Parser.LastFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#receiverParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReceiverParameter(Java8Parser.ReceiverParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#throws_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrows_(Java8Parser.Throws_Context ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exceptionTypeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionTypeList(Java8Parser.ExceptionTypeListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exceptionType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionType(Java8Parser.ExceptionTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodBody(Java8Parser.MethodBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#instanceInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInstanceInitializer(Java8Parser.InstanceInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#staticInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStaticInitializer(Java8Parser.StaticInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclaration(Java8Parser.ConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorModifier(Java8Parser.ConstructorModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclarator(Java8Parser.ConstructorDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#simpleTypeName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTypeName(Java8Parser.SimpleTypeNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorBody(Java8Parser.ConstructorBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#explicitConstructorInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitConstructorInvocation(Java8Parser.ExplicitConstructorInvocationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumDeclaration(Java8Parser.EnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBody(Java8Parser.EnumBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantList(Java8Parser.EnumConstantListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstant}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstant(Java8Parser.EnumConstantContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantModifier(Java8Parser.EnumConstantModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumBodyDeclarations}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBodyDeclarations(Java8Parser.EnumBodyDeclarationsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceDeclaration(Java8Parser.InterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalInterfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalInterfaceDeclaration(Java8Parser.NormalInterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceModifier(Java8Parser.InterfaceModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#extendsInterfaces}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExtendsInterfaces(Java8Parser.ExtendsInterfacesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBody(Java8Parser.InterfaceBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMemberDeclaration(Java8Parser.InterfaceMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantDeclaration(Java8Parser.ConstantDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantModifier(Java8Parser.ConstantModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodDeclaration(Java8Parser.InterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMethodModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodModifier(Java8Parser.InterfaceMethodModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeDeclaration(Java8Parser.AnnotationTypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeBody(Java8Parser.AnnotationTypeBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeMemberDeclaration(Java8Parser.AnnotationTypeMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementDeclaration(Java8Parser.AnnotationTypeElementDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementModifier(Java8Parser.AnnotationTypeElementModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#defaultValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDefaultValue(Java8Parser.DefaultValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotation(Java8Parser.AnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#normalAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNormalAnnotation(Java8Parser.NormalAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePairList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePairList(Java8Parser.ElementValuePairListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePair}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePair(Java8Parser.ElementValuePairContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValue(Java8Parser.ElementValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValueArrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueArrayInitializer(Java8Parser.ElementValueArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValueList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueList(Java8Parser.ElementValueListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#markerAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMarkerAnnotation(Java8Parser.MarkerAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#singleElementAnnotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleElementAnnotation(Java8Parser.SingleElementAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayInitializer(Java8Parser.ArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableInitializerList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializerList(Java8Parser.VariableInitializerListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#block}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(Java8Parser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#blockStatements}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatements(Java8Parser.BlockStatementsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#blockStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatement(Java8Parser.BlockStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclarationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclarationStatement(Java8Parser.LocalVariableDeclarationStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclaration(Java8Parser.LocalVariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(Java8Parser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementNoShortIf(Java8Parser.StatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementWithoutTrailingSubstatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementWithoutTrailingSubstatement(Java8Parser.StatementWithoutTrailingSubstatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#emptyStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEmptyStatement(Java8Parser.EmptyStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#labeledStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabeledStatement(Java8Parser.LabeledStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#labeledStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabeledStatementNoShortIf(Java8Parser.LabeledStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expressionStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionStatement(Java8Parser.ExpressionStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementExpression(Java8Parser.StatementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenStatement(Java8Parser.IfThenStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenElseStatement(Java8Parser.IfThenElseStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#ifThenElseStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfThenElseStatementNoShortIf(Java8Parser.IfThenElseStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assertStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssertStatement(Java8Parser.AssertStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchStatement(Java8Parser.SwitchStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlock(Java8Parser.SwitchBlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchBlockStatementGroup}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlockStatementGroup(Java8Parser.SwitchBlockStatementGroupContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchLabels}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabels(Java8Parser.SwitchLabelsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchLabel}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabel(Java8Parser.SwitchLabelContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantName(Java8Parser.EnumConstantNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#whileStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatement(Java8Parser.WhileStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#whileStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatementNoShortIf(Java8Parser.WhileStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#doStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDoStatement(Java8Parser.DoStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatement(Java8Parser.ForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatementNoShortIf(Java8Parser.ForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#basicForStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBasicForStatement(Java8Parser.BasicForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#basicForStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBasicForStatementNoShortIf(Java8Parser.BasicForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forInit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInit(Java8Parser.ForInitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forUpdate}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForUpdate(Java8Parser.ForUpdateContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementExpressionList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementExpressionList(Java8Parser.StatementExpressionListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enhancedForStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForStatement(Java8Parser.EnhancedForStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enhancedForStatementNoShortIf}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForStatementNoShortIf(Java8Parser.EnhancedForStatementNoShortIfContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#breakStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBreakStatement(Java8Parser.BreakStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#continueStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitContinueStatement(Java8Parser.ContinueStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#returnStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitReturnStatement(Java8Parser.ReturnStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#throwStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrowStatement(Java8Parser.ThrowStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#synchronizedStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSynchronizedStatement(Java8Parser.SynchronizedStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#tryStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryStatement(Java8Parser.TryStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catches}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatches(Java8Parser.CatchesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchClause(Java8Parser.CatchClauseContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchFormalParameter(Java8Parser.CatchFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchType(Java8Parser.CatchTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#finally_}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinally_(Java8Parser.Finally_Context ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#tryWithResourcesStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryWithResourcesStatement(Java8Parser.TryWithResourcesStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resourceSpecification}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceSpecification(Java8Parser.ResourceSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resourceList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceList(Java8Parser.ResourceListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resource}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResource(Java8Parser.ResourceContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimary(Java8Parser.PrimaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray(Java8Parser.PrimaryNoNewArrayContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_arrayAccess(Java8Parser.PrimaryNoNewArray_lf_arrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_arrayAccess(Java8Parser.PrimaryNoNewArray_lfno_arrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(Java8Parser.PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(Java8Parser.PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression(Java8Parser.ClassInstanceCreationExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression_lf_primary(Java8Parser.ClassInstanceCreationExpression_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classInstanceCreationExpression_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassInstanceCreationExpression_lfno_primary(Java8Parser.ClassInstanceCreationExpression_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentsOrDiamond(Java8Parser.TypeArgumentsOrDiamondContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess(Java8Parser.FieldAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess_lf_primary(Java8Parser.FieldAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldAccess_lfno_primary(Java8Parser.FieldAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess(Java8Parser.ArrayAccessContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess_lf_primary(Java8Parser.ArrayAccess_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayAccess_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayAccess_lfno_primary(Java8Parser.ArrayAccess_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation(Java8Parser.MethodInvocationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation_lf_primary(Java8Parser.MethodInvocation_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodInvocation_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodInvocation_lfno_primary(Java8Parser.MethodInvocation_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#argumentList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArgumentList(Java8Parser.ArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference(Java8Parser.MethodReferenceContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference_lf_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference_lf_primary(Java8Parser.MethodReference_lf_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodReference_lfno_primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodReference_lfno_primary(Java8Parser.MethodReference_lfno_primaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayCreationExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayCreationExpression(Java8Parser.ArrayCreationExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dimExprs}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDimExprs(Java8Parser.DimExprsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#dimExpr}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDimExpr(Java8Parser.DimExprContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantExpression(Java8Parser.ConstantExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(Java8Parser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaExpression(Java8Parser.LambdaExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaParameters(Java8Parser.LambdaParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#inferredFormalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInferredFormalParameterList(Java8Parser.InferredFormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lambdaBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaBody(Java8Parser.LambdaBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignmentExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentExpression(Java8Parser.AssignmentExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignment}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignment(Java8Parser.AssignmentContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#leftHandSide}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLeftHandSide(Java8Parser.LeftHandSideContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#assignmentOperator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentOperator(Java8Parser.AssignmentOperatorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalExpression(Java8Parser.ConditionalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalOrExpression(Java8Parser.ConditionalOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#conditionalAndExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalAndExpression(Java8Parser.ConditionalAndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#inclusiveOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInclusiveOrExpression(Java8Parser.InclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#exclusiveOrExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExclusiveOrExpression(Java8Parser.ExclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#andExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAndExpression(Java8Parser.AndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#equalityExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEqualityExpression(Java8Parser.EqualityExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#relationalExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitRelationalExpression(Java8Parser.RelationalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#shiftExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitShiftExpression(Java8Parser.ShiftExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#additiveExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveExpression(Java8Parser.AdditiveExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#multiplicativeExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeExpression(Java8Parser.MultiplicativeExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unaryExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryExpression(Java8Parser.UnaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#preIncrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreIncrementExpression(Java8Parser.PreIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#preDecrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPreDecrementExpression(Java8Parser.PreDecrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#unaryExpressionNotPlusMinus}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryExpressionNotPlusMinus(Java8Parser.UnaryExpressionNotPlusMinusContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixExpression(Java8Parser.PostfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostIncrementExpression(Java8Parser.PostIncrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postIncrementExpression_lf_postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostIncrementExpression_lf_postfixExpression(Java8Parser.PostIncrementExpression_lf_postfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostDecrementExpression(Java8Parser.PostDecrementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#postDecrementExpression_lf_postfixExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostDecrementExpression_lf_postfixExpression(Java8Parser.PostDecrementExpression_lf_postfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#castExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCastExpression(Java8Parser.CastExpressionContext ctx); +} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java deleted file mode 100644 index a5d4536..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java +++ /dev/null @@ -1,1376 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ - -import org.antlr.v4.runtime.ParserRuleContext; -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.ErrorNode; -import org.antlr.v4.runtime.tree.TerminalNode; - -/** - * This class provides an empty implementation of {@link JavaListener}, - * which can be extended to create a listener which only needs to handle a subset - * of the available methods. - */ -public class JavaBaseListener implements JavaListener { - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterExpressionList(@NotNull JavaParser.ExpressionListContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitExpressionList(@NotNull JavaParser.ExpressionListContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterForUpdate(@NotNull JavaParser.ForUpdateContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitForUpdate(@NotNull JavaParser.ForUpdateContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotation(@NotNull JavaParser.AnnotationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotation(@NotNull JavaParser.AnnotationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnumConstant(@NotNull JavaParser.EnumConstantContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnumConstant(@NotNull JavaParser.EnumConstantContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterCatchClause(@NotNull JavaParser.CatchClauseContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitCatchClause(@NotNull JavaParser.CatchClauseContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeParameter(@NotNull JavaParser.TypeParameterContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeParameter(@NotNull JavaParser.TypeParameterContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeBound(@NotNull JavaParser.TypeBoundContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeBound(@NotNull JavaParser.TypeBoundContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterBlock(@NotNull JavaParser.BlockContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitBlock(@NotNull JavaParser.BlockContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterParExpression(@NotNull JavaParser.ParExpressionContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitParExpression(@NotNull JavaParser.ParExpressionContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeParameters(@NotNull JavaParser.TypeParametersContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeParameters(@NotNull JavaParser.TypeParametersContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterArguments(@NotNull JavaParser.ArgumentsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitArguments(@NotNull JavaParser.ArgumentsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterFormalParameters(@NotNull JavaParser.FormalParametersContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitFormalParameters(@NotNull JavaParser.FormalParametersContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterForInit(@NotNull JavaParser.ForInitContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitForInit(@NotNull JavaParser.ForInitContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterExpression(@NotNull JavaParser.ExpressionContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitExpression(@NotNull JavaParser.ExpressionContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterResources(@NotNull JavaParser.ResourcesContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitResources(@NotNull JavaParser.ResourcesContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterFormalParameter(@NotNull JavaParser.FormalParameterContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitFormalParameter(@NotNull JavaParser.FormalParameterContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterType(@NotNull JavaParser.TypeContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitType(@NotNull JavaParser.TypeContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterPrimary(@NotNull JavaParser.PrimaryContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitPrimary(@NotNull JavaParser.PrimaryContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassBody(@NotNull JavaParser.ClassBodyContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassBody(@NotNull JavaParser.ClassBodyContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterDefaultValue(@NotNull JavaParser.DefaultValueContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitDefaultValue(@NotNull JavaParser.DefaultValueContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterVariableModifier(@NotNull JavaParser.VariableModifierContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitVariableModifier(@NotNull JavaParser.VariableModifierContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterCreatedName(@NotNull JavaParser.CreatedNameContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitCreatedName(@NotNull JavaParser.CreatedNameContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterCatchType(@NotNull JavaParser.CatchTypeContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitCatchType(@NotNull JavaParser.CatchTypeContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterModifier(@NotNull JavaParser.ModifierContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitModifier(@NotNull JavaParser.ModifierContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterStatement(@NotNull JavaParser.StatementContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitStatement(@NotNull JavaParser.StatementContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterForControl(@NotNull JavaParser.ForControlContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitForControl(@NotNull JavaParser.ForControlContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeList(@NotNull JavaParser.TypeListContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeList(@NotNull JavaParser.TypeListContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterElementValue(@NotNull JavaParser.ElementValueContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitElementValue(@NotNull JavaParser.ElementValueContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterBlockStatement(@NotNull JavaParser.BlockStatementContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitBlockStatement(@NotNull JavaParser.BlockStatementContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterCreator(@NotNull JavaParser.CreatorContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitCreator(@NotNull JavaParser.CreatorContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterResource(@NotNull JavaParser.ResourceContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitResource(@NotNull JavaParser.ResourceContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterMethodBody(@NotNull JavaParser.MethodBodyContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitMethodBody(@NotNull JavaParser.MethodBodyContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterLiteral(@NotNull JavaParser.LiteralContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitLiteral(@NotNull JavaParser.LiteralContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx) { } - - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void enterEveryRule(@NotNull ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void exitEveryRule(@NotNull ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void visitTerminal(@NotNull TerminalNode node) { } - /** - * {@inheritDoc} - * <p/> - * The default implementation does nothing. - */ - @Override public void visitErrorNode(@NotNull ErrorNode node) { } -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java deleted file mode 100644 index d80cf31..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java +++ /dev/null @@ -1,846 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; - -/** - * This class provides an empty implementation of {@link JavaVisitor}, - * which can be extended to create a visitor which only needs to handle a subset - * of the available methods. - * - * @param <T> The return type of the visit operation. Use {@link Void} for - * operations with no return type. - */ -public class JavaBaseVisitor<T> extends AbstractParseTreeVisitor<T> implements JavaVisitor<T> { - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitExpressionList(@NotNull JavaParser.ExpressionListContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitForUpdate(@NotNull JavaParser.ForUpdateContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotation(@NotNull JavaParser.AnnotationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnumConstant(@NotNull JavaParser.EnumConstantContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitCatchClause(@NotNull JavaParser.CatchClauseContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeParameter(@NotNull JavaParser.TypeParameterContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeBound(@NotNull JavaParser.TypeBoundContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitBlock(@NotNull JavaParser.BlockContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitParExpression(@NotNull JavaParser.ParExpressionContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeParameters(@NotNull JavaParser.TypeParametersContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitArguments(@NotNull JavaParser.ArgumentsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitFormalParameters(@NotNull JavaParser.FormalParametersContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitForInit(@NotNull JavaParser.ForInitContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitExpression(@NotNull JavaParser.ExpressionContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitResources(@NotNull JavaParser.ResourcesContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitFormalParameter(@NotNull JavaParser.FormalParameterContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitType(@NotNull JavaParser.TypeContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitPrimary(@NotNull JavaParser.PrimaryContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassBody(@NotNull JavaParser.ClassBodyContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitDefaultValue(@NotNull JavaParser.DefaultValueContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitVariableModifier(@NotNull JavaParser.VariableModifierContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitCreatedName(@NotNull JavaParser.CreatedNameContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitCatchType(@NotNull JavaParser.CatchTypeContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitModifier(@NotNull JavaParser.ModifierContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitStatement(@NotNull JavaParser.StatementContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitForControl(@NotNull JavaParser.ForControlContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeList(@NotNull JavaParser.TypeListContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitElementValue(@NotNull JavaParser.ElementValueContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitBlockStatement(@NotNull JavaParser.BlockStatementContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitCreator(@NotNull JavaParser.CreatorContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitResource(@NotNull JavaParser.ResourceContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitMethodBody(@NotNull JavaParser.MethodBodyContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitLiteral(@NotNull JavaParser.LiteralContext ctx) { return visitChildren(ctx); } - - /** - * {@inheritDoc} - * <p/> - * The default implementation returns the result of calling - * {@link #visitChildren} on {@code ctx}. - */ - @Override public T visitSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java deleted file mode 100644 index 3e99fe0..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java +++ /dev/null @@ -1,570 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -import org.antlr.v4.runtime.Lexer; -import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.Token; -import org.antlr.v4.runtime.TokenStream; -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.atn.*; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.*; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class JavaLexer extends Lexer { - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, - CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, - ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, - IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, - NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, - SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, - THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, - WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, - CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, - LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, - ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, - LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, - MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ADD_ASSIGN=89, - SUB_ASSIGN=90, MUL_ASSIGN=91, DIV_ASSIGN=92, AND_ASSIGN=93, OR_ASSIGN=94, - XOR_ASSIGN=95, MOD_ASSIGN=96, LSHIFT_ASSIGN=97, RSHIFT_ASSIGN=98, URSHIFT_ASSIGN=99, - Identifier=100, AT=101, ELLIPSIS=102, WS=103, COMMENT=104, LINE_COMMENT=105; - public static String[] modeNames = { - "DEFAULT_MODE" - }; - - public static final String[] tokenNames = { - "<INVALID>", - "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", - "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", "IntegerLiteral", - "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", - "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", - "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", - "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", - "'|'", "'^'", "'%'", "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", - "'%='", "'<<='", "'>>='", "'>>>='", "Identifier", "'@'", "'...'", "WS", - "COMMENT", "LINE_COMMENT" - }; - public static final String[] ruleNames = { - "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", - "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", - "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", - "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", - "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", - "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", - "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", - "HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", - "DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitOrUnderscore", - "Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitOrUnderscore", - "OctalNumeral", "OctalDigits", "OctalDigit", "OctalDigitOrUnderscore", - "BinaryNumeral", "BinaryDigits", "BinaryDigit", "BinaryDigitOrUnderscore", - "FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", - "ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", - "HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", - "CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", - "StringCharacter", "EscapeSequence", "OctalEscape", "UnicodeEscape", "ZeroToThree", - "NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", - "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", - "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", - "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", - "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", - "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", - "JavaLetter", "JavaLetterOrDigit", "AT", "ELLIPSIS", "WS", "COMMENT", - "LINE_COMMENT" - }; - - - public JavaLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - @Override - public String getGrammarFileName() { return "Java.g4"; } - - @Override - public String[] getTokenNames() { return tokenNames; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String[] getModeNames() { return modeNames; } - - @Override - public ATN getATN() { return _ATN; } - - @Override - public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { - switch (ruleIndex) { - case 144: WS_action((RuleContext)_localctx, actionIndex); break; - - case 145: COMMENT_action((RuleContext)_localctx, actionIndex); break; - - case 146: LINE_COMMENT_action((RuleContext)_localctx, actionIndex); break; - } - } - private void WS_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 0: skip(); break; - } - } - private void LINE_COMMENT_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 2: skip(); break; - } - } - private void COMMENT_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 1: skip(); break; - } - } - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 140: return JavaLetter_sempred((RuleContext)_localctx, predIndex); - - case 141: return JavaLetterOrDigit_sempred((RuleContext)_localctx, predIndex); - } - return true; - } - private boolean JavaLetterOrDigit_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 2: return Character.isJavaIdentifierPart(_input.LA(-1)); - - case 3: return Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); - } - return true; - } - private boolean JavaLetter_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: return Character.isJavaIdentifierStart(_input.LA(-1)); - - case 1: return Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1))); - } - return true; - } - - public static final String _serializedATN = - "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\2k\u042e\b\1\4\2\t"+ - "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ - "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ - "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ - "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ - "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ - "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ - "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ - "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ - "\4\u0093\t\u0093\4\u0094\t\u0094\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3"+ - "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5"+ - "\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3"+ - "\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13"+ - "\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r"+ - "\3\r\3\r\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3"+ - "\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3"+ - "\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3"+ - "\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\27\3\27\3"+ - "\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ - "\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3"+ - "\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3"+ - "\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3"+ - "\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3!\3!\3\"\3\"\3"+ - "\"\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3"+ - "$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3\'\3"+ - "\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3"+ - "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3"+ - "-\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3/\3/\3\60\3\60\3\60\3"+ - "\60\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3"+ - "\62\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\5\64\u0281\n\64"+ - "\3\65\3\65\5\65\u0285\n\65\3\66\3\66\5\66\u0289\n\66\3\67\3\67\5\67\u028d"+ - "\n\67\38\38\58\u0291\n8\39\39\3:\3:\3:\5:\u0298\n:\3:\3:\3:\5:\u029d\n"+ - ":\5:\u029f\n:\3;\3;\7;\u02a3\n;\f;\16;\u02a6\13;\3;\5;\u02a9\n;\3<\3<"+ - "\5<\u02ad\n<\3=\3=\3>\3>\5>\u02b3\n>\3?\6?\u02b6\n?\r?\16?\u02b7\3@\3"+ - "@\3@\3@\3A\3A\7A\u02c0\nA\fA\16A\u02c3\13A\3A\5A\u02c6\nA\3B\3B\3C\3C"+ - "\5C\u02cc\nC\3D\3D\5D\u02d0\nD\3D\3D\3E\3E\7E\u02d6\nE\fE\16E\u02d9\13"+ - "E\3E\5E\u02dc\nE\3F\3F\3G\3G\5G\u02e2\nG\3H\3H\3H\3H\3I\3I\7I\u02ea\n"+ - "I\fI\16I\u02ed\13I\3I\5I\u02f0\nI\3J\3J\3K\3K\5K\u02f6\nK\3L\3L\5L\u02fa"+ - "\nL\3M\3M\3M\5M\u02ff\nM\3M\5M\u0302\nM\3M\5M\u0305\nM\3M\3M\3M\5M\u030a"+ - "\nM\3M\5M\u030d\nM\3M\3M\3M\5M\u0312\nM\3M\3M\3M\5M\u0317\nM\3N\3N\3N"+ - "\3O\3O\3P\5P\u031f\nP\3P\3P\3Q\3Q\3R\3R\3S\3S\3S\5S\u032a\nS\3T\3T\5T"+ - "\u032e\nT\3T\3T\3T\5T\u0333\nT\3T\3T\5T\u0337\nT\3U\3U\3U\3V\3V\3W\3W"+ - "\3W\3W\3W\3W\3W\3W\3W\5W\u0347\nW\3X\3X\3X\3X\3X\3X\3X\3X\5X\u0351\nX"+ - "\3Y\3Y\3Z\3Z\5Z\u0357\nZ\3Z\3Z\3[\6[\u035c\n[\r[\16[\u035d\3\\\3\\\5\\"+ - "\u0362\n\\\3]\3]\3]\3]\5]\u0368\n]\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\5"+ - "^\u0375\n^\3_\3_\3_\3_\3_\3_\3_\3`\3`\3a\3a\3a\3a\3a\3b\3b\3c\3c\3d\3"+ - "d\3e\3e\3f\3f\3g\3g\3h\3h\3i\3i\3j\3j\3k\3k\3l\3l\3m\3m\3n\3n\3o\3o\3"+ - "p\3p\3q\3q\3r\3r\3r\3s\3s\3s\3t\3t\3t\3u\3u\3u\3v\3v\3v\3w\3w\3w\3x\3"+ - "x\3x\3y\3y\3y\3z\3z\3{\3{\3|\3|\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080"+ - "\3\u0081\3\u0081\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0084"+ - "\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0086\3\u0086\3\u0086\3\u0087"+ - "\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u008a"+ - "\3\u008a\3\u008a\3\u008a\3\u008b\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c"+ - "\3\u008c\3\u008c\3\u008c\3\u008d\3\u008d\7\u008d\u03f4\n\u008d\f\u008d"+ - "\16\u008d\u03f7\13\u008d\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+ - "\5\u008e\u03ff\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f"+ - "\5\u008f\u0407\n\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091\3\u0091"+ - "\3\u0092\6\u0092\u0410\n\u0092\r\u0092\16\u0092\u0411\3\u0092\3\u0092"+ - "\3\u0093\3\u0093\3\u0093\3\u0093\7\u0093\u041a\n\u0093\f\u0093\16\u0093"+ - "\u041d\13\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094"+ - "\3\u0094\3\u0094\7\u0094\u0428\n\u0094\f\u0094\16\u0094\u042b\13\u0094"+ - "\3\u0094\3\u0094\3\u041b\u0095\3\3\1\5\4\1\7\5\1\t\6\1\13\7\1\r\b\1\17"+ - "\t\1\21\n\1\23\13\1\25\f\1\27\r\1\31\16\1\33\17\1\35\20\1\37\21\1!\22"+ - "\1#\23\1%\24\1\'\25\1)\26\1+\27\1-\30\1/\31\1\61\32\1\63\33\1\65\34\1"+ - "\67\35\19\36\1;\37\1= \1?!\1A\"\1C#\1E$\1G%\1I&\1K\'\1M(\1O)\1Q*\1S+\1"+ - "U,\1W-\1Y.\1[/\1]\60\1_\61\1a\62\1c\63\1e\64\1g\65\1i\2\1k\2\1m\2\1o\2"+ - "\1q\2\1s\2\1u\2\1w\2\1y\2\1{\2\1}\2\1\177\2\1\u0081\2\1\u0083\2\1\u0085"+ - "\2\1\u0087\2\1\u0089\2\1\u008b\2\1\u008d\2\1\u008f\2\1\u0091\2\1\u0093"+ - "\2\1\u0095\2\1\u0097\66\1\u0099\2\1\u009b\2\1\u009d\2\1\u009f\2\1\u00a1"+ - "\2\1\u00a3\2\1\u00a5\2\1\u00a7\2\1\u00a9\2\1\u00ab\2\1\u00ad\67\1\u00af"+ - "8\1\u00b1\2\1\u00b39\1\u00b5\2\1\u00b7\2\1\u00b9\2\1\u00bb\2\1\u00bd\2"+ - "\1\u00bf\2\1\u00c1:\1\u00c3;\1\u00c5<\1\u00c7=\1\u00c9>\1\u00cb?\1\u00cd"+ - "@\1\u00cfA\1\u00d1B\1\u00d3C\1\u00d5D\1\u00d7E\1\u00d9F\1\u00dbG\1\u00dd"+ - "H\1\u00dfI\1\u00e1J\1\u00e3K\1\u00e5L\1\u00e7M\1\u00e9N\1\u00ebO\1\u00ed"+ - "P\1\u00efQ\1\u00f1R\1\u00f3S\1\u00f5T\1\u00f7U\1\u00f9V\1\u00fbW\1\u00fd"+ - "X\1\u00ffY\1\u0101Z\1\u0103[\1\u0105\\\1\u0107]\1\u0109^\1\u010b_\1\u010d"+ - "`\1\u010fa\1\u0111b\1\u0113c\1\u0115d\1\u0117e\1\u0119f\1\u011b\2\1\u011d"+ - "\2\1\u011fg\1\u0121h\1\u0123i\2\u0125j\3\u0127k\4\3\2\30\4\2NNnn\3\2\63"+ - ";\4\2ZZzz\5\2\62;CHch\3\2\629\4\2DDdd\3\2\62\63\4\2GGgg\4\2--//\6\2FF"+ - "HHffhh\4\2RRrr\4\2))^^\4\2$$^^\n\2$$))^^ddhhppttvv\3\2\62\65\6\2&&C\\"+ - "aac|\4\2\2\u0101\ud802\udc01\3\2\ud802\udc01\3\2\udc02\ue001\7\2&&\62"+ - ";C\\aac|\5\2\13\f\16\17\"\"\4\2\f\f\17\17\u043c\2\3\3\2\2\2\2\5\3\2\2"+ - "\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21"+ - "\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2"+ - "\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3"+ - "\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3"+ - "\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3"+ - "\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2"+ - "\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2"+ - "Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3"+ - "\2\2\2\2g\3\2\2\2\2\u0097\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b3"+ - "\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2"+ - "\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1"+ - "\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2"+ - "\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3"+ - "\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2"+ - "\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5"+ - "\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2"+ - "\2\2\u00ff\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2\2\2\u0107"+ - "\3\2\2\2\2\u0109\3\2\2\2\2\u010b\3\2\2\2\2\u010d\3\2\2\2\2\u010f\3\2\2"+ - "\2\2\u0111\3\2\2\2\2\u0113\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119"+ - "\3\2\2\2\2\u011f\3\2\2\2\2\u0121\3\2\2\2\2\u0123\3\2\2\2\2\u0125\3\2\2"+ - "\2\2\u0127\3\2\2\2\3\u0129\3\2\2\2\5\u0132\3\2\2\2\7\u0139\3\2\2\2\t\u0141"+ - "\3\2\2\2\13\u0147\3\2\2\2\r\u014c\3\2\2\2\17\u0151\3\2\2\2\21\u0157\3"+ - "\2\2\2\23\u015c\3\2\2\2\25\u0162\3\2\2\2\27\u0168\3\2\2\2\31\u0171\3\2"+ - "\2\2\33\u0179\3\2\2\2\35\u017c\3\2\2\2\37\u0183\3\2\2\2!\u0188\3\2\2\2"+ - "#\u018d\3\2\2\2%\u0195\3\2\2\2\'\u019b\3\2\2\2)\u01a3\3\2\2\2+\u01a9\3"+ - "\2\2\2-\u01ad\3\2\2\2/\u01b0\3\2\2\2\61\u01b5\3\2\2\2\63\u01c0\3\2\2\2"+ - "\65\u01c7\3\2\2\2\67\u01d2\3\2\2\29\u01d6\3\2\2\2;\u01e0\3\2\2\2=\u01e5"+ - "\3\2\2\2?\u01ec\3\2\2\2A\u01f0\3\2\2\2C\u01f8\3\2\2\2E\u0200\3\2\2\2G"+ - "\u020a\3\2\2\2I\u0211\3\2\2\2K\u0218\3\2\2\2M\u021e\3\2\2\2O\u0225\3\2"+ - "\2\2Q\u022e\3\2\2\2S\u0234\3\2\2\2U\u023b\3\2\2\2W\u0248\3\2\2\2Y\u024d"+ - "\3\2\2\2[\u0253\3\2\2\2]\u025a\3\2\2\2_\u0264\3\2\2\2a\u0268\3\2\2\2c"+ - "\u026d\3\2\2\2e\u0276\3\2\2\2g\u0280\3\2\2\2i\u0282\3\2\2\2k\u0286\3\2"+ - "\2\2m\u028a\3\2\2\2o\u028e\3\2\2\2q\u0292\3\2\2\2s\u029e\3\2\2\2u\u02a0"+ - "\3\2\2\2w\u02ac\3\2\2\2y\u02ae\3\2\2\2{\u02b2\3\2\2\2}\u02b5\3\2\2\2\177"+ - "\u02b9\3\2\2\2\u0081\u02bd\3\2\2\2\u0083\u02c7\3\2\2\2\u0085\u02cb\3\2"+ - "\2\2\u0087\u02cd\3\2\2\2\u0089\u02d3\3\2\2\2\u008b\u02dd\3\2\2\2\u008d"+ - "\u02e1\3\2\2\2\u008f\u02e3\3\2\2\2\u0091\u02e7\3\2\2\2\u0093\u02f1\3\2"+ - "\2\2\u0095\u02f5\3\2\2\2\u0097\u02f9\3\2\2\2\u0099\u0316\3\2\2\2\u009b"+ - "\u0318\3\2\2\2\u009d\u031b\3\2\2\2\u009f\u031e\3\2\2\2\u00a1\u0322\3\2"+ - "\2\2\u00a3\u0324\3\2\2\2\u00a5\u0326\3\2\2\2\u00a7\u0336\3\2\2\2\u00a9"+ - "\u0338\3\2\2\2\u00ab\u033b\3\2\2\2\u00ad\u0346\3\2\2\2\u00af\u0350\3\2"+ - "\2\2\u00b1\u0352\3\2\2\2\u00b3\u0354\3\2\2\2\u00b5\u035b\3\2\2\2\u00b7"+ - "\u0361\3\2\2\2\u00b9\u0367\3\2\2\2\u00bb\u0374\3\2\2\2\u00bd\u0376\3\2"+ - "\2\2\u00bf\u037d\3\2\2\2\u00c1\u037f\3\2\2\2\u00c3\u0384\3\2\2\2\u00c5"+ - "\u0386\3\2\2\2\u00c7\u0388\3\2\2\2\u00c9\u038a\3\2\2\2\u00cb\u038c\3\2"+ - "\2\2\u00cd\u038e\3\2\2\2\u00cf\u0390\3\2\2\2\u00d1\u0392\3\2\2\2\u00d3"+ - "\u0394\3\2\2\2\u00d5\u0396\3\2\2\2\u00d7\u0398\3\2\2\2\u00d9\u039a\3\2"+ - "\2\2\u00db\u039c\3\2\2\2\u00dd\u039e\3\2\2\2\u00df\u03a0\3\2\2\2\u00e1"+ - "\u03a2\3\2\2\2\u00e3\u03a4\3\2\2\2\u00e5\u03a7\3\2\2\2\u00e7\u03aa\3\2"+ - "\2\2\u00e9\u03ad\3\2\2\2\u00eb\u03b0\3\2\2\2\u00ed\u03b3\3\2\2\2\u00ef"+ - "\u03b6\3\2\2\2\u00f1\u03b9\3\2\2\2\u00f3\u03bc\3\2\2\2\u00f5\u03be\3\2"+ - "\2\2\u00f7\u03c0\3\2\2\2\u00f9\u03c2\3\2\2\2\u00fb\u03c4\3\2\2\2\u00fd"+ - "\u03c6\3\2\2\2\u00ff\u03c8\3\2\2\2\u0101\u03ca\3\2\2\2\u0103\u03cc\3\2"+ - "\2\2\u0105\u03cf\3\2\2\2\u0107\u03d2\3\2\2\2\u0109\u03d5\3\2\2\2\u010b"+ - "\u03d8\3\2\2\2\u010d\u03db\3\2\2\2\u010f\u03de\3\2\2\2\u0111\u03e1\3\2"+ - "\2\2\u0113\u03e4\3\2\2\2\u0115\u03e8\3\2\2\2\u0117\u03ec\3\2\2\2\u0119"+ - "\u03f1\3\2\2\2\u011b\u03fe\3\2\2\2\u011d\u0406\3\2\2\2\u011f\u0408\3\2"+ - "\2\2\u0121\u040a\3\2\2\2\u0123\u040f\3\2\2\2\u0125\u0415\3\2\2\2\u0127"+ - "\u0423\3\2\2\2\u0129\u012a\7c\2\2\u012a\u012b\7d\2\2\u012b\u012c\7u\2"+ - "\2\u012c\u012d\7v\2\2\u012d\u012e\7t\2\2\u012e\u012f\7c\2\2\u012f\u0130"+ - "\7e\2\2\u0130\u0131\7v\2\2\u0131\4\3\2\2\2\u0132\u0133\7c\2\2\u0133\u0134"+ - "\7u\2\2\u0134\u0135\7u\2\2\u0135\u0136\7g\2\2\u0136\u0137\7t\2\2\u0137"+ - "\u0138\7v\2\2\u0138\6\3\2\2\2\u0139\u013a\7d\2\2\u013a\u013b\7q\2\2\u013b"+ - "\u013c\7q\2\2\u013c\u013d\7n\2\2\u013d\u013e\7g\2\2\u013e\u013f\7c\2\2"+ - "\u013f\u0140\7p\2\2\u0140\b\3\2\2\2\u0141\u0142\7d\2\2\u0142\u0143\7t"+ - "\2\2\u0143\u0144\7g\2\2\u0144\u0145\7c\2\2\u0145\u0146\7m\2\2\u0146\n"+ - "\3\2\2\2\u0147\u0148\7d\2\2\u0148\u0149\7{\2\2\u0149\u014a\7v\2\2\u014a"+ - "\u014b\7g\2\2\u014b\f\3\2\2\2\u014c\u014d\7e\2\2\u014d\u014e\7c\2\2\u014e"+ - "\u014f\7u\2\2\u014f\u0150\7g\2\2\u0150\16\3\2\2\2\u0151\u0152\7e\2\2\u0152"+ - "\u0153\7c\2\2\u0153\u0154\7v\2\2\u0154\u0155\7e\2\2\u0155\u0156\7j\2\2"+ - "\u0156\20\3\2\2\2\u0157\u0158\7e\2\2\u0158\u0159\7j\2\2\u0159\u015a\7"+ - "c\2\2\u015a\u015b\7t\2\2\u015b\22\3\2\2\2\u015c\u015d\7e\2\2\u015d\u015e"+ - "\7n\2\2\u015e\u015f\7c\2\2\u015f\u0160\7u\2\2\u0160\u0161\7u\2\2\u0161"+ - "\24\3\2\2\2\u0162\u0163\7e\2\2\u0163\u0164\7q\2\2\u0164\u0165\7p\2\2\u0165"+ - "\u0166\7u\2\2\u0166\u0167\7v\2\2\u0167\26\3\2\2\2\u0168\u0169\7e\2\2\u0169"+ - "\u016a\7q\2\2\u016a\u016b\7p\2\2\u016b\u016c\7v\2\2\u016c\u016d\7k\2\2"+ - "\u016d\u016e\7p\2\2\u016e\u016f\7w\2\2\u016f\u0170\7g\2\2\u0170\30\3\2"+ - "\2\2\u0171\u0172\7f\2\2\u0172\u0173\7g\2\2\u0173\u0174\7h\2\2\u0174\u0175"+ - "\7c\2\2\u0175\u0176\7w\2\2\u0176\u0177\7n\2\2\u0177\u0178\7v\2\2\u0178"+ - "\32\3\2\2\2\u0179\u017a\7f\2\2\u017a\u017b\7q\2\2\u017b\34\3\2\2\2\u017c"+ - "\u017d\7f\2\2\u017d\u017e\7q\2\2\u017e\u017f\7w\2\2\u017f\u0180\7d\2\2"+ - "\u0180\u0181\7n\2\2\u0181\u0182\7g\2\2\u0182\36\3\2\2\2\u0183\u0184\7"+ - "g\2\2\u0184\u0185\7n\2\2\u0185\u0186\7u\2\2\u0186\u0187\7g\2\2\u0187 "+ - "\3\2\2\2\u0188\u0189\7g\2\2\u0189\u018a\7p\2\2\u018a\u018b\7w\2\2\u018b"+ - "\u018c\7o\2\2\u018c\"\3\2\2\2\u018d\u018e\7g\2\2\u018e\u018f\7z\2\2\u018f"+ - "\u0190\7v\2\2\u0190\u0191\7g\2\2\u0191\u0192\7p\2\2\u0192\u0193\7f\2\2"+ - "\u0193\u0194\7u\2\2\u0194$\3\2\2\2\u0195\u0196\7h\2\2\u0196\u0197\7k\2"+ - "\2\u0197\u0198\7p\2\2\u0198\u0199\7c\2\2\u0199\u019a\7n\2\2\u019a&\3\2"+ - "\2\2\u019b\u019c\7h\2\2\u019c\u019d\7k\2\2\u019d\u019e\7p\2\2\u019e\u019f"+ - "\7c\2\2\u019f\u01a0\7n\2\2\u01a0\u01a1\7n\2\2\u01a1\u01a2\7{\2\2\u01a2"+ - "(\3\2\2\2\u01a3\u01a4\7h\2\2\u01a4\u01a5\7n\2\2\u01a5\u01a6\7q\2\2\u01a6"+ - "\u01a7\7c\2\2\u01a7\u01a8\7v\2\2\u01a8*\3\2\2\2\u01a9\u01aa\7h\2\2\u01aa"+ - "\u01ab\7q\2\2\u01ab\u01ac\7t\2\2\u01ac,\3\2\2\2\u01ad\u01ae\7k\2\2\u01ae"+ - "\u01af\7h\2\2\u01af.\3\2\2\2\u01b0\u01b1\7i\2\2\u01b1\u01b2\7q\2\2\u01b2"+ - "\u01b3\7v\2\2\u01b3\u01b4\7q\2\2\u01b4\60\3\2\2\2\u01b5\u01b6\7k\2\2\u01b6"+ - "\u01b7\7o\2\2\u01b7\u01b8\7r\2\2\u01b8\u01b9\7n\2\2\u01b9\u01ba\7g\2\2"+ - "\u01ba\u01bb\7o\2\2\u01bb\u01bc\7g\2\2\u01bc\u01bd\7p\2\2\u01bd\u01be"+ - "\7v\2\2\u01be\u01bf\7u\2\2\u01bf\62\3\2\2\2\u01c0\u01c1\7k\2\2\u01c1\u01c2"+ - "\7o\2\2\u01c2\u01c3\7r\2\2\u01c3\u01c4\7q\2\2\u01c4\u01c5\7t\2\2\u01c5"+ - "\u01c6\7v\2\2\u01c6\64\3\2\2\2\u01c7\u01c8\7k\2\2\u01c8\u01c9\7p\2\2\u01c9"+ - "\u01ca\7u\2\2\u01ca\u01cb\7v\2\2\u01cb\u01cc\7c\2\2\u01cc\u01cd\7p\2\2"+ - "\u01cd\u01ce\7e\2\2\u01ce\u01cf\7g\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1"+ - "\7h\2\2\u01d1\66\3\2\2\2\u01d2\u01d3\7k\2\2\u01d3\u01d4\7p\2\2\u01d4\u01d5"+ - "\7v\2\2\u01d58\3\2\2\2\u01d6\u01d7\7k\2\2\u01d7\u01d8\7p\2\2\u01d8\u01d9"+ - "\7v\2\2\u01d9\u01da\7g\2\2\u01da\u01db\7t\2\2\u01db\u01dc\7h\2\2\u01dc"+ - "\u01dd\7c\2\2\u01dd\u01de\7e\2\2\u01de\u01df\7g\2\2\u01df:\3\2\2\2\u01e0"+ - "\u01e1\7n\2\2\u01e1\u01e2\7q\2\2\u01e2\u01e3\7p\2\2\u01e3\u01e4\7i\2\2"+ - "\u01e4<\3\2\2\2\u01e5\u01e6\7p\2\2\u01e6\u01e7\7c\2\2\u01e7\u01e8\7v\2"+ - "\2\u01e8\u01e9\7k\2\2\u01e9\u01ea\7x\2\2\u01ea\u01eb\7g\2\2\u01eb>\3\2"+ - "\2\2\u01ec\u01ed\7p\2\2\u01ed\u01ee\7g\2\2\u01ee\u01ef\7y\2\2\u01ef@\3"+ - "\2\2\2\u01f0\u01f1\7r\2\2\u01f1\u01f2\7c\2\2\u01f2\u01f3\7e\2\2\u01f3"+ - "\u01f4\7m\2\2\u01f4\u01f5\7c\2\2\u01f5\u01f6\7i\2\2\u01f6\u01f7\7g\2\2"+ - "\u01f7B\3\2\2\2\u01f8\u01f9\7r\2\2\u01f9\u01fa\7t\2\2\u01fa\u01fb\7k\2"+ - "\2\u01fb\u01fc\7x\2\2\u01fc\u01fd\7c\2\2\u01fd\u01fe\7v\2\2\u01fe\u01ff"+ - "\7g\2\2\u01ffD\3\2\2\2\u0200\u0201\7r\2\2\u0201\u0202\7t\2\2\u0202\u0203"+ - "\7q\2\2\u0203\u0204\7v\2\2\u0204\u0205\7g\2\2\u0205\u0206\7e\2\2\u0206"+ - "\u0207\7v\2\2\u0207\u0208\7g\2\2\u0208\u0209\7f\2\2\u0209F\3\2\2\2\u020a"+ - "\u020b\7r\2\2\u020b\u020c\7w\2\2\u020c\u020d\7d\2\2\u020d\u020e\7n\2\2"+ - "\u020e\u020f\7k\2\2\u020f\u0210\7e\2\2\u0210H\3\2\2\2\u0211\u0212\7t\2"+ - "\2\u0212\u0213\7g\2\2\u0213\u0214\7v\2\2\u0214\u0215\7w\2\2\u0215\u0216"+ - "\7t\2\2\u0216\u0217\7p\2\2\u0217J\3\2\2\2\u0218\u0219\7u\2\2\u0219\u021a"+ - "\7j\2\2\u021a\u021b\7q\2\2\u021b\u021c\7t\2\2\u021c\u021d\7v\2\2\u021d"+ - "L\3\2\2\2\u021e\u021f\7u\2\2\u021f\u0220\7v\2\2\u0220\u0221\7c\2\2\u0221"+ - "\u0222\7v\2\2\u0222\u0223\7k\2\2\u0223\u0224\7e\2\2\u0224N\3\2\2\2\u0225"+ - "\u0226\7u\2\2\u0226\u0227\7v\2\2\u0227\u0228\7t\2\2\u0228\u0229\7k\2\2"+ - "\u0229\u022a\7e\2\2\u022a\u022b\7v\2\2\u022b\u022c\7h\2\2\u022c\u022d"+ - "\7r\2\2\u022dP\3\2\2\2\u022e\u022f\7u\2\2\u022f\u0230\7w\2\2\u0230\u0231"+ - "\7r\2\2\u0231\u0232\7g\2\2\u0232\u0233\7t\2\2\u0233R\3\2\2\2\u0234\u0235"+ - "\7u\2\2\u0235\u0236\7y\2\2\u0236\u0237\7k\2\2\u0237\u0238\7v\2\2\u0238"+ - "\u0239\7e\2\2\u0239\u023a\7j\2\2\u023aT\3\2\2\2\u023b\u023c\7u\2\2\u023c"+ - "\u023d\7{\2\2\u023d\u023e\7p\2\2\u023e\u023f\7e\2\2\u023f\u0240\7j\2\2"+ - "\u0240\u0241\7t\2\2\u0241\u0242\7q\2\2\u0242\u0243\7p\2\2\u0243\u0244"+ - "\7k\2\2\u0244\u0245\7|\2\2\u0245\u0246\7g\2\2\u0246\u0247\7f\2\2\u0247"+ - "V\3\2\2\2\u0248\u0249\7v\2\2\u0249\u024a\7j\2\2\u024a\u024b\7k\2\2\u024b"+ - "\u024c\7u\2\2\u024cX\3\2\2\2\u024d\u024e\7v\2\2\u024e\u024f\7j\2\2\u024f"+ - "\u0250\7t\2\2\u0250\u0251\7q\2\2\u0251\u0252\7y\2\2\u0252Z\3\2\2\2\u0253"+ - "\u0254\7v\2\2\u0254\u0255\7j\2\2\u0255\u0256\7t\2\2\u0256\u0257\7q\2\2"+ - "\u0257\u0258\7y\2\2\u0258\u0259\7u\2\2\u0259\\\3\2\2\2\u025a\u025b\7v"+ - "\2\2\u025b\u025c\7t\2\2\u025c\u025d\7c\2\2\u025d\u025e\7p\2\2\u025e\u025f"+ - "\7u\2\2\u025f\u0260\7k\2\2\u0260\u0261\7g\2\2\u0261\u0262\7p\2\2\u0262"+ - "\u0263\7v\2\2\u0263^\3\2\2\2\u0264\u0265\7v\2\2\u0265\u0266\7t\2\2\u0266"+ - "\u0267\7{\2\2\u0267`\3\2\2\2\u0268\u0269\7x\2\2\u0269\u026a\7q\2\2\u026a"+ - "\u026b\7k\2\2\u026b\u026c\7f\2\2\u026cb\3\2\2\2\u026d\u026e\7x\2\2\u026e"+ - "\u026f\7q\2\2\u026f\u0270\7n\2\2\u0270\u0271\7c\2\2\u0271\u0272\7v\2\2"+ - "\u0272\u0273\7k\2\2\u0273\u0274\7n\2\2\u0274\u0275\7g\2\2\u0275d\3\2\2"+ - "\2\u0276\u0277\7y\2\2\u0277\u0278\7j\2\2\u0278\u0279\7k\2\2\u0279\u027a"+ - "\7n\2\2\u027a\u027b\7g\2\2\u027bf\3\2\2\2\u027c\u0281\5i\65\2\u027d\u0281"+ - "\5k\66\2\u027e\u0281\5m\67\2\u027f\u0281\5o8\2\u0280\u027c\3\2\2\2\u0280"+ - "\u027d\3\2\2\2\u0280\u027e\3\2\2\2\u0280\u027f\3\2\2\2\u0281h\3\2\2\2"+ - "\u0282\u0284\5s:\2\u0283\u0285\5q9\2\u0284\u0283\3\2\2\2\u0284\u0285\3"+ - "\2\2\2\u0285j\3\2\2\2\u0286\u0288\5\177@\2\u0287\u0289\5q9\2\u0288\u0287"+ - "\3\2\2\2\u0288\u0289\3\2\2\2\u0289l\3\2\2\2\u028a\u028c\5\u0087D\2\u028b"+ - "\u028d\5q9\2\u028c\u028b\3\2\2\2\u028c\u028d\3\2\2\2\u028dn\3\2\2\2\u028e"+ - "\u0290\5\u008fH\2\u028f\u0291\5q9\2\u0290\u028f\3\2\2\2\u0290\u0291\3"+ - "\2\2\2\u0291p\3\2\2\2\u0292\u0293\t\2\2\2\u0293r\3\2\2\2\u0294\u029f\7"+ - "\62\2\2\u0295\u029c\5y=\2\u0296\u0298\5u;\2\u0297\u0296\3\2\2\2\u0297"+ - "\u0298\3\2\2\2\u0298\u029d\3\2\2\2\u0299\u029a\5}?\2\u029a\u029b\5u;\2"+ - "\u029b\u029d\3\2\2\2\u029c\u0297\3\2\2\2\u029c\u0299\3\2\2\2\u029d\u029f"+ - "\3\2\2\2\u029e\u0294\3\2\2\2\u029e\u0295\3\2\2\2\u029ft\3\2\2\2\u02a0"+ - "\u02a8\5w<\2\u02a1\u02a3\5{>\2\u02a2\u02a1\3\2\2\2\u02a3\u02a6\3\2\2\2"+ - "\u02a4\u02a2\3\2\2\2\u02a4\u02a5\3\2\2\2\u02a5\u02a7\3\2\2\2\u02a6\u02a4"+ - "\3\2\2\2\u02a7\u02a9\5w<\2\u02a8\u02a4\3\2\2\2\u02a8\u02a9\3\2\2\2\u02a9"+ - "v\3\2\2\2\u02aa\u02ad\7\62\2\2\u02ab\u02ad\5y=\2\u02ac\u02aa\3\2\2\2\u02ac"+ - "\u02ab\3\2\2\2\u02adx\3\2\2\2\u02ae\u02af\t\3\2\2\u02afz\3\2\2\2\u02b0"+ - "\u02b3\5w<\2\u02b1\u02b3\7a\2\2\u02b2\u02b0\3\2\2\2\u02b2\u02b1\3\2\2"+ - "\2\u02b3|\3\2\2\2\u02b4\u02b6\7a\2\2\u02b5\u02b4\3\2\2\2\u02b6\u02b7\3"+ - "\2\2\2\u02b7\u02b5\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8~\3\2\2\2\u02b9\u02ba"+ - "\7\62\2\2\u02ba\u02bb\t\4\2\2\u02bb\u02bc\5\u0081A\2\u02bc\u0080\3\2\2"+ - "\2\u02bd\u02c5\5\u0083B\2\u02be\u02c0\5\u0085C\2\u02bf\u02be\3\2\2\2\u02c0"+ - "\u02c3\3\2\2\2\u02c1\u02bf\3\2\2\2\u02c1\u02c2\3\2\2\2\u02c2\u02c4\3\2"+ - "\2\2\u02c3\u02c1\3\2\2\2\u02c4\u02c6\5\u0083B\2\u02c5\u02c1\3\2\2\2\u02c5"+ - "\u02c6\3\2\2\2\u02c6\u0082\3\2\2\2\u02c7\u02c8\t\5\2\2\u02c8\u0084\3\2"+ - "\2\2\u02c9\u02cc\5\u0083B\2\u02ca\u02cc\7a\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ - "\u02ca\3\2\2\2\u02cc\u0086\3\2\2\2\u02cd\u02cf\7\62\2\2\u02ce\u02d0\5"+ - "}?\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1"+ - "\u02d2\5\u0089E\2\u02d2\u0088\3\2\2\2\u02d3\u02db\5\u008bF\2\u02d4\u02d6"+ - "\5\u008dG\2\u02d5\u02d4\3\2\2\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2"+ - "\2\u02d7\u02d8\3\2\2\2\u02d8\u02da\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02dc"+ - "\5\u008bF\2\u02db\u02d7\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc\u008a\3\2\2"+ - "\2\u02dd\u02de\t\6\2\2\u02de\u008c\3\2\2\2\u02df\u02e2\5\u008bF\2\u02e0"+ - "\u02e2\7a\2\2\u02e1\u02df\3\2\2\2\u02e1\u02e0\3\2\2\2\u02e2\u008e\3\2"+ - "\2\2\u02e3\u02e4\7\62\2\2\u02e4\u02e5\t\7\2\2\u02e5\u02e6\5\u0091I\2\u02e6"+ - "\u0090\3\2\2\2\u02e7\u02ef\5\u0093J\2\u02e8\u02ea\5\u0095K\2\u02e9\u02e8"+ - "\3\2\2\2\u02ea\u02ed\3\2\2\2\u02eb\u02e9\3\2\2\2\u02eb\u02ec\3\2\2\2\u02ec"+ - "\u02ee\3\2\2\2\u02ed\u02eb\3\2\2\2\u02ee\u02f0\5\u0093J\2\u02ef\u02eb"+ - "\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0\u0092\3\2\2\2\u02f1\u02f2\t\b\2\2\u02f2"+ - "\u0094\3\2\2\2\u02f3\u02f6\5\u0093J\2\u02f4\u02f6\7a\2\2\u02f5\u02f3\3"+ - "\2\2\2\u02f5\u02f4\3\2\2\2\u02f6\u0096\3\2\2\2\u02f7\u02fa\5\u0099M\2"+ - "\u02f8\u02fa\5\u00a5S\2\u02f9\u02f7\3\2\2\2\u02f9\u02f8\3\2\2\2\u02fa"+ - "\u0098\3\2\2\2\u02fb\u02fc\5u;\2\u02fc\u02fe\7\60\2\2\u02fd\u02ff\5u;"+ - "\2\u02fe\u02fd\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0301\3\2\2\2\u0300\u0302"+ - "\5\u009bN\2\u0301\u0300\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0304\3\2\2"+ - "\2\u0303\u0305\5\u00a3R\2\u0304\u0303\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+ - "\u0317\3\2\2\2\u0306\u0307\7\60\2\2\u0307\u0309\5u;\2\u0308\u030a\5\u009b"+ - "N\2\u0309\u0308\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030c\3\2\2\2\u030b"+ - "\u030d\5\u00a3R\2\u030c\u030b\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u0317"+ - "\3\2\2\2\u030e\u030f\5u;\2\u030f\u0311\5\u009bN\2\u0310\u0312\5\u00a3"+ - "R\2\u0311\u0310\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0317\3\2\2\2\u0313"+ - "\u0314\5u;\2\u0314\u0315\5\u00a3R\2\u0315\u0317\3\2\2\2\u0316\u02fb\3"+ - "\2\2\2\u0316\u0306\3\2\2\2\u0316\u030e\3\2\2\2\u0316\u0313\3\2\2\2\u0317"+ - "\u009a\3\2\2\2\u0318\u0319\5\u009dO\2\u0319\u031a\5\u009fP\2\u031a\u009c"+ - "\3\2\2\2\u031b\u031c\t\t\2\2\u031c\u009e\3\2\2\2\u031d\u031f\5\u00a1Q"+ - "\2\u031e\u031d\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0321"+ - "\5u;\2\u0321\u00a0\3\2\2\2\u0322\u0323\t\n\2\2\u0323\u00a2\3\2\2\2\u0324"+ - "\u0325\t\13\2\2\u0325\u00a4\3\2\2\2\u0326\u0327\5\u00a7T\2\u0327\u0329"+ - "\5\u00a9U\2\u0328\u032a\5\u00a3R\2\u0329\u0328\3\2\2\2\u0329\u032a\3\2"+ - "\2\2\u032a\u00a6\3\2\2\2\u032b\u032d\5\177@\2\u032c\u032e\7\60\2\2\u032d"+ - "\u032c\3\2\2\2\u032d\u032e\3\2\2\2\u032e\u0337\3\2\2\2\u032f\u0330\7\62"+ - "\2\2\u0330\u0332\t\4\2\2\u0331\u0333\5\u0081A\2\u0332\u0331\3\2\2\2\u0332"+ - "\u0333\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0335\7\60\2\2\u0335\u0337\5"+ - "\u0081A\2\u0336\u032b\3\2\2\2\u0336\u032f\3\2\2\2\u0337\u00a8\3\2\2\2"+ - "\u0338\u0339\5\u00abV\2\u0339\u033a\5\u009fP\2\u033a\u00aa\3\2\2\2\u033b"+ - "\u033c\t\f\2\2\u033c\u00ac\3\2\2\2\u033d\u033e\7v\2\2\u033e\u033f\7t\2"+ - "\2\u033f\u0340\7w\2\2\u0340\u0347\7g\2\2\u0341\u0342\7h\2\2\u0342\u0343"+ - "\7c\2\2\u0343\u0344\7n\2\2\u0344\u0345\7u\2\2\u0345\u0347\7g\2\2\u0346"+ - "\u033d\3\2\2\2\u0346\u0341\3\2\2\2\u0347\u00ae\3\2\2\2\u0348\u0349\7)"+ - "\2\2\u0349\u034a\5\u00b1Y\2\u034a\u034b\7)\2\2\u034b\u0351\3\2\2\2\u034c"+ - "\u034d\7)\2\2\u034d\u034e\5\u00b9]\2\u034e\u034f\7)\2\2\u034f\u0351\3"+ - "\2\2\2\u0350\u0348\3\2\2\2\u0350\u034c\3\2\2\2\u0351\u00b0\3\2\2\2\u0352"+ - "\u0353\n\r\2\2\u0353\u00b2\3\2\2\2\u0354\u0356\7$\2\2\u0355\u0357\5\u00b5"+ - "[\2\u0356\u0355\3\2\2\2\u0356\u0357\3\2\2\2\u0357\u0358\3\2\2\2\u0358"+ - "\u0359\7$\2\2\u0359\u00b4\3\2\2\2\u035a\u035c\5\u00b7\\\2\u035b\u035a"+ - "\3\2\2\2\u035c\u035d\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035e\3\2\2\2\u035e"+ - "\u00b6\3\2\2\2\u035f\u0362\n\16\2\2\u0360\u0362\5\u00b9]\2\u0361\u035f"+ - "\3\2\2\2\u0361\u0360\3\2\2\2\u0362\u00b8\3\2\2\2\u0363\u0364\7^\2\2\u0364"+ - "\u0368\t\17\2\2\u0365\u0368\5\u00bb^\2\u0366\u0368\5\u00bd_\2\u0367\u0363"+ - "\3\2\2\2\u0367\u0365\3\2\2\2\u0367\u0366\3\2\2\2\u0368\u00ba\3\2\2\2\u0369"+ - "\u036a\7^\2\2\u036a\u0375\5\u008bF\2\u036b\u036c\7^\2\2\u036c\u036d\5"+ - "\u008bF\2\u036d\u036e\5\u008bF\2\u036e\u0375\3\2\2\2\u036f\u0370\7^\2"+ - "\2\u0370\u0371\5\u00bf`\2\u0371\u0372\5\u008bF\2\u0372\u0373\5\u008bF"+ - "\2\u0373\u0375\3\2\2\2\u0374\u0369\3\2\2\2\u0374\u036b\3\2\2\2\u0374\u036f"+ - "\3\2\2\2\u0375\u00bc\3\2\2\2\u0376\u0377\7^\2\2\u0377\u0378\7w\2\2\u0378"+ - "\u0379\5\u0083B\2\u0379\u037a\5\u0083B\2\u037a\u037b\5\u0083B\2\u037b"+ - "\u037c\5\u0083B\2\u037c\u00be\3\2\2\2\u037d\u037e\t\20\2\2\u037e\u00c0"+ - "\3\2\2\2\u037f\u0380\7p\2\2\u0380\u0381\7w\2\2\u0381\u0382\7n\2\2\u0382"+ - "\u0383\7n\2\2\u0383\u00c2\3\2\2\2\u0384\u0385\7*\2\2\u0385\u00c4\3\2\2"+ - "\2\u0386\u0387\7+\2\2\u0387\u00c6\3\2\2\2\u0388\u0389\7}\2\2\u0389\u00c8"+ - "\3\2\2\2\u038a\u038b\7\177\2\2\u038b\u00ca\3\2\2\2\u038c\u038d\7]\2\2"+ - "\u038d\u00cc\3\2\2\2\u038e\u038f\7_\2\2\u038f\u00ce\3\2\2\2\u0390\u0391"+ - "\7=\2\2\u0391\u00d0\3\2\2\2\u0392\u0393\7.\2\2\u0393\u00d2\3\2\2\2\u0394"+ - "\u0395\7\60\2\2\u0395\u00d4\3\2\2\2\u0396\u0397\7?\2\2\u0397\u00d6\3\2"+ - "\2\2\u0398\u0399\7@\2\2\u0399\u00d8\3\2\2\2\u039a\u039b\7>\2\2\u039b\u00da"+ - "\3\2\2\2\u039c\u039d\7#\2\2\u039d\u00dc\3\2\2\2\u039e\u039f\7\u0080\2"+ - "\2\u039f\u00de\3\2\2\2\u03a0\u03a1\7A\2\2\u03a1\u00e0\3\2\2\2\u03a2\u03a3"+ - "\7<\2\2\u03a3\u00e2\3\2\2\2\u03a4\u03a5\7?\2\2\u03a5\u03a6\7?\2\2\u03a6"+ - "\u00e4\3\2\2\2\u03a7\u03a8\7>\2\2\u03a8\u03a9\7?\2\2\u03a9\u00e6\3\2\2"+ - "\2\u03aa\u03ab\7@\2\2\u03ab\u03ac\7?\2\2\u03ac\u00e8\3\2\2\2\u03ad\u03ae"+ - "\7#\2\2\u03ae\u03af\7?\2\2\u03af\u00ea\3\2\2\2\u03b0\u03b1\7(\2\2\u03b1"+ - "\u03b2\7(\2\2\u03b2\u00ec\3\2\2\2\u03b3\u03b4\7~\2\2\u03b4\u03b5\7~\2"+ - "\2\u03b5\u00ee\3\2\2\2\u03b6\u03b7\7-\2\2\u03b7\u03b8\7-\2\2\u03b8\u00f0"+ - "\3\2\2\2\u03b9\u03ba\7/\2\2\u03ba\u03bb\7/\2\2\u03bb\u00f2\3\2\2\2\u03bc"+ - "\u03bd\7-\2\2\u03bd\u00f4\3\2\2\2\u03be\u03bf\7/\2\2\u03bf\u00f6\3\2\2"+ - "\2\u03c0\u03c1\7,\2\2\u03c1\u00f8\3\2\2\2\u03c2\u03c3\7\61\2\2\u03c3\u00fa"+ - "\3\2\2\2\u03c4\u03c5\7(\2\2\u03c5\u00fc\3\2\2\2\u03c6\u03c7\7~\2\2\u03c7"+ - "\u00fe\3\2\2\2\u03c8\u03c9\7`\2\2\u03c9\u0100\3\2\2\2\u03ca\u03cb\7\'"+ - "\2\2\u03cb\u0102\3\2\2\2\u03cc\u03cd\7-\2\2\u03cd\u03ce\7?\2\2\u03ce\u0104"+ - "\3\2\2\2\u03cf\u03d0\7/\2\2\u03d0\u03d1\7?\2\2\u03d1\u0106\3\2\2\2\u03d2"+ - "\u03d3\7,\2\2\u03d3\u03d4\7?\2\2\u03d4\u0108\3\2\2\2\u03d5\u03d6\7\61"+ - "\2\2\u03d6\u03d7\7?\2\2\u03d7\u010a\3\2\2\2\u03d8\u03d9\7(\2\2\u03d9\u03da"+ - "\7?\2\2\u03da\u010c\3\2\2\2\u03db\u03dc\7~\2\2\u03dc\u03dd\7?\2\2\u03dd"+ - "\u010e\3\2\2\2\u03de\u03df\7`\2\2\u03df\u03e0\7?\2\2\u03e0\u0110\3\2\2"+ - "\2\u03e1\u03e2\7\'\2\2\u03e2\u03e3\7?\2\2\u03e3\u0112\3\2\2\2\u03e4\u03e5"+ - "\7>\2\2\u03e5\u03e6\7>\2\2\u03e6\u03e7\7?\2\2\u03e7\u0114\3\2\2\2\u03e8"+ - "\u03e9\7@\2\2\u03e9\u03ea\7@\2\2\u03ea\u03eb\7?\2\2\u03eb\u0116\3\2\2"+ - "\2\u03ec\u03ed\7@\2\2\u03ed\u03ee\7@\2\2\u03ee\u03ef\7@\2\2\u03ef\u03f0"+ - "\7?\2\2\u03f0\u0118\3\2\2\2\u03f1\u03f5\5\u011b\u008e\2\u03f2\u03f4\5"+ - "\u011d\u008f\2\u03f3\u03f2\3\2\2\2\u03f4\u03f7\3\2\2\2\u03f5\u03f3\3\2"+ - "\2\2\u03f5\u03f6\3\2\2\2\u03f6\u011a\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f8"+ - "\u03ff\t\21\2\2\u03f9\u03fa\n\22\2\2\u03fa\u03ff\6\u008e\2\2\u03fb\u03fc"+ - "\t\23\2\2\u03fc\u03fd\t\24\2\2\u03fd\u03ff\6\u008e\3\2\u03fe\u03f8\3\2"+ - "\2\2\u03fe\u03f9\3\2\2\2\u03fe\u03fb\3\2\2\2\u03ff\u011c\3\2\2\2\u0400"+ - "\u0407\t\25\2\2\u0401\u0402\n\22\2\2\u0402\u0407\6\u008f\4\2\u0403\u0404"+ - "\t\23\2\2\u0404\u0405\t\24\2\2\u0405\u0407\6\u008f\5\2\u0406\u0400\3\2"+ - "\2\2\u0406\u0401\3\2\2\2\u0406\u0403\3\2\2\2\u0407\u011e\3\2\2\2\u0408"+ - "\u0409\7B\2\2\u0409\u0120\3\2\2\2\u040a\u040b\7\60\2\2\u040b\u040c\7\60"+ - "\2\2\u040c\u040d\7\60\2\2\u040d\u0122\3\2\2\2\u040e\u0410\t\26\2\2\u040f"+ - "\u040e\3\2\2\2\u0410\u0411\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2"+ - "\2\2\u0412\u0413\3\2\2\2\u0413\u0414\b\u0092\2\2\u0414\u0124\3\2\2\2\u0415"+ - "\u0416\7\61\2\2\u0416\u0417\7,\2\2\u0417\u041b\3\2\2\2\u0418\u041a\13"+ - "\2\2\2\u0419\u0418\3\2\2\2\u041a\u041d\3\2\2\2\u041b\u041c\3\2\2\2\u041b"+ - "\u0419\3\2\2\2\u041c\u041e\3\2\2\2\u041d\u041b\3\2\2\2\u041e\u041f\7,"+ - "\2\2\u041f\u0420\7\61\2\2\u0420\u0421\3\2\2\2\u0421\u0422\b\u0093\3\2"+ - "\u0422\u0126\3\2\2\2\u0423\u0424\7\61\2\2\u0424\u0425\7\61\2\2\u0425\u0429"+ - "\3\2\2\2\u0426\u0428\n\27\2\2\u0427\u0426\3\2\2\2\u0428\u042b\3\2\2\2"+ - "\u0429\u0427\3\2\2\2\u0429\u042a\3\2\2\2\u042a\u042c\3\2\2\2\u042b\u0429"+ - "\3\2\2\2\u042c\u042d\b\u0094\4\2\u042d\u0128\3\2\2\2\64\2\u0280\u0284"+ - "\u0288\u028c\u0290\u0297\u029c\u029e\u02a4\u02a8\u02ac\u02b2\u02b7\u02c1"+ - "\u02c5\u02cb\u02cf\u02d7\u02db\u02e1\u02eb\u02ef\u02f5\u02f9\u02fe\u0301"+ - "\u0304\u0309\u030c\u0311\u0316\u031e\u0329\u032d\u0332\u0336\u0346\u0350"+ - "\u0356\u035d\u0361\u0367\u0374\u03f5\u03fe\u0406\u0411\u041b\u0429"; - public static final ATN _ATN = - ATNSimulator.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); - } - } -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java deleted file mode 100644 index fdbf3a1..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java +++ /dev/null @@ -1,1145 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.ParseTreeListener; - -/** - * This interface defines a complete listener for a parse tree produced by - * {@link JavaParser}. - */ -public interface JavaListener extends ParseTreeListener { - /** - * Enter a parse tree produced by {@link JavaParser#innerCreator}. - * @param ctx the parse tree - */ - void enterInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#innerCreator}. - * @param ctx the parse tree - */ - void exitInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#genericMethodDeclaration}. - * @param ctx the parse tree - */ - void enterGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#genericMethodDeclaration}. - * @param ctx the parse tree - */ - void exitGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#expressionList}. - * @param ctx the parse tree - */ - void enterExpressionList(@NotNull JavaParser.ExpressionListContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#expressionList}. - * @param ctx the parse tree - */ - void exitExpressionList(@NotNull JavaParser.ExpressionListContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeDeclaration}. - * @param ctx the parse tree - */ - void enterTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeDeclaration}. - * @param ctx the parse tree - */ - void exitTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#forUpdate}. - * @param ctx the parse tree - */ - void enterForUpdate(@NotNull JavaParser.ForUpdateContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#forUpdate}. - * @param ctx the parse tree - */ - void exitForUpdate(@NotNull JavaParser.ForUpdateContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotation}. - * @param ctx the parse tree - */ - void enterAnnotation(@NotNull JavaParser.AnnotationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotation}. - * @param ctx the parse tree - */ - void exitAnnotation(@NotNull JavaParser.AnnotationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enumConstant}. - * @param ctx the parse tree - */ - void enterEnumConstant(@NotNull JavaParser.EnumConstantContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enumConstant}. - * @param ctx the parse tree - */ - void exitEnumConstant(@NotNull JavaParser.EnumConstantContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#importDeclaration}. - * @param ctx the parse tree - */ - void enterImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#importDeclaration}. - * @param ctx the parse tree - */ - void exitImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. - * @param ctx the parse tree - */ - void enterAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. - * @param ctx the parse tree - */ - void exitAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enumConstantName}. - * @param ctx the parse tree - */ - void enterEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enumConstantName}. - * @param ctx the parse tree - */ - void exitEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#finallyBlock}. - * @param ctx the parse tree - */ - void enterFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#finallyBlock}. - * @param ctx the parse tree - */ - void exitFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#variableDeclarators}. - * @param ctx the parse tree - */ - void enterVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#variableDeclarators}. - * @param ctx the parse tree - */ - void exitVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#elementValuePairs}. - * @param ctx the parse tree - */ - void enterElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#elementValuePairs}. - * @param ctx the parse tree - */ - void exitElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. - * @param ctx the parse tree - */ - void enterInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. - * @param ctx the parse tree - */ - void exitInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. - * @param ctx the parse tree - */ - void enterInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. - * @param ctx the parse tree - */ - void exitInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enumConstants}. - * @param ctx the parse tree - */ - void enterEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enumConstants}. - * @param ctx the parse tree - */ - void exitEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#catchClause}. - * @param ctx the parse tree - */ - void enterCatchClause(@NotNull JavaParser.CatchClauseContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#catchClause}. - * @param ctx the parse tree - */ - void exitCatchClause(@NotNull JavaParser.CatchClauseContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#constantExpression}. - * @param ctx the parse tree - */ - void enterConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#constantExpression}. - * @param ctx the parse tree - */ - void exitConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enumDeclaration}. - * @param ctx the parse tree - */ - void enterEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enumDeclaration}. - * @param ctx the parse tree - */ - void exitEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. - * @param ctx the parse tree - */ - void enterExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. - * @param ctx the parse tree - */ - void exitExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeParameter}. - * @param ctx the parse tree - */ - void enterTypeParameter(@NotNull JavaParser.TypeParameterContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeParameter}. - * @param ctx the parse tree - */ - void exitTypeParameter(@NotNull JavaParser.TypeParameterContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enumBodyDeclarations}. - * @param ctx the parse tree - */ - void enterEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enumBodyDeclarations}. - * @param ctx the parse tree - */ - void exitEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeBound}. - * @param ctx the parse tree - */ - void enterTypeBound(@NotNull JavaParser.TypeBoundContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeBound}. - * @param ctx the parse tree - */ - void exitTypeBound(@NotNull JavaParser.TypeBoundContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#statementExpression}. - * @param ctx the parse tree - */ - void enterStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#statementExpression}. - * @param ctx the parse tree - */ - void exitStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#variableInitializer}. - * @param ctx the parse tree - */ - void enterVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#variableInitializer}. - * @param ctx the parse tree - */ - void exitVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#block}. - * @param ctx the parse tree - */ - void enterBlock(@NotNull JavaParser.BlockContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#block}. - * @param ctx the parse tree - */ - void exitBlock(@NotNull JavaParser.BlockContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. - * @param ctx the parse tree - */ - void enterGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. - * @param ctx the parse tree - */ - void exitGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#localVariableDeclarationStatement}. - * @param ctx the parse tree - */ - void enterLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#localVariableDeclarationStatement}. - * @param ctx the parse tree - */ - void exitLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#superSuffix}. - * @param ctx the parse tree - */ - void enterSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#superSuffix}. - * @param ctx the parse tree - */ - void exitSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#fieldDeclaration}. - * @param ctx the parse tree - */ - void enterFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#fieldDeclaration}. - * @param ctx the parse tree - */ - void exitFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#formalParameterList}. - * @param ctx the parse tree - */ - void enterFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#formalParameterList}. - * @param ctx the parse tree - */ - void exitFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#explicitGenericInvocation}. - * @param ctx the parse tree - */ - void enterExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#explicitGenericInvocation}. - * @param ctx the parse tree - */ - void exitExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#parExpression}. - * @param ctx the parse tree - */ - void enterParExpression(@NotNull JavaParser.ParExpressionContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#parExpression}. - * @param ctx the parse tree - */ - void exitParExpression(@NotNull JavaParser.ParExpressionContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#switchLabel}. - * @param ctx the parse tree - */ - void enterSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#switchLabel}. - * @param ctx the parse tree - */ - void exitSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeParameters}. - * @param ctx the parse tree - */ - void enterTypeParameters(@NotNull JavaParser.TypeParametersContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeParameters}. - * @param ctx the parse tree - */ - void exitTypeParameters(@NotNull JavaParser.TypeParametersContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#qualifiedName}. - * @param ctx the parse tree - */ - void enterQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#qualifiedName}. - * @param ctx the parse tree - */ - void exitQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classDeclaration}. - * @param ctx the parse tree - */ - void enterClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classDeclaration}. - * @param ctx the parse tree - */ - void exitClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationConstantRest}. - * @param ctx the parse tree - */ - void enterAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationConstantRest}. - * @param ctx the parse tree - */ - void exitAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#arguments}. - * @param ctx the parse tree - */ - void enterArguments(@NotNull JavaParser.ArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#arguments}. - * @param ctx the parse tree - */ - void exitArguments(@NotNull JavaParser.ArgumentsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#constructorBody}. - * @param ctx the parse tree - */ - void enterConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#constructorBody}. - * @param ctx the parse tree - */ - void exitConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#formalParameters}. - * @param ctx the parse tree - */ - void enterFormalParameters(@NotNull JavaParser.FormalParametersContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#formalParameters}. - * @param ctx the parse tree - */ - void exitFormalParameters(@NotNull JavaParser.FormalParametersContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeArgument}. - * @param ctx the parse tree - */ - void enterTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeArgument}. - * @param ctx the parse tree - */ - void exitTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#forInit}. - * @param ctx the parse tree - */ - void enterForInit(@NotNull JavaParser.ForInitContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#forInit}. - * @param ctx the parse tree - */ - void exitForInit(@NotNull JavaParser.ForInitContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#variableDeclarator}. - * @param ctx the parse tree - */ - void enterVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#variableDeclarator}. - * @param ctx the parse tree - */ - void exitVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. - * @param ctx the parse tree - */ - void enterAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. - * @param ctx the parse tree - */ - void exitAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#expression}. - * @param ctx the parse tree - */ - void enterExpression(@NotNull JavaParser.ExpressionContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#expression}. - * @param ctx the parse tree - */ - void exitExpression(@NotNull JavaParser.ExpressionContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#resources}. - * @param ctx the parse tree - */ - void enterResources(@NotNull JavaParser.ResourcesContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#resources}. - * @param ctx the parse tree - */ - void exitResources(@NotNull JavaParser.ResourcesContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#formalParameter}. - * @param ctx the parse tree - */ - void enterFormalParameter(@NotNull JavaParser.FormalParameterContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#formalParameter}. - * @param ctx the parse tree - */ - void exitFormalParameter(@NotNull JavaParser.FormalParameterContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#type}. - * @param ctx the parse tree - */ - void enterType(@NotNull JavaParser.TypeContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#type}. - * @param ctx the parse tree - */ - void exitType(@NotNull JavaParser.TypeContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. - * @param ctx the parse tree - */ - void enterElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. - * @param ctx the parse tree - */ - void exitElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationName}. - * @param ctx the parse tree - */ - void enterAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationName}. - * @param ctx the parse tree - */ - void exitAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#enhancedForControl}. - * @param ctx the parse tree - */ - void enterEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#enhancedForControl}. - * @param ctx the parse tree - */ - void exitEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationMethodRest}. - * @param ctx the parse tree - */ - void enterAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationMethodRest}. - * @param ctx the parse tree - */ - void exitAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#primary}. - * @param ctx the parse tree - */ - void enterPrimary(@NotNull JavaParser.PrimaryContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#primary}. - * @param ctx the parse tree - */ - void exitPrimary(@NotNull JavaParser.PrimaryContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classBody}. - * @param ctx the parse tree - */ - void enterClassBody(@NotNull JavaParser.ClassBodyContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classBody}. - * @param ctx the parse tree - */ - void exitClassBody(@NotNull JavaParser.ClassBodyContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. - * @param ctx the parse tree - */ - void enterClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. - * @param ctx the parse tree - */ - void exitClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#defaultValue}. - * @param ctx the parse tree - */ - void enterDefaultValue(@NotNull JavaParser.DefaultValueContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#defaultValue}. - * @param ctx the parse tree - */ - void exitDefaultValue(@NotNull JavaParser.DefaultValueContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#variableModifier}. - * @param ctx the parse tree - */ - void enterVariableModifier(@NotNull JavaParser.VariableModifierContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#variableModifier}. - * @param ctx the parse tree - */ - void exitVariableModifier(@NotNull JavaParser.VariableModifierContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#constDeclaration}. - * @param ctx the parse tree - */ - void enterConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#constDeclaration}. - * @param ctx the parse tree - */ - void exitConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#createdName}. - * @param ctx the parse tree - */ - void enterCreatedName(@NotNull JavaParser.CreatedNameContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#createdName}. - * @param ctx the parse tree - */ - void exitCreatedName(@NotNull JavaParser.CreatedNameContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#interfaceDeclaration}. - * @param ctx the parse tree - */ - void enterInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#interfaceDeclaration}. - * @param ctx the parse tree - */ - void exitInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#packageDeclaration}. - * @param ctx the parse tree - */ - void enterPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#packageDeclaration}. - * @param ctx the parse tree - */ - void exitPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#constantDeclarator}. - * @param ctx the parse tree - */ - void enterConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#constantDeclarator}. - * @param ctx the parse tree - */ - void exitConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#catchType}. - * @param ctx the parse tree - */ - void enterCatchType(@NotNull JavaParser.CatchTypeContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#catchType}. - * @param ctx the parse tree - */ - void exitCatchType(@NotNull JavaParser.CatchTypeContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeArguments}. - * @param ctx the parse tree - */ - void enterTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeArguments}. - * @param ctx the parse tree - */ - void exitTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classCreatorRest}. - * @param ctx the parse tree - */ - void enterClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classCreatorRest}. - * @param ctx the parse tree - */ - void exitClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#modifier}. - * @param ctx the parse tree - */ - void enterModifier(@NotNull JavaParser.ModifierContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#modifier}. - * @param ctx the parse tree - */ - void exitModifier(@NotNull JavaParser.ModifierContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#statement}. - * @param ctx the parse tree - */ - void enterStatement(@NotNull JavaParser.StatementContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#statement}. - * @param ctx the parse tree - */ - void exitStatement(@NotNull JavaParser.StatementContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#interfaceBody}. - * @param ctx the parse tree - */ - void enterInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#interfaceBody}. - * @param ctx the parse tree - */ - void exitInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classBodyDeclaration}. - * @param ctx the parse tree - */ - void enterClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classBodyDeclaration}. - * @param ctx the parse tree - */ - void exitClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#lastFormalParameter}. - * @param ctx the parse tree - */ - void enterLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#lastFormalParameter}. - * @param ctx the parse tree - */ - void exitLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#forControl}. - * @param ctx the parse tree - */ - void enterForControl(@NotNull JavaParser.ForControlContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#forControl}. - * @param ctx the parse tree - */ - void exitForControl(@NotNull JavaParser.ForControlContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeList}. - * @param ctx the parse tree - */ - void enterTypeList(@NotNull JavaParser.TypeListContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeList}. - * @param ctx the parse tree - */ - void exitTypeList(@NotNull JavaParser.TypeListContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#localVariableDeclaration}. - * @param ctx the parse tree - */ - void enterLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#localVariableDeclaration}. - * @param ctx the parse tree - */ - void exitLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#variableDeclaratorId}. - * @param ctx the parse tree - */ - void enterVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#variableDeclaratorId}. - * @param ctx the parse tree - */ - void exitVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#compilationUnit}. - * @param ctx the parse tree - */ - void enterCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#compilationUnit}. - * @param ctx the parse tree - */ - void exitCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#elementValue}. - * @param ctx the parse tree - */ - void enterElementValue(@NotNull JavaParser.ElementValueContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#elementValue}. - * @param ctx the parse tree - */ - void exitElementValue(@NotNull JavaParser.ElementValueContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#classOrInterfaceType}. - * @param ctx the parse tree - */ - void enterClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#classOrInterfaceType}. - * @param ctx the parse tree - */ - void exitClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. - * @param ctx the parse tree - */ - void enterTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. - * @param ctx the parse tree - */ - void exitTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. - * @param ctx the parse tree - */ - void enterAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. - * @param ctx the parse tree - */ - void exitAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#blockStatement}. - * @param ctx the parse tree - */ - void enterBlockStatement(@NotNull JavaParser.BlockStatementContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#blockStatement}. - * @param ctx the parse tree - */ - void exitBlockStatement(@NotNull JavaParser.BlockStatementContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationTypeBody}. - * @param ctx the parse tree - */ - void enterAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationTypeBody}. - * @param ctx the parse tree - */ - void exitAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#qualifiedNameList}. - * @param ctx the parse tree - */ - void enterQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#qualifiedNameList}. - * @param ctx the parse tree - */ - void exitQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#creator}. - * @param ctx the parse tree - */ - void enterCreator(@NotNull JavaParser.CreatorContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#creator}. - * @param ctx the parse tree - */ - void exitCreator(@NotNull JavaParser.CreatorContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#memberDeclaration}. - * @param ctx the parse tree - */ - void enterMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#memberDeclaration}. - * @param ctx the parse tree - */ - void exitMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#methodDeclaration}. - * @param ctx the parse tree - */ - void enterMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#methodDeclaration}. - * @param ctx the parse tree - */ - void exitMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#annotationTypeElementRest}. - * @param ctx the parse tree - */ - void enterAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#annotationTypeElementRest}. - * @param ctx the parse tree - */ - void exitAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#resourceSpecification}. - * @param ctx the parse tree - */ - void enterResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#resourceSpecification}. - * @param ctx the parse tree - */ - void exitResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#constructorDeclaration}. - * @param ctx the parse tree - */ - void enterConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#constructorDeclaration}. - * @param ctx the parse tree - */ - void exitConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#resource}. - * @param ctx the parse tree - */ - void enterResource(@NotNull JavaParser.ResourceContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#resource}. - * @param ctx the parse tree - */ - void exitResource(@NotNull JavaParser.ResourceContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#elementValuePair}. - * @param ctx the parse tree - */ - void enterElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#elementValuePair}. - * @param ctx the parse tree - */ - void exitElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#methodBody}. - * @param ctx the parse tree - */ - void enterMethodBody(@NotNull JavaParser.MethodBodyContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#methodBody}. - * @param ctx the parse tree - */ - void exitMethodBody(@NotNull JavaParser.MethodBodyContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#arrayInitializer}. - * @param ctx the parse tree - */ - void enterArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#arrayInitializer}. - * @param ctx the parse tree - */ - void exitArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. - * @param ctx the parse tree - */ - void enterNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. - * @param ctx the parse tree - */ - void exitNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#primitiveType}. - * @param ctx the parse tree - */ - void enterPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#primitiveType}. - * @param ctx the parse tree - */ - void exitPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. - * @param ctx the parse tree - */ - void enterNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. - * @param ctx the parse tree - */ - void exitNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#arrayCreatorRest}. - * @param ctx the parse tree - */ - void enterArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#arrayCreatorRest}. - * @param ctx the parse tree - */ - void exitArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. - * @param ctx the parse tree - */ - void enterInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. - * @param ctx the parse tree - */ - void exitInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. - * @param ctx the parse tree - */ - void enterGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. - * @param ctx the parse tree - */ - void exitGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#literal}. - * @param ctx the parse tree - */ - void enterLiteral(@NotNull JavaParser.LiteralContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#literal}. - * @param ctx the parse tree - */ - void exitLiteral(@NotNull JavaParser.LiteralContext ctx); - - /** - * Enter a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. - * @param ctx the parse tree - */ - void enterSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx); - /** - * Exit a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. - * @param ctx the parse tree - */ - void exitSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx); -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java deleted file mode 100644 index 5eea998..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java +++ /dev/null @@ -1,8384 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -import org.antlr.v4.runtime.atn.*; -import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.*; -import org.antlr.v4.runtime.misc.*; -import org.antlr.v4.runtime.tree.*; -import java.util.List; -import java.util.Iterator; -import java.util.ArrayList; - -@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) -public class JavaParser extends Parser { - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, - CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, - ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, - IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, - NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, - SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, - THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, - WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, - CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, - LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, - ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, - LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, - MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, ADD_ASSIGN=89, - SUB_ASSIGN=90, MUL_ASSIGN=91, DIV_ASSIGN=92, AND_ASSIGN=93, OR_ASSIGN=94, - XOR_ASSIGN=95, MOD_ASSIGN=96, LSHIFT_ASSIGN=97, RSHIFT_ASSIGN=98, URSHIFT_ASSIGN=99, - Identifier=100, AT=101, ELLIPSIS=102, WS=103, COMMENT=104, LINE_COMMENT=105; - public static final String[] tokenNames = { - "<INVALID>", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", - "'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", - "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", - "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", - "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", - "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", - "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", - "'transient'", "'try'", "'void'", "'volatile'", "'while'", "IntegerLiteral", - "FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", - "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", - "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", - "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", - "'|'", "'^'", "'%'", "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", - "'%='", "'<<='", "'>>='", "'>>>='", "Identifier", "'@'", "'...'", "WS", - "COMMENT", "LINE_COMMENT" - }; - public static final int - RULE_compilationUnit = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2, - RULE_typeDeclaration = 3, RULE_modifier = 4, RULE_classOrInterfaceModifier = 5, - RULE_variableModifier = 6, RULE_classDeclaration = 7, RULE_typeParameters = 8, - RULE_typeParameter = 9, RULE_typeBound = 10, RULE_enumDeclaration = 11, - RULE_enumConstants = 12, RULE_enumConstant = 13, RULE_enumBodyDeclarations = 14, - RULE_interfaceDeclaration = 15, RULE_typeList = 16, RULE_classBody = 17, - RULE_interfaceBody = 18, RULE_classBodyDeclaration = 19, RULE_memberDeclaration = 20, - RULE_methodDeclaration = 21, RULE_genericMethodDeclaration = 22, RULE_constructorDeclaration = 23, - RULE_genericConstructorDeclaration = 24, RULE_fieldDeclaration = 25, RULE_interfaceBodyDeclaration = 26, - RULE_interfaceMemberDeclaration = 27, RULE_constDeclaration = 28, RULE_constantDeclarator = 29, - RULE_interfaceMethodDeclaration = 30, RULE_genericInterfaceMethodDeclaration = 31, - RULE_variableDeclarators = 32, RULE_variableDeclarator = 33, RULE_variableDeclaratorId = 34, - RULE_variableInitializer = 35, RULE_arrayInitializer = 36, RULE_enumConstantName = 37, - RULE_type = 38, RULE_classOrInterfaceType = 39, RULE_primitiveType = 40, - RULE_typeArguments = 41, RULE_typeArgument = 42, RULE_qualifiedNameList = 43, - RULE_formalParameters = 44, RULE_formalParameterList = 45, RULE_formalParameter = 46, - RULE_lastFormalParameter = 47, RULE_methodBody = 48, RULE_constructorBody = 49, - RULE_qualifiedName = 50, RULE_literal = 51, RULE_annotation = 52, RULE_annotationName = 53, - RULE_elementValuePairs = 54, RULE_elementValuePair = 55, RULE_elementValue = 56, - RULE_elementValueArrayInitializer = 57, RULE_annotationTypeDeclaration = 58, - RULE_annotationTypeBody = 59, RULE_annotationTypeElementDeclaration = 60, - RULE_annotationTypeElementRest = 61, RULE_annotationMethodOrConstantRest = 62, - RULE_annotationMethodRest = 63, RULE_annotationConstantRest = 64, RULE_defaultValue = 65, - RULE_block = 66, RULE_blockStatement = 67, RULE_localVariableDeclarationStatement = 68, - RULE_localVariableDeclaration = 69, RULE_statement = 70, RULE_catchClause = 71, - RULE_catchType = 72, RULE_finallyBlock = 73, RULE_resourceSpecification = 74, - RULE_resources = 75, RULE_resource = 76, RULE_switchBlockStatementGroup = 77, - RULE_switchLabel = 78, RULE_forControl = 79, RULE_forInit = 80, RULE_enhancedForControl = 81, - RULE_forUpdate = 82, RULE_parExpression = 83, RULE_expressionList = 84, - RULE_statementExpression = 85, RULE_constantExpression = 86, RULE_expression = 87, - RULE_primary = 88, RULE_creator = 89, RULE_createdName = 90, RULE_innerCreator = 91, - RULE_arrayCreatorRest = 92, RULE_classCreatorRest = 93, RULE_explicitGenericInvocation = 94, - RULE_nonWildcardTypeArguments = 95, RULE_typeArgumentsOrDiamond = 96, - RULE_nonWildcardTypeArgumentsOrDiamond = 97, RULE_superSuffix = 98, RULE_explicitGenericInvocationSuffix = 99, - RULE_arguments = 100; - public static final String[] ruleNames = { - "compilationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration", - "modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration", - "typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants", - "enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "typeList", - "classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration", - "methodDeclaration", "genericMethodDeclaration", "constructorDeclaration", - "genericConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", - "interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", - "interfaceMethodDeclaration", "genericInterfaceMethodDeclaration", "variableDeclarators", - "variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer", - "enumConstantName", "type", "classOrInterfaceType", "primitiveType", "typeArguments", - "typeArgument", "qualifiedNameList", "formalParameters", "formalParameterList", - "formalParameter", "lastFormalParameter", "methodBody", "constructorBody", - "qualifiedName", "literal", "annotation", "annotationName", "elementValuePairs", - "elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration", - "annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest", - "annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest", - "defaultValue", "block", "blockStatement", "localVariableDeclarationStatement", - "localVariableDeclaration", "statement", "catchClause", "catchType", "finallyBlock", - "resourceSpecification", "resources", "resource", "switchBlockStatementGroup", - "switchLabel", "forControl", "forInit", "enhancedForControl", "forUpdate", - "parExpression", "expressionList", "statementExpression", "constantExpression", - "expression", "primary", "creator", "createdName", "innerCreator", "arrayCreatorRest", - "classCreatorRest", "explicitGenericInvocation", "nonWildcardTypeArguments", - "typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "superSuffix", - "explicitGenericInvocationSuffix", "arguments" - }; - - @Override - public String getGrammarFileName() { return "Java.g4"; } - - @Override - public String[] getTokenNames() { return tokenNames; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public ATN getATN() { return _ATN; } - - public JavaParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - public static class CompilationUnitContext extends ParserRuleContext { - public List<ImportDeclarationContext> importDeclaration() { - return getRuleContexts(ImportDeclarationContext.class); - } - public TerminalNode EOF() { return getToken(JavaParser.EOF, 0); } - public PackageDeclarationContext packageDeclaration() { - return getRuleContext(PackageDeclarationContext.class,0); - } - public ImportDeclarationContext importDeclaration(int i) { - return getRuleContext(ImportDeclarationContext.class,i); - } - public List<TypeDeclarationContext> typeDeclaration() { - return getRuleContexts(TypeDeclarationContext.class); - } - public TypeDeclarationContext typeDeclaration(int i) { - return getRuleContext(TypeDeclarationContext.class,i); - } - public CompilationUnitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_compilationUnit; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterCompilationUnit(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitCompilationUnit(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitCompilationUnit(this); - else return visitor.visitChildren(this); - } - } - - public final CompilationUnitContext compilationUnit() throws RecognitionException { - CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_compilationUnit); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(203); - switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { - case 1: - { - setState(202); packageDeclaration(); - } - break; - } - setState(208); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==IMPORT) { - { - { - setState(205); importDeclaration(); - } - } - setState(210); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(214); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SEMI))) != 0) || _la==AT) { - { - { - setState(211); typeDeclaration(); - } - } - setState(216); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(217); match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PackageDeclarationContext extends ParserRuleContext { - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class,0); - } - public List<AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterPackageDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitPackageDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(222); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT) { - { - { - setState(219); annotation(); - } - } - setState(224); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(225); match(PACKAGE); - setState(226); qualifiedName(); - setState(227); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportDeclarationContext extends ParserRuleContext { - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class,0); - } - public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterImportDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitImportDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(229); match(IMPORT); - setState(231); - _la = _input.LA(1); - if (_la==STATIC) { - { - setState(230); match(STATIC); - } - } - - setState(233); qualifiedName(); - setState(236); - _la = _input.LA(1); - if (_la==DOT) { - { - setState(234); match(DOT); - setState(235); match(MUL); - } - } - - setState(238); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeDeclarationContext extends ParserRuleContext { - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class,0); - } - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class,0); - } - public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { - return getRuleContext(ClassOrInterfaceModifierContext.class,i); - } - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class,0); - } - public List<ClassOrInterfaceModifierContext> classOrInterfaceModifier() { - return getRuleContexts(ClassOrInterfaceModifierContext.class); - } - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class,0); - } - public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final TypeDeclarationContext typeDeclaration() throws RecognitionException { - TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_typeDeclaration); - int _la; - try { - int _alt; - setState(269); - switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(243); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { - { - { - setState(240); classOrInterfaceModifier(); - } - } - setState(245); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(246); classDeclaration(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(250); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { - { - { - setState(247); classOrInterfaceModifier(); - } - } - setState(252); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(253); enumDeclaration(); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(257); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) { - { - { - setState(254); classOrInterfaceModifier(); - } - } - setState(259); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(260); interfaceDeclaration(); - } - break; - - case 4: - enterOuterAlt(_localctx, 4); - { - setState(264); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,9,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(261); classOrInterfaceModifier(); - } - } - } - setState(266); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,9,_ctx); - } - setState(267); annotationTypeDeclaration(); - } - break; - - case 5: - enterOuterAlt(_localctx, 5); - { - setState(268); match(SEMI); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ModifierContext extends ParserRuleContext { - public ClassOrInterfaceModifierContext classOrInterfaceModifier() { - return getRuleContext(ClassOrInterfaceModifierContext.class,0); - } - public ModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitModifier(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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); - int _la; - try { - setState(273); - switch (_input.LA(1)) { - case ABSTRACT: - case FINAL: - case PRIVATE: - case PROTECTED: - case PUBLIC: - case STATIC: - case STRICTFP: - case AT: - enterOuterAlt(_localctx, 1); - { - setState(271); classOrInterfaceModifier(); - } - break; - case NATIVE: - case SYNCHRONIZED: - case TRANSIENT: - case VOLATILE: - enterOuterAlt(_localctx, 2); - { - setState(272); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NATIVE) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassOrInterfaceModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterClassOrInterfaceModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassOrInterfaceModifier(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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); - int _la; - try { - setState(277); - switch (_input.LA(1)) { - case AT: - enterOuterAlt(_localctx, 1); - { - setState(275); annotation(); - } - break; - case ABSTRACT: - case FINAL: - case PRIVATE: - case PROTECTED: - case PUBLIC: - case STATIC: - case STRICTFP: - enterOuterAlt(_localctx, 2); - { - setState(276); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public VariableModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterVariableModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableModifier(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitVariableModifier(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(281); - switch (_input.LA(1)) { - case FINAL: - enterOuterAlt(_localctx, 1); - { - setState(279); match(FINAL); - } - break; - case AT: - enterOuterAlt(_localctx, 2); - { - setState(280); annotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterClassDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(283); match(CLASS); - setState(284); match(Identifier); - setState(286); - _la = _input.LA(1); - if (_la==LT) { - { - setState(285); typeParameters(); - } - } - - setState(290); - _la = _input.LA(1); - if (_la==EXTENDS) { - { - setState(288); match(EXTENDS); - setState(289); type(); - } - } - - setState(294); - _la = _input.LA(1); - if (_la==IMPLEMENTS) { - { - setState(292); match(IMPLEMENTS); - setState(293); typeList(); - } - } - - setState(296); classBody(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParametersContext extends ParserRuleContext { - public List<TypeParameterContext> typeParameter() { - return getRuleContexts(TypeParameterContext.class); - } - public TypeParameterContext typeParameter(int i) { - return getRuleContext(TypeParameterContext.class,i); - } - public TypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeParameters(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeParameters(this); - else return visitor.visitChildren(this); - } - } - - public final TypeParametersContext typeParameters() throws RecognitionException { - TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_typeParameters); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(298); match(LT); - setState(299); typeParameter(); - setState(304); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(300); match(COMMA); - setState(301); typeParameter(); - } - } - setState(306); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(307); match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParameterContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeBoundContext typeBound() { - return getRuleContext(TypeBoundContext.class,0); - } - public TypeParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeParameter(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeParameter(this); - else return visitor.visitChildren(this); - } - } - - public final TypeParameterContext typeParameter() throws RecognitionException { - TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_typeParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(309); match(Identifier); - setState(312); - _la = _input.LA(1); - if (_la==EXTENDS) { - { - setState(310); match(EXTENDS); - setState(311); typeBound(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeBoundContext extends ParserRuleContext { - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List<TypeContext> type() { - return getRuleContexts(TypeContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterTypeBound(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeBound(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(314); type(); - setState(319); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==BITAND) { - { - { - setState(315); match(BITAND); - setState(316); type(); - } - } - setState(321); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumDeclarationContext extends ParserRuleContext { - public TerminalNode ENUM() { return getToken(JavaParser.ENUM, 0); } - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class,0); - } - public EnumConstantsContext enumConstants() { - return getRuleContext(EnumConstantsContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 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 JavaListener ) ((JavaListener)listener).enterEnumDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(322); match(ENUM); - setState(323); match(Identifier); - setState(326); - _la = _input.LA(1); - if (_la==IMPLEMENTS) { - { - setState(324); match(IMPLEMENTS); - setState(325); typeList(); - } - } - - setState(328); match(LBRACE); - setState(330); - _la = _input.LA(1); - if (_la==Identifier || _la==AT) { - { - setState(329); enumConstants(); - } - } - - setState(333); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(332); match(COMMA); - } - } - - setState(336); - _la = _input.LA(1); - if (_la==SEMI) { - { - setState(335); enumBodyDeclarations(); - } - } - - setState(338); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantsContext extends ParserRuleContext { - public List<EnumConstantContext> enumConstant() { - return getRuleContexts(EnumConstantContext.class); - } - public EnumConstantContext enumConstant(int i) { - return getRuleContext(EnumConstantContext.class,i); - } - public EnumConstantsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumConstants; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterEnumConstants(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumConstants(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(340); enumConstant(); - setState(345); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,24,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(341); match(COMMA); - setState(342); enumConstant(); - } - } - } - setState(347); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,24,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantContext extends ParserRuleContext { - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public List<AnnotationContext> annotation() { - return getRuleContexts(AnnotationContext.class); - } - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.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 JavaListener ) ((JavaListener)listener).enterEnumConstant(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumConstant(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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 { - enterOuterAlt(_localctx, 1); - { - setState(351); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT) { - { - { - setState(348); annotation(); - } - } - setState(353); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(354); match(Identifier); - setState(356); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(355); arguments(); - } - } - - setState(359); - _la = _input.LA(1); - if (_la==LBRACE) { - { - setState(358); classBody(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumBodyDeclarationsContext extends ParserRuleContext { - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class,i); - } - public List<ClassBodyDeclarationContext> classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterEnumBodyDeclarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumBodyDeclarations(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(361); match(SEMI); - setState(365); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] - { - { - setState(362); classBodyDeclaration(); - } - } - setState(367); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public InterfaceBodyContext interfaceBody() { - return getRuleContext(InterfaceBodyContext.class,0); - } - public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterInterfaceDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(368); match(INTERFACE); - setState(369); match(Identifier); - setState(371); - _la = _input.LA(1); - if (_la==LT) { - { - setState(370); typeParameters(); - } - } - - setState(375); - _la = _input.LA(1); - if (_la==EXTENDS) { - { - setState(373); match(EXTENDS); - setState(374); typeList(); - } - } - - setState(377); interfaceBody(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeListContext extends ParserRuleContext { - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List<TypeContext> type() { - return getRuleContexts(TypeContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterTypeList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeList(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeList(this); - else return visitor.visitChildren(this); - } - } - - public final TypeListContext typeList() throws RecognitionException { - TypeListContext _localctx = new TypeListContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_typeList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(379); type(); - setState(384); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(380); match(COMMA); - setState(381); type(); - } - } - setState(386); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyContext extends ParserRuleContext { - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class,i); - } - public List<ClassBodyDeclarationContext> classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterClassBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassBody(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitClassBody(this); - else return visitor.visitChildren(this); - } - } - - public final ClassBodyContext classBody() throws RecognitionException { - ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_classBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(387); match(LBRACE); - setState(391); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((( [...] - { - { - setState(388); classBodyDeclaration(); - } - } - setState(393); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(394); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceBodyContext extends ParserRuleContext { - public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { - return getRuleContext(InterfaceBodyDeclarationContext.class,i); - } - public List<InterfaceBodyDeclarationContext> interfaceBodyDeclaration() { - return getRuleContexts(InterfaceBodyDeclarationContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterInterfaceBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceBody(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitInterfaceBody(this); - else return visitor.visitChildren(this); - } - } - - public final InterfaceBodyContext interfaceBody() throws RecognitionException { - InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_interfaceBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(396); match(LBRACE); - setState(400); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x [...] - { - { - setState(397); interfaceBodyDeclaration(); - } - } - setState(402); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(403); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyDeclarationContext extends ParserRuleContext { - public MemberDeclarationContext memberDeclaration() { - return getRuleContext(MemberDeclarationContext.class,0); - } - public List<ModifierContext> modifier() { - return getRuleContexts(ModifierContext.class); - } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class,i); - } - public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterClassBodyDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassBodyDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitClassBodyDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { - ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_classBodyDeclaration); - int _la; - try { - int _alt; - setState(417); - switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(405); match(SEMI); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(407); - _la = _input.LA(1); - if (_la==STATIC) { - { - setState(406); match(STATIC); - } - } - - setState(409); block(); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(413); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,35,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(410); modifier(); - } - } - } - setState(415); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,35,_ctx); - } - setState(416); memberDeclaration(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MemberDeclarationContext extends ParserRuleContext { - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class,0); - } - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class,0); - } - public ConstructorDeclarationContext constructorDeclaration() { - return getRuleContext(ConstructorDeclarationContext.class,0); - } - public FieldDeclarationContext fieldDeclaration() { - return getRuleContext(FieldDeclarationContext.class,0); - } - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class,0); - } - public GenericMethodDeclarationContext genericMethodDeclaration() { - return getRuleContext(GenericMethodDeclarationContext.class,0); - } - public MethodDeclarationContext methodDeclaration() { - return getRuleContext(MethodDeclarationContext.class,0); - } - public GenericConstructorDeclarationContext genericConstructorDeclaration() { - return getRuleContext(GenericConstructorDeclarationContext.class,0); - } - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class,0); - } - public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_memberDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterMemberDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitMemberDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final MemberDeclarationContext memberDeclaration() throws RecognitionException { - MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_memberDeclaration); - try { - setState(428); - switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(419); methodDeclaration(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(420); genericMethodDeclaration(); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(421); fieldDeclaration(); - } - break; - - case 4: - enterOuterAlt(_localctx, 4); - { - setState(422); constructorDeclaration(); - } - break; - - case 5: - enterOuterAlt(_localctx, 5); - { - setState(423); genericConstructorDeclaration(); - } - break; - - case 6: - enterOuterAlt(_localctx, 6); - { - setState(424); interfaceDeclaration(); - } - break; - - case 7: - enterOuterAlt(_localctx, 7); - { - setState(425); annotationTypeDeclaration(); - } - break; - - case 8: - enterOuterAlt(_localctx, 8); - { - setState(426); classDeclaration(); - } - break; - - case 9: - enterOuterAlt(_localctx, 9); - { - setState(427); enumDeclaration(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MethodDeclarationContext extends ParserRuleContext { - public MethodBodyContext methodBody() { - return getRuleContext(MethodBodyContext.class,0); - } - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class,0); - } - public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_methodDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterMethodDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitMethodDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? 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(432); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - { - setState(430); type(); - } - break; - case VOID: - { - setState(431); match(VOID); - } - break; - default: - throw new NoViableAltException(this); - } - setState(434); match(Identifier); - setState(435); formalParameters(); - setState(440); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==LBRACK) { - { - { - setState(436); match(LBRACK); - setState(437); match(RBRACK); - } - } - setState(442); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(445); - _la = _input.LA(1); - if (_la==THROWS) { - { - setState(443); match(THROWS); - setState(444); qualifiedNameList(); - } - } - - setState(449); - switch (_input.LA(1)) { - case LBRACE: - { - setState(447); methodBody(); - } - break; - case SEMI: - { - setState(448); match(SEMI); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GenericMethodDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public MethodDeclarationContext methodDeclaration() { - return getRuleContext(MethodDeclarationContext.class,0); - } - public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_genericMethodDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterGenericMethodDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitGenericMethodDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitGenericMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException { - GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_genericMethodDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(451); typeParameters(); - setState(452); methodDeclaration(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorDeclarationContext extends ParserRuleContext { - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public ConstructorBodyContext constructorBody() { - return getRuleContext(ConstructorBodyContext.class,0); - } - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class,0); - } - public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterConstructorDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitConstructorDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitConstructorDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { - ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_constructorDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(454); match(Identifier); - setState(455); formalParameters(); - setState(458); - _la = _input.LA(1); - if (_la==THROWS) { - { - setState(456); match(THROWS); - setState(457); qualifiedNameList(); - } - } - - setState(460); constructorBody(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GenericConstructorDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ConstructorDeclarationContext constructorDeclaration() { - return getRuleContext(ConstructorDeclarationContext.class,0); - } - public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterGenericConstructorDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitGenericConstructorDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitGenericConstructorDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException { - GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_genericConstructorDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(462); typeParameters(); - setState(463); constructorDeclaration(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FieldDeclarationContext extends ParserRuleContext { - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.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 JavaListener ) ((JavaListener)listener).enterFieldDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitFieldDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitFieldDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { - FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_fieldDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(465); type(); - setState(466); variableDeclarators(); - setState(467); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceBodyDeclarationContext extends ParserRuleContext { - public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { - return getRuleContext(InterfaceMemberDeclarationContext.class,0); - } - public List<ModifierContext> modifier() { - return getRuleContexts(ModifierContext.class); - } - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class,i); - } - public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterInterfaceBodyDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceBodyDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitInterfaceBodyDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException { - InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_interfaceBodyDeclaration); - try { - int _alt; - setState(477); - switch (_input.LA(1)) { - case ABSTRACT: - case BOOLEAN: - case BYTE: - case CHAR: - case CLASS: - case DOUBLE: - case ENUM: - case FINAL: - case FLOAT: - case INT: - case INTERFACE: - case LONG: - case NATIVE: - case PRIVATE: - case PROTECTED: - case PUBLIC: - case SHORT: - case STATIC: - case STRICTFP: - case SYNCHRONIZED: - case TRANSIENT: - case VOID: - case VOLATILE: - case LT: - case Identifier: - case AT: - enterOuterAlt(_localctx, 1); - { - setState(472); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,43,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(469); modifier(); - } - } - } - setState(474); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,43,_ctx); - } - setState(475); interfaceMemberDeclaration(); - } - break; - case SEMI: - enterOuterAlt(_localctx, 2); - { - setState(476); match(SEMI); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceMemberDeclarationContext extends ParserRuleContext { - public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { - return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0); - } - public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { - return getRuleContext(InterfaceMethodDeclarationContext.class,0); - } - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class,0); - } - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class,0); - } - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class,0); - } - public ConstDeclarationContext constDeclaration() { - return getRuleContext(ConstDeclarationContext.class,0); - } - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class,0); - } - public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterInterfaceMemberDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceMemberDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitInterfaceMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { - InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_interfaceMemberDeclaration); - try { - setState(486); - switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(479); constDeclaration(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(480); interfaceMethodDeclaration(); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(481); genericInterfaceMethodDeclaration(); - } - break; - - case 4: - enterOuterAlt(_localctx, 4); - { - setState(482); interfaceDeclaration(); - } - break; - - case 5: - enterOuterAlt(_localctx, 5); - { - setState(483); annotationTypeDeclaration(); - } - break; - - case 6: - enterOuterAlt(_localctx, 6); - { - setState(484); classDeclaration(); - } - break; - - case 7: - enterOuterAlt(_localctx, 7); - { - setState(485); enumDeclaration(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstDeclarationContext extends ParserRuleContext { - public List<ConstantDeclaratorContext> constantDeclarator() { - return getRuleContexts(ConstantDeclaratorContext.class); - } - public ConstantDeclaratorContext constantDeclarator(int i) { - return getRuleContext(ConstantDeclaratorContext.class,i); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterConstDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitConstDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitConstDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final ConstDeclarationContext constDeclaration() throws RecognitionException { - ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_constDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(488); type(); - setState(489); constantDeclarator(); - setState(494); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(490); match(COMMA); - setState(491); constantDeclarator(); - } - } - setState(496); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(497); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstantDeclaratorContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public VariableInitializerContext variableInitializer() { - return getRuleContext(VariableInitializerContext.class,0); - } - public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constantDeclarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterConstantDeclarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitConstantDeclarator(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitConstantDeclarator(this); - else return visitor.visitChildren(this); - } - } - - public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException { - ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_constantDeclarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(499); match(Identifier); - setState(504); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==LBRACK) { - { - { - setState(500); match(LBRACK); - setState(501); match(RBRACK); - } - } - setState(506); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(507); match(ASSIGN); - setState(508); variableInitializer(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InterfaceMethodDeclarationContext extends ParserRuleContext { - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class,0); - } - public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterInterfaceMethodDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInterfaceMethodDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitInterfaceMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { - InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_interfaceMethodDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(512); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - { - setState(510); type(); - } - break; - case VOID: - { - setState(511); match(VOID); - } - break; - default: - throw new NoViableAltException(this); - } - setState(514); match(Identifier); - setState(515); formalParameters(); - setState(520); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==LBRACK) { - { - { - setState(516); match(LBRACK); - setState(517); match(RBRACK); - } - } - setState(522); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(525); - _la = _input.LA(1); - if (_la==THROWS) { - { - setState(523); match(THROWS); - setState(524); qualifiedNameList(); - } - } - - setState(527); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext { - public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { - return getRuleContext(InterfaceMethodDeclarationContext.class,0); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterGenericInterfaceMethodDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitGenericInterfaceMethodDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitGenericInterfaceMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException { - GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_genericInterfaceMethodDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(529); typeParameters(); - setState(530); interfaceMethodDeclaration(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorsContext extends ParserRuleContext { - public VariableDeclaratorContext variableDeclarator(int i) { - return getRuleContext(VariableDeclaratorContext.class,i); - } - public List<VariableDeclaratorContext> variableDeclarator() { - return getRuleContexts(VariableDeclaratorContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterVariableDeclarators(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableDeclarators(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitVariableDeclarators(this); - else return visitor.visitChildren(this); - } - } - - public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException { - VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_variableDeclarators); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(532); variableDeclarator(); - setState(537); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(533); match(COMMA); - setState(534); variableDeclarator(); - } - } - setState(539); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorContext extends ParserRuleContext { - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class,0); - } - public VariableInitializerContext variableInitializer() { - return getRuleContext(VariableInitializerContext.class,0); - } - public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableDeclarator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterVariableDeclarator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableDeclarator(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitVariableDeclarator(this); - else return visitor.visitChildren(this); - } - } - - public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { - VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_variableDeclarator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(540); variableDeclaratorId(); - setState(543); - _la = _input.LA(1); - if (_la==ASSIGN) { - { - setState(541); match(ASSIGN); - setState(542); variableInitializer(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableDeclaratorIdContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterVariableDeclaratorId(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableDeclaratorId(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitVariableDeclaratorId(this); - else return visitor.visitChildren(this); - } - } - - public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { - VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_variableDeclaratorId); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(545); match(Identifier); - setState(550); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==LBRACK) { - { - { - setState(546); match(LBRACK); - setState(547); match(RBRACK); - } - } - setState(552); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class VariableInitializerContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ArrayInitializerContext arrayInitializer() { - return getRuleContext(ArrayInitializerContext.class,0); - } - public VariableInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableInitializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterVariableInitializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitVariableInitializer(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitVariableInitializer(this); - else return visitor.visitChildren(this); - } - } - - public final VariableInitializerContext variableInitializer() throws RecognitionException { - VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_variableInitializer); - try { - setState(555); - switch (_input.LA(1)) { - case LBRACE: - enterOuterAlt(_localctx, 1); - { - setState(553); arrayInitializer(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case LT: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(554); expression(0); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayInitializerContext extends ParserRuleContext { - public VariableInitializerContext variableInitializer(int i) { - return getRuleContext(VariableInitializerContext.class,i); - } - public List<VariableInitializerContext> variableInitializer() { - return getRuleContexts(VariableInitializerContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterArrayInitializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitArrayInitializer(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - - public final ArrayInitializerContext arrayInitializer() throws RecognitionException { - ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_arrayInitializer); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(557); match(LBRACE); - setState(569); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << [...] - { - setState(558); variableInitializer(); - setState(563); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,55,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(559); match(COMMA); - setState(560); variableInitializer(); - } - } - } - setState(565); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,55,_ctx); - } - setState(567); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(566); match(COMMA); - } - } - - } - } - - setState(571); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumConstantNameContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public EnumConstantNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumConstantName; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterEnumConstantName(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnumConstantName(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitEnumConstantName(this); - else return visitor.visitChildren(this); - } - } - - public final EnumConstantNameContext enumConstantName() throws RecognitionException { - EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_enumConstantName); - try { - enterOuterAlt(_localctx, 1); - { - setState(573); match(Identifier); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeContext extends ParserRuleContext { - public PrimitiveTypeContext primitiveType() { - return getRuleContext(PrimitiveTypeContext.class,0); - } - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class,0); - } - public TypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitType(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitType(this); - else return visitor.visitChildren(this); - } - } - - public final TypeContext type() throws RecognitionException { - TypeContext _localctx = new TypeContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_type); - try { - int _alt; - setState(591); - switch (_input.LA(1)) { - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(575); classOrInterfaceType(); - setState(580); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,58,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(576); match(LBRACK); - setState(577); match(RBRACK); - } - } - } - setState(582); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,58,_ctx); - } - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - enterOuterAlt(_localctx, 2); - { - setState(583); primitiveType(); - setState(588); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,59,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(584); match(LBRACK); - setState(585); match(RBRACK); - } - } - } - setState(590); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,59,_ctx); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassOrInterfaceTypeContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments(int i) { - return getRuleContext(TypeArgumentsContext.class,i); - } - public TerminalNode Identifier(int i) { - return getToken(JavaParser.Identifier, i); - } - public List<TerminalNode> Identifier() { return getTokens(JavaParser.Identifier); } - public List<TypeArgumentsContext> typeArguments() { - return getRuleContexts(TypeArgumentsContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterClassOrInterfaceType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassOrInterfaceType(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - - public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { - ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_classOrInterfaceType); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(593); match(Identifier); - setState(595); - switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { - case 1: - { - setState(594); typeArguments(); - } - break; - } - setState(604); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,63,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(597); match(DOT); - setState(598); match(Identifier); - setState(600); - switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { - case 1: - { - setState(599); typeArguments(); - } - break; - } - } - } - } - setState(606); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,63,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrimitiveTypeContext extends ParserRuleContext { - public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primitiveType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterPrimitiveType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitPrimitiveType(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitPrimitiveType(this); - else return visitor.visitChildren(this); - } - } - - public final PrimitiveTypeContext primitiveType() throws RecognitionException { - PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_primitiveType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(607); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsContext extends ParserRuleContext { - public List<TypeArgumentContext> typeArgument() { - return getRuleContexts(TypeArgumentContext.class); - } - public TypeArgumentContext typeArgument(int i) { - return getRuleContext(TypeArgumentContext.class,i); - } - public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeArguments(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeArguments(this); - else return visitor.visitChildren(this); - } - } - - public final TypeArgumentsContext typeArguments() throws RecognitionException { - TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_typeArguments); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(609); match(LT); - setState(610); typeArgument(); - setState(615); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(611); match(COMMA); - setState(612); typeArgument(); - } - } - setState(617); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(618); match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentContext extends ParserRuleContext { - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArgument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeArgument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeArgument(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeArgument(this); - else return visitor.visitChildren(this); - } - } - - public final TypeArgumentContext typeArgument() throws RecognitionException { - TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_typeArgument); - int _la; - try { - setState(626); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(620); type(); - } - break; - case QUESTION: - enterOuterAlt(_localctx, 2); - { - setState(621); match(QUESTION); - setState(624); - _la = _input.LA(1); - if (_la==EXTENDS || _la==SUPER) { - { - setState(622); - _la = _input.LA(1); - if ( !(_la==EXTENDS || _la==SUPER) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(623); type(); - } - } - - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class QualifiedNameListContext extends ParserRuleContext { - public QualifiedNameContext qualifiedName(int i) { - return getRuleContext(QualifiedNameContext.class,i); - } - public List<QualifiedNameContext> qualifiedName() { - return getRuleContexts(QualifiedNameContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterQualifiedNameList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitQualifiedNameList(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitQualifiedNameList(this); - else return visitor.visitChildren(this); - } - } - - public final QualifiedNameListContext qualifiedNameList() throws RecognitionException { - QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_qualifiedNameList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(628); qualifiedName(); - setState(633); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(629); match(COMMA); - setState(630); qualifiedName(); - } - } - setState(635); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParametersContext extends ParserRuleContext { - public FormalParameterListContext formalParameterList() { - return getRuleContext(FormalParameterListContext.class,0); - } - public FormalParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_formalParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterFormalParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitFormalParameters(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitFormalParameters(this); - else return visitor.visitChildren(this); - } - } - - public final FormalParametersContext formalParameters() throws RecognitionException { - FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_formalParameters); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(636); match(LPAREN); - setState(638); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==Identifier || _la==AT) { - { - setState(637); formalParameterList(); - } - } - - setState(640); match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParameterListContext extends ParserRuleContext { - public List<FormalParameterContext> formalParameter() { - return getRuleContexts(FormalParameterContext.class); - } - public LastFormalParameterContext lastFormalParameter() { - return getRuleContext(LastFormalParameterContext.class,0); - } - public FormalParameterContext formalParameter(int i) { - return getRuleContext(FormalParameterContext.class,i); - } - 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 JavaListener ) ((JavaListener)listener).enterFormalParameterList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitFormalParameterList(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitFormalParameterList(this); - else return visitor.visitChildren(this); - } - } - - public final FormalParameterListContext formalParameterList() throws RecognitionException { - FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_formalParameterList); - int _la; - try { - int _alt; - setState(655); - switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(642); formalParameter(); - setState(647); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,69,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(643); match(COMMA); - setState(644); formalParameter(); - } - } - } - setState(649); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,69,_ctx); - } - setState(652); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(650); match(COMMA); - setState(651); lastFormalParameter(); - } - } - - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(654); lastFormalParameter(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FormalParameterContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.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 JavaListener ) ((JavaListener)listener).enterFormalParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitFormalParameter(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitFormalParameter(this); - else return visitor.visitChildren(this); - } - } - - public final FormalParameterContext formalParameter() throws RecognitionException { - FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_formalParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(660); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(657); variableModifier(); - } - } - setState(662); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(663); type(); - setState(664); variableDeclaratorId(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LastFormalParameterContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterLastFormalParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitLastFormalParameter(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitLastFormalParameter(this); - else return visitor.visitChildren(this); - } - } - - public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { - LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_lastFormalParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(669); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(666); variableModifier(); - } - } - setState(671); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(672); type(); - setState(673); match(ELLIPSIS); - setState(674); variableDeclaratorId(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MethodBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public MethodBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_methodBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterMethodBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitMethodBody(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitMethodBody(this); - else return visitor.visitChildren(this); - } - } - - public final MethodBodyContext methodBody() throws RecognitionException { - MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_methodBody); - try { - enterOuterAlt(_localctx, 1); - { - setState(676); block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public ConstructorBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterConstructorBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitConstructorBody(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitConstructorBody(this); - else return visitor.visitChildren(this); - } - } - - public final ConstructorBodyContext constructorBody() throws RecognitionException { - ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_constructorBody); - try { - enterOuterAlt(_localctx, 1); - { - setState(678); block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class QualifiedNameContext extends ParserRuleContext { - public TerminalNode Identifier(int i) { - return getToken(JavaParser.Identifier, i); - } - public List<TerminalNode> Identifier() { return getTokens(JavaParser.Identifier); } - 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 JavaListener ) ((JavaListener)listener).enterQualifiedName(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitQualifiedName(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitQualifiedName(this); - else return visitor.visitChildren(this); - } - } - - public final QualifiedNameContext qualifiedName() throws RecognitionException { - QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_qualifiedName); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(680); match(Identifier); - setState(685); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,74,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(681); match(DOT); - setState(682); match(Identifier); - } - } - } - setState(687); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,74,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LiteralContext extends ParserRuleContext { - public TerminalNode CharacterLiteral() { return getToken(JavaParser.CharacterLiteral, 0); } - public TerminalNode IntegerLiteral() { return getToken(JavaParser.IntegerLiteral, 0); } - public TerminalNode StringLiteral() { return getToken(JavaParser.StringLiteral, 0); } - public TerminalNode FloatingPointLiteral() { return getToken(JavaParser.FloatingPointLiteral, 0); } - public TerminalNode BooleanLiteral() { return getToken(JavaParser.BooleanLiteral, 0); } - public LiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_literal; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitLiteral(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitLiteral(this); - else return visitor.visitChildren(this); - } - } - - public final LiteralContext literal() throws RecognitionException { - LiteralContext _localctx = new LiteralContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_literal); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(688); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationContext extends ParserRuleContext { - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class,0); - } - public ElementValuePairsContext elementValuePairs() { - return getRuleContext(ElementValuePairsContext.class,0); - } - public AnnotationNameContext annotationName() { - return getRuleContext(AnnotationNameContext.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 JavaListener ) ((JavaListener)listener).enterAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotation(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotation(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationContext annotation() throws RecognitionException { - AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_annotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(690); match(AT); - setState(691); annotationName(); - setState(698); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(692); match(LPAREN); - setState(695); - switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { - case 1: - { - setState(693); elementValuePairs(); - } - break; - - case 2: - { - setState(694); elementValue(); - } - break; - } - setState(697); match(RPAREN); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationNameContext extends ParserRuleContext { - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class,0); - } - public AnnotationNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotationName; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterAnnotationName(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationName(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationName(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationNameContext annotationName() throws RecognitionException { - AnnotationNameContext _localctx = new AnnotationNameContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_annotationName); - try { - enterOuterAlt(_localctx, 1); - { - setState(700); qualifiedName(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValuePairsContext extends ParserRuleContext { - public List<ElementValuePairContext> elementValuePair() { - return getRuleContexts(ElementValuePairContext.class); - } - public ElementValuePairContext elementValuePair(int i) { - return getRuleContext(ElementValuePairContext.class,i); - } - public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_elementValuePairs; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterElementValuePairs(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitElementValuePairs(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitElementValuePairs(this); - else return visitor.visitChildren(this); - } - } - - public final ElementValuePairsContext elementValuePairs() throws RecognitionException { - ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_elementValuePairs); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(702); elementValuePair(); - setState(707); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(703); match(COMMA); - setState(704); elementValuePair(); - } - } - setState(709); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValuePairContext extends ParserRuleContext { - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 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 JavaListener ) ((JavaListener)listener).enterElementValuePair(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitElementValuePair(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitElementValuePair(this); - else return visitor.visitChildren(this); - } - } - - public final ElementValuePairContext elementValuePair() throws RecognitionException { - ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_elementValuePair); - try { - enterOuterAlt(_localctx, 1); - { - setState(710); match(Identifier); - setState(711); match(ASSIGN); - setState(712); elementValue(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValueContext extends ParserRuleContext { - public ElementValueArrayInitializerContext elementValueArrayInitializer() { - return getRuleContext(ElementValueArrayInitializerContext.class,0); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.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 JavaListener ) ((JavaListener)listener).enterElementValue(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitElementValue(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitElementValue(this); - else return visitor.visitChildren(this); - } - } - - public final ElementValueContext elementValue() throws RecognitionException { - ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_elementValue); - try { - setState(717); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case LT: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(714); expression(0); - } - break; - case AT: - enterOuterAlt(_localctx, 2); - { - setState(715); annotation(); - } - break; - case LBRACE: - enterOuterAlt(_localctx, 3); - { - setState(716); elementValueArrayInitializer(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElementValueArrayInitializerContext extends ParserRuleContext { - public ElementValueContext elementValue(int i) { - return getRuleContext(ElementValueContext.class,i); - } - public List<ElementValueContext> elementValue() { - return getRuleContexts(ElementValueContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterElementValueArrayInitializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitElementValueArrayInitializer(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitElementValueArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - - public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { - ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_elementValueArrayInitializer); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(719); match(LBRACE); - setState(728); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << [...] - { - setState(720); elementValue(); - setState(725); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,79,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(721); match(COMMA); - setState(722); elementValue(); - } - } - } - setState(727); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,79,_ctx); - } - } - } - - setState(731); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(730); match(COMMA); - } - } - - setState(733); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeDeclarationContext extends ParserRuleContext { - public AnnotationTypeBodyContext annotationTypeBody() { - return getRuleContext(AnnotationTypeBodyContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 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 JavaListener ) ((JavaListener)listener).enterAnnotationTypeDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationTypeDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { - AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_annotationTypeDeclaration); - try { - enterOuterAlt(_localctx, 1); - { - setState(735); match(AT); - setState(736); match(INTERFACE); - setState(737); match(Identifier); - setState(738); annotationTypeBody(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeBodyContext extends ParserRuleContext { - public List<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 JavaListener ) ((JavaListener)listener).enterAnnotationTypeBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationTypeBody(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationTypeBody(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { - AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_annotationTypeBody); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(740); match(LBRACE); - setState(744); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE) | (1L << SEMI))) != 0) || _la==Identifier || _la==AT) { - { - { - setState(741); annotationTypeElementDeclaration(); - } - } - setState(746); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(747); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { - public List<ModifierContext> modifier() { - return getRuleContexts(ModifierContext.class); - } - public AnnotationTypeElementRestContext annotationTypeElementRest() { - return getRuleContext(AnnotationTypeElementRestContext.class,0); - } - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class,i); - } - public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterAnnotationTypeElementDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationTypeElementDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationTypeElementDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { - AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_annotationTypeElementDeclaration); - try { - int _alt; - setState(757); - switch (_input.LA(1)) { - case ABSTRACT: - case BOOLEAN: - case BYTE: - case CHAR: - case CLASS: - case DOUBLE: - case ENUM: - case FINAL: - case FLOAT: - case INT: - case INTERFACE: - case LONG: - case NATIVE: - case PRIVATE: - case PROTECTED: - case PUBLIC: - case SHORT: - case STATIC: - case STRICTFP: - case SYNCHRONIZED: - case TRANSIENT: - case VOLATILE: - case Identifier: - case AT: - enterOuterAlt(_localctx, 1); - { - setState(752); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,83,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(749); modifier(); - } - } - } - setState(754); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,83,_ctx); - } - setState(755); annotationTypeElementRest(); - } - break; - case SEMI: - enterOuterAlt(_localctx, 2); - { - setState(756); match(SEMI); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationTypeElementRestContext extends ParserRuleContext { - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class,0); - } - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class,0); - } - public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { - return getRuleContext(AnnotationMethodOrConstantRestContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class,0); - } - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.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 JavaListener ) ((JavaListener)listener).enterAnnotationTypeElementRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationTypeElementRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationTypeElementRest(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException { - AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_annotationTypeElementRest); - try { - setState(779); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(759); type(); - setState(760); annotationMethodOrConstantRest(); - setState(761); match(SEMI); - } - break; - case CLASS: - enterOuterAlt(_localctx, 2); - { - setState(763); classDeclaration(); - setState(765); - switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { - case 1: - { - setState(764); match(SEMI); - } - break; - } - } - break; - case INTERFACE: - enterOuterAlt(_localctx, 3); - { - setState(767); interfaceDeclaration(); - setState(769); - switch ( getInterpreter().adaptivePredict(_input,86,_ctx) ) { - case 1: - { - setState(768); match(SEMI); - } - break; - } - } - break; - case ENUM: - enterOuterAlt(_localctx, 4); - { - setState(771); enumDeclaration(); - setState(773); - switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { - case 1: - { - setState(772); match(SEMI); - } - break; - } - } - break; - case AT: - enterOuterAlt(_localctx, 5); - { - setState(775); annotationTypeDeclaration(); - setState(777); - switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { - case 1: - { - setState(776); match(SEMI); - } - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext { - public AnnotationConstantRestContext annotationConstantRest() { - return getRuleContext(AnnotationConstantRestContext.class,0); - } - public AnnotationMethodRestContext annotationMethodRest() { - return getRuleContext(AnnotationMethodRestContext.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 JavaListener ) ((JavaListener)listener).enterAnnotationMethodOrConstantRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationMethodOrConstantRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationMethodOrConstantRest(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException { - AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_annotationMethodOrConstantRest); - try { - setState(783); - switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(781); annotationMethodRest(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(782); annotationConstantRest(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationMethodRestContext extends ParserRuleContext { - public DefaultValueContext defaultValue() { - return getRuleContext(DefaultValueContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 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 JavaListener ) ((JavaListener)listener).enterAnnotationMethodRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationMethodRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationMethodRest(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException { - AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_annotationMethodRest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(785); match(Identifier); - setState(786); match(LPAREN); - setState(787); match(RPAREN); - setState(789); - _la = _input.LA(1); - if (_la==DEFAULT) { - { - setState(788); defaultValue(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationConstantRestContext extends ParserRuleContext { - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class,0); - } - public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotationConstantRest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterAnnotationConstantRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitAnnotationConstantRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitAnnotationConstantRest(this); - else return visitor.visitChildren(this); - } - } - - public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException { - AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_annotationConstantRest); - try { - enterOuterAlt(_localctx, 1); - { - setState(791); variableDeclarators(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DefaultValueContext extends ParserRuleContext { - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class,0); - } - public DefaultValueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_defaultValue; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterDefaultValue(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitDefaultValue(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitDefaultValue(this); - else return visitor.visitChildren(this); - } - } - - public final DefaultValueContext defaultValue() throws RecognitionException { - DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_defaultValue); - try { - enterOuterAlt(_localctx, 1); - { - setState(793); match(DEFAULT); - setState(794); elementValue(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BlockContext extends ParserRuleContext { - public List<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 JavaListener ) ((JavaListener)listener).enterBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitBlock(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitBlock(this); - else return visitor.visitChildren(this); - } - } - - public final BlockContext block() throws RecognitionException { - BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_block); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(796); match(LBRACE); - setState(800); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | [...] - { - { - setState(797); blockStatement(); - } - } - setState(802); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(803); match(RBRACE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BlockStatementContext extends ParserRuleContext { - public StatementContext statement() { - return getRuleContext(StatementContext.class,0); - } - public TypeDeclarationContext typeDeclaration() { - return getRuleContext(TypeDeclarationContext.class,0); - } - public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() { - return getRuleContext(LocalVariableDeclarationStatementContext.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 JavaListener ) ((JavaListener)listener).enterBlockStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitBlockStatement(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitBlockStatement(this); - else return visitor.visitChildren(this); - } - } - - public final BlockStatementContext blockStatement() throws RecognitionException { - BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_blockStatement); - try { - setState(808); - switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(805); localVariableDeclarationStatement(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(806); statement(); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(807); typeDeclaration(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LocalVariableDeclarationStatementContext extends ParserRuleContext { - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class,0); - } - public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterLocalVariableDeclarationStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitLocalVariableDeclarationStatement(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitLocalVariableDeclarationStatement(this); - else return visitor.visitChildren(this); - } - } - - public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException { - LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_localVariableDeclarationStatement); - try { - enterOuterAlt(_localctx, 1); - { - setState(810); localVariableDeclaration(); - setState(811); match(SEMI); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LocalVariableDeclarationContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class,0); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterLocalVariableDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitLocalVariableDeclaration(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitLocalVariableDeclaration(this); - else return visitor.visitChildren(this); - } - } - - public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { - LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_localVariableDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(816); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(813); variableModifier(); - } - } - setState(818); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(819); type(); - setState(820); variableDeclarators(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementContext extends ParserRuleContext { - public List<StatementContext> statement() { - return getRuleContexts(StatementContext.class); - } - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class,i); - } - public ForControlContext forControl() { - return getRuleContext(ForControlContext.class,0); - } - public List<SwitchLabelContext> switchLabel() { - return getRuleContexts(SwitchLabelContext.class); - } - public ParExpressionContext parExpression() { - return getRuleContext(ParExpressionContext.class,0); - } - public ResourceSpecificationContext resourceSpecification() { - return getRuleContext(ResourceSpecificationContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public List<ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - public CatchClauseContext catchClause(int i) { - return getRuleContext(CatchClauseContext.class,i); - } - public FinallyBlockContext finallyBlock() { - return getRuleContext(FinallyBlockContext.class,0); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { - return getRuleContext(SwitchBlockStatementGroupContext.class,i); - } - public StatementExpressionContext statementExpression() { - return getRuleContext(StatementExpressionContext.class,0); - } - public List<CatchClauseContext> catchClause() { - return getRuleContexts(CatchClauseContext.class); - } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() { - return getRuleContexts(SwitchBlockStatementGroupContext.class); - } - public TerminalNode ASSERT() { return getToken(JavaParser.ASSERT, 0); } - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitStatement(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitStatement(this); - else return visitor.visitChildren(this); - } - } - - public final StatementContext statement() throws RecognitionException { - StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_statement); - int _la; - try { - int _alt; - setState(926); - switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(822); block(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(823); match(ASSERT); - setState(824); expression(0); - setState(827); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(825); match(COLON); - setState(826); expression(0); - } - } - - setState(829); match(SEMI); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(831); match(IF); - setState(832); parExpression(); - setState(833); statement(); - setState(836); - switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { - case 1: - { - setState(834); match(ELSE); - setState(835); statement(); - } - break; - } - } - break; - - case 4: - enterOuterAlt(_localctx, 4); - { - setState(838); match(FOR); - setState(839); match(LPAREN); - setState(840); forControl(); - setState(841); match(RPAREN); - setState(842); statement(); - } - break; - - case 5: - enterOuterAlt(_localctx, 5); - { - setState(844); match(WHILE); - setState(845); parExpression(); - setState(846); statement(); - } - break; - - case 6: - enterOuterAlt(_localctx, 6); - { - setState(848); match(DO); - setState(849); statement(); - setState(850); match(WHILE); - setState(851); parExpression(); - setState(852); match(SEMI); - } - break; - - case 7: - enterOuterAlt(_localctx, 7); - { - setState(854); match(TRY); - setState(855); block(); - setState(865); - switch (_input.LA(1)) { - case CATCH: - { - setState(857); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(856); catchClause(); - } - } - setState(859); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CATCH ); - setState(862); - _la = _input.LA(1); - if (_la==FINALLY) { - { - setState(861); finallyBlock(); - } - } - - } - break; - case FINALLY: - { - setState(864); finallyBlock(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - - case 8: - enterOuterAlt(_localctx, 8); - { - setState(867); match(TRY); - setState(868); resourceSpecification(); - setState(869); block(); - setState(873); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==CATCH) { - { - { - setState(870); catchClause(); - } - } - setState(875); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(877); - _la = _input.LA(1); - if (_la==FINALLY) { - { - setState(876); finallyBlock(); - } - } - - } - break; - - case 9: - enterOuterAlt(_localctx, 9); - { - setState(879); match(SWITCH); - setState(880); parExpression(); - setState(881); match(LBRACE); - setState(885); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,102,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(882); switchBlockStatementGroup(); - } - } - } - setState(887); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,102,_ctx); - } - setState(891); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==CASE || _la==DEFAULT) { - { - { - setState(888); switchLabel(); - } - } - setState(893); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(894); match(RBRACE); - } - break; - - case 10: - enterOuterAlt(_localctx, 10); - { - setState(896); match(SYNCHRONIZED); - setState(897); parExpression(); - setState(898); block(); - } - break; - - case 11: - enterOuterAlt(_localctx, 11); - { - setState(900); match(RETURN); - setState(902); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1 [...] - { - setState(901); expression(0); - } - } - - setState(904); match(SEMI); - } - break; - - case 12: - enterOuterAlt(_localctx, 12); - { - setState(905); match(THROW); - setState(906); expression(0); - setState(907); match(SEMI); - } - break; - - case 13: - enterOuterAlt(_localctx, 13); - { - setState(909); match(BREAK); - setState(911); - _la = _input.LA(1); - if (_la==Identifier) { - { - setState(910); match(Identifier); - } - } - - setState(913); match(SEMI); - } - break; - - case 14: - enterOuterAlt(_localctx, 14); - { - setState(914); match(CONTINUE); - setState(916); - _la = _input.LA(1); - if (_la==Identifier) { - { - setState(915); match(Identifier); - } - } - - setState(918); match(SEMI); - } - break; - - case 15: - enterOuterAlt(_localctx, 15); - { - setState(919); match(SEMI); - } - break; - - case 16: - enterOuterAlt(_localctx, 16); - { - setState(920); statementExpression(); - setState(921); match(SEMI); - } - break; - - case 17: - enterOuterAlt(_localctx, 17); - { - setState(923); match(Identifier); - setState(924); match(COLON); - setState(925); statement(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CatchClauseContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterCatchClause(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitCatchClause(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitCatchClause(this); - else return visitor.visitChildren(this); - } - } - - public final CatchClauseContext catchClause() throws RecognitionException { - CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_catchClause); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(928); match(CATCH); - setState(929); match(LPAREN); - setState(933); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(930); variableModifier(); - } - } - setState(935); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(936); catchType(); - setState(937); match(Identifier); - setState(938); match(RPAREN); - setState(939); block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CatchTypeContext extends ParserRuleContext { - public QualifiedNameContext qualifiedName(int i) { - return getRuleContext(QualifiedNameContext.class,i); - } - public List<QualifiedNameContext> qualifiedName() { - return getRuleContexts(QualifiedNameContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterCatchType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitCatchType(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitCatchType(this); - else return visitor.visitChildren(this); - } - } - - public final CatchTypeContext catchType() throws RecognitionException { - CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_catchType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(941); qualifiedName(); - setState(946); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==BITOR) { - { - { - setState(942); match(BITOR); - setState(943); qualifiedName(); - } - } - setState(948); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FinallyBlockContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public FinallyBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_finallyBlock; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterFinallyBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitFinallyBlock(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitFinallyBlock(this); - else return visitor.visitChildren(this); - } - } - - public final FinallyBlockContext finallyBlock() throws RecognitionException { - FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_finallyBlock); - try { - enterOuterAlt(_localctx, 1); - { - setState(949); match(FINALLY); - setState(950); block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ResourceSpecificationContext extends ParserRuleContext { - public ResourcesContext resources() { - return getRuleContext(ResourcesContext.class,0); - } - public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_resourceSpecification; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterResourceSpecification(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitResourceSpecification(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitResourceSpecification(this); - else return visitor.visitChildren(this); - } - } - - public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { - ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_resourceSpecification); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(952); match(LPAREN); - setState(953); resources(); - setState(955); - _la = _input.LA(1); - if (_la==SEMI) { - { - setState(954); match(SEMI); - } - } - - setState(957); match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ResourcesContext extends ParserRuleContext { - public List<ResourceContext> resource() { - return getRuleContexts(ResourceContext.class); - } - public ResourceContext resource(int i) { - return getRuleContext(ResourceContext.class,i); - } - public ResourcesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_resources; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterResources(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitResources(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitResources(this); - else return visitor.visitChildren(this); - } - } - - public final ResourcesContext resources() throws RecognitionException { - ResourcesContext _localctx = new ResourcesContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_resources); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(959); resource(); - setState(964); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,111,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(960); match(SEMI); - setState(961); resource(); - } - } - } - setState(966); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,111,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ResourceContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterResource(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitResource(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitResource(this); - else return visitor.visitChildren(this); - } - } - - public final ResourceContext resource() throws RecognitionException { - ResourceContext _localctx = new ResourceContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_resource); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(970); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(967); variableModifier(); - } - } - setState(972); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(973); classOrInterfaceType(); - setState(974); variableDeclaratorId(); - setState(975); match(ASSIGN); - setState(976); expression(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchBlockStatementGroupContext extends ParserRuleContext { - public List<BlockStatementContext> blockStatement() { - return getRuleContexts(BlockStatementContext.class); - } - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class,i); - } - public List<SwitchLabelContext> switchLabel() { - return getRuleContexts(SwitchLabelContext.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 JavaListener ) ((JavaListener)listener).enterSwitchBlockStatementGroup(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitSwitchBlockStatementGroup(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitSwitchBlockStatementGroup(this); - else return visitor.visitChildren(this); - } - } - - public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { - SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_switchBlockStatementGroup); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(979); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(978); switchLabel(); - } - } - setState(981); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==CASE || _la==DEFAULT ); - setState(984); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(983); blockStatement(); - } - } - setState(986); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER [...] - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SwitchLabelContext extends ParserRuleContext { - public ConstantExpressionContext constantExpression() { - return getRuleContext(ConstantExpressionContext.class,0); - } - public EnumConstantNameContext enumConstantName() { - return getRuleContext(EnumConstantNameContext.class,0); - } - public SwitchLabelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_switchLabel; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterSwitchLabel(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitSwitchLabel(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitSwitchLabel(this); - else return visitor.visitChildren(this); - } - } - - public final SwitchLabelContext switchLabel() throws RecognitionException { - SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_switchLabel); - try { - setState(998); - switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(988); match(CASE); - setState(989); constantExpression(); - setState(990); match(COLON); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(992); match(CASE); - setState(993); enumConstantName(); - setState(994); match(COLON); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(996); match(DEFAULT); - setState(997); match(COLON); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ForControlContext extends ParserRuleContext { - public ForInitContext forInit() { - return getRuleContext(ForInitContext.class,0); - } - public EnhancedForControlContext enhancedForControl() { - return getRuleContext(EnhancedForControlContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ForUpdateContext forUpdate() { - return getRuleContext(ForUpdateContext.class,0); - } - public ForControlContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_forControl; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterForControl(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitForControl(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitForControl(this); - else return visitor.visitChildren(this); - } - } - - public final ForControlContext forControl() throws RecognitionException { - ForControlContext _localctx = new ForControlContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_forControl); - int _la; - try { - setState(1012); - switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1000); enhancedForControl(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1002); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << [...] - { - setState(1001); forInit(); - } - } - - setState(1004); match(SEMI); - setState(1006); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1 [...] - { - setState(1005); expression(0); - } - } - - setState(1008); match(SEMI); - setState(1010); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1 [...] - { - setState(1009); forUpdate(); - } - } - - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ForInitContext extends ParserRuleContext { - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class,0); - } - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class,0); - } - public ForInitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_forInit; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterForInit(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitForInit(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitForInit(this); - else return visitor.visitChildren(this); - } - } - - public final ForInitContext forInit() throws RecognitionException { - ForInitContext _localctx = new ForInitContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_forInit); - try { - setState(1016); - switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1014); localVariableDeclaration(); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1015); expressionList(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnhancedForControlContext extends ParserRuleContext { - public List<VariableModifierContext> variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class,i); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.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 JavaListener ) ((JavaListener)listener).enterEnhancedForControl(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitEnhancedForControl(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitEnhancedForControl(this); - else return visitor.visitChildren(this); - } - } - - public final EnhancedForControlContext enhancedForControl() throws RecognitionException { - EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_enhancedForControl); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1021); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==FINAL || _la==AT) { - { - { - setState(1018); variableModifier(); - } - } - setState(1023); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1024); type(); - setState(1025); match(Identifier); - setState(1026); match(COLON); - setState(1027); expression(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ForUpdateContext extends ParserRuleContext { - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class,0); - } - public ForUpdateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_forUpdate; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterForUpdate(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitForUpdate(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitForUpdate(this); - else return visitor.visitChildren(this); - } - } - - public final ForUpdateContext forUpdate() throws RecognitionException { - ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_forUpdate); - try { - enterOuterAlt(_localctx, 1); - { - setState(1029); expressionList(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParExpressionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ParExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterParExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitParExpression(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitParExpression(this); - else return visitor.visitChildren(this); - } - } - - public final ParExpressionContext parExpression() throws RecognitionException { - ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_parExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1031); match(LPAREN); - setState(1032); expression(0); - setState(1033); match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionListContext extends ParserRuleContext { - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List<ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterExpressionList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitExpressionList(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitExpressionList(this); - else return visitor.visitChildren(this); - } - } - - public final ExpressionListContext expressionList() throws RecognitionException { - ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_expressionList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1035); expression(0); - setState(1040); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==COMMA) { - { - { - setState(1036); match(COMMA); - setState(1037); expression(0); - } - } - setState(1042); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementExpressionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public StatementExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statementExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterStatementExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitStatementExpression(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitStatementExpression(this); - else return visitor.visitChildren(this); - } - } - - public final StatementExpressionContext statementExpression() throws RecognitionException { - StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_statementExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1043); expression(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstantExpressionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constantExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterConstantExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitConstantExpression(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitConstantExpression(this); - else return visitor.visitChildren(this); - } - } - - public final ConstantExpressionContext constantExpression() throws RecognitionException { - ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_constantExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1045); expression(0); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExpressionContext extends ParserRuleContext { - public int _p; - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class,0); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public ExplicitGenericInvocationContext explicitGenericInvocation() { - return getRuleContext(ExplicitGenericInvocationContext.class,0); - } - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class,0); - } - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class,0); - } - public SuperSuffixContext superSuffix() { - return getRuleContext(SuperSuffixContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List<ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - public InnerCreatorContext innerCreator() { - return getRuleContext(InnerCreatorContext.class,0); - } - public CreatorContext creator() { - return getRuleContext(CreatorContext.class,0); - } - public ExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } - public ExpressionContext(ParserRuleContext parent, int invokingState, int _p) { - super(parent, invokingState); - this._p = _p; - } - @Override public int getRuleIndex() { return RULE_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitExpression(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitExpression(this); - else return visitor.visitChildren(this); - } - } - - public final ExpressionContext expression(int _p) throws RecognitionException { - ParserRuleContext _parentctx = _ctx; - int _parentState = getState(); - ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState, _p); - ExpressionContext _prevctx = _localctx; - int _startState = 174; - enterRecursionRule(_localctx, RULE_expression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1060); - switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { - case 1: - { - setState(1048); match(LPAREN); - setState(1049); type(); - setState(1050); match(RPAREN); - setState(1051); expression(17); - } - break; - - case 2: - { - setState(1053); - _la = _input.LA(1); - if ( !(((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (INC - 79)) | (1L << (DEC - 79)) | (1L << (ADD - 79)) | (1L << (SUB - 79)))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1054); expression(15); - } - break; - - case 3: - { - setState(1055); - _la = _input.LA(1); - if ( !(_la==BANG || _la==TILDE) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1056); expression(14); - } - break; - - case 4: - { - setState(1057); primary(); - } - break; - - case 5: - { - setState(1058); match(NEW); - setState(1059); creator(); - } - break; - } - _ctx.stop = _input.LT(-1); - setState(1160); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,129,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - if ( _parseListeners!=null ) triggerExitRuleEvent(); - _prevctx = _localctx; - { - setState(1158); - switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { - case 1: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1062); - if (!(13 >= _localctx._p)) throw new FailedPredicateException(this, "13 >= $_p"); - setState(1063); - _la = _input.LA(1); - if ( !(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (MUL - 83)) | (1L << (DIV - 83)) | (1L << (MOD - 83)))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1064); expression(14); - } - break; - - case 2: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1065); - if (!(12 >= _localctx._p)) throw new FailedPredicateException(this, "12 >= $_p"); - setState(1066); - _la = _input.LA(1); - if ( !(_la==ADD || _la==SUB) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1067); expression(13); - } - break; - - case 3: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1068); - if (!(11 >= _localctx._p)) throw new FailedPredicateException(this, "11 >= $_p"); - setState(1076); - switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { - case 1: - { - setState(1069); match(LT); - setState(1070); match(LT); - } - break; - - case 2: - { - setState(1071); match(GT); - setState(1072); match(GT); - setState(1073); match(GT); - } - break; - - case 3: - { - setState(1074); match(GT); - setState(1075); match(GT); - } - break; - } - setState(1078); expression(12); - } - break; - - case 4: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1079); - if (!(10 >= _localctx._p)) throw new FailedPredicateException(this, "10 >= $_p"); - setState(1080); - _la = _input.LA(1); - if ( !(((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (GT - 67)) | (1L << (LT - 67)) | (1L << (LE - 67)) | (1L << (GE - 67)))) != 0)) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1081); expression(11); - } - break; - - case 5: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1082); - if (!(8 >= _localctx._p)) throw new FailedPredicateException(this, "8 >= $_p"); - setState(1083); - _la = _input.LA(1); - if ( !(_la==EQUAL || _la==NOTEQUAL) ) { - _errHandler.recoverInline(this); - } - consume(); - setState(1084); expression(9); - } - break; - - case 6: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1085); - if (!(7 >= _localctx._p)) throw new FailedPredicateException(this, "7 >= $_p"); - setState(1086); match(BITAND); - setState(1087); expression(8); - } - break; - - case 7: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1088); - if (!(6 >= _localctx._p)) throw new FailedPredicateException(this, "6 >= $_p"); - setState(1089); match(CARET); - setState(1090); expression(7); - } - break; - - case 8: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1091); - if (!(5 >= _localctx._p)) throw new FailedPredicateException(this, "5 >= $_p"); - setState(1092); match(BITOR); - setState(1093); expression(6); - } - break; - - case 9: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1094); - if (!(4 >= _localctx._p)) throw new FailedPredicateException(this, "4 >= $_p"); - setState(1095); match(AND); - setState(1096); expression(5); - } - break; - - case 10: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1097); - if (!(3 >= _localctx._p)) throw new FailedPredicateException(this, "3 >= $_p"); - setState(1098); match(OR); - setState(1099); expression(4); - } - break; - - case 11: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1100); - if (!(1 >= _localctx._p)) throw new FailedPredicateException(this, "1 >= $_p"); - setState(1113); - switch (_input.LA(1)) { - case ASSIGN: - { - setState(1101); match(ASSIGN); - } - break; - case ADD_ASSIGN: - { - setState(1102); match(ADD_ASSIGN); - } - break; - case SUB_ASSIGN: - { - setState(1103); match(SUB_ASSIGN); - } - break; - case MUL_ASSIGN: - { - setState(1104); match(MUL_ASSIGN); - } - break; - case DIV_ASSIGN: - { - setState(1105); match(DIV_ASSIGN); - } - break; - case AND_ASSIGN: - { - setState(1106); match(AND_ASSIGN); - } - break; - case OR_ASSIGN: - { - setState(1107); match(OR_ASSIGN); - } - break; - case XOR_ASSIGN: - { - setState(1108); match(XOR_ASSIGN); - } - break; - case RSHIFT_ASSIGN: - { - setState(1109); match(RSHIFT_ASSIGN); - } - break; - case URSHIFT_ASSIGN: - { - setState(1110); match(URSHIFT_ASSIGN); - } - break; - case LSHIFT_ASSIGN: - { - setState(1111); match(LSHIFT_ASSIGN); - } - break; - case MOD_ASSIGN: - { - setState(1112); match(MOD_ASSIGN); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1115); expression(1); - } - break; - - case 12: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1116); - if (!(2 >= _localctx._p)) throw new FailedPredicateException(this, "2 >= $_p"); - setState(1117); match(QUESTION); - setState(1118); expression(0); - setState(1119); match(COLON); - setState(1120); expression(3); - } - break; - - case 13: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1122); - if (!(25 >= _localctx._p)) throw new FailedPredicateException(this, "25 >= $_p"); - setState(1123); match(DOT); - setState(1124); match(Identifier); - } - break; - - case 14: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1125); - if (!(24 >= _localctx._p)) throw new FailedPredicateException(this, "24 >= $_p"); - setState(1126); match(DOT); - setState(1127); match(THIS); - } - break; - - case 15: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1128); - if (!(23 >= _localctx._p)) throw new FailedPredicateException(this, "23 >= $_p"); - setState(1129); match(DOT); - setState(1130); match(NEW); - setState(1132); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1131); nonWildcardTypeArguments(); - } - } - - setState(1134); innerCreator(); - } - break; - - case 16: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1135); - if (!(22 >= _localctx._p)) throw new FailedPredicateException(this, "22 >= $_p"); - setState(1136); match(DOT); - setState(1137); match(SUPER); - setState(1138); superSuffix(); - } - break; - - case 17: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1139); - if (!(21 >= _localctx._p)) throw new FailedPredicateException(this, "21 >= $_p"); - setState(1140); match(DOT); - setState(1141); explicitGenericInvocation(); - } - break; - - case 18: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1142); - if (!(20 >= _localctx._p)) throw new FailedPredicateException(this, "20 >= $_p"); - setState(1143); match(LBRACK); - setState(1144); expression(0); - setState(1145); match(RBRACK); - } - break; - - case 19: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1147); - if (!(19 >= _localctx._p)) throw new FailedPredicateException(this, "19 >= $_p"); - setState(1148); match(LPAREN); - setState(1150); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | [...] - { - setState(1149); expressionList(); - } - } - - setState(1152); match(RPAREN); - } - break; - - case 20: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1153); - if (!(16 >= _localctx._p)) throw new FailedPredicateException(this, "16 >= $_p"); - setState(1154); - _la = _input.LA(1); - if ( !(_la==INC || _la==DEC) ) { - _errHandler.recoverInline(this); - } - consume(); - } - break; - - case 21: - { - _localctx = new ExpressionContext(_parentctx, _parentState, _p); - pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(1155); - if (!(9 >= _localctx._p)) throw new FailedPredicateException(this, "9 >= $_p"); - setState(1156); match(INSTANCEOF); - setState(1157); type(); - } - break; - } - } - } - setState(1162); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,129,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - unrollRecursionContexts(_parentctx); - } - return _localctx; - } - - public static class PrimaryContext extends ParserRuleContext { - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { - return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.class,0); - } - public LiteralContext literal() { - return getRuleContext(LiteralContext.class,0); - } - public PrimaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primary; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterPrimary(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitPrimary(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitPrimary(this); - else return visitor.visitChildren(this); - } - } - - public final PrimaryContext primary() throws RecognitionException { - PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_primary); - try { - setState(1184); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1163); match(LPAREN); - setState(1164); expression(0); - setState(1165); match(RPAREN); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1167); match(THIS); - } - break; - - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1168); match(SUPER); - } - break; - - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1169); literal(); - } - break; - - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1170); match(Identifier); - } - break; - - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1171); type(); - setState(1172); match(DOT); - setState(1173); match(CLASS); - } - break; - - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1175); match(VOID); - setState(1176); match(DOT); - setState(1177); match(CLASS); - } - break; - - case 8: - enterOuterAlt(_localctx, 8); - { - setState(1178); nonWildcardTypeArguments(); - setState(1182); - switch (_input.LA(1)) { - case SUPER: - case Identifier: - { - setState(1179); explicitGenericInvocationSuffix(); - } - break; - case THIS: - { - setState(1180); match(THIS); - setState(1181); arguments(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CreatorContext extends ParserRuleContext { - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class,0); - } - public ArrayCreatorRestContext arrayCreatorRest() { - return getRuleContext(ArrayCreatorRestContext.class,0); - } - public ClassCreatorRestContext classCreatorRest() { - return getRuleContext(ClassCreatorRestContext.class,0); - } - public CreatedNameContext createdName() { - return getRuleContext(CreatedNameContext.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 JavaListener ) ((JavaListener)listener).enterCreator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitCreator(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitCreator(this); - else return visitor.visitChildren(this); - } - } - - public final CreatorContext creator() throws RecognitionException { - CreatorContext _localctx = new CreatorContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_creator); - try { - setState(1195); - switch (_input.LA(1)) { - case LT: - enterOuterAlt(_localctx, 1); - { - setState(1186); nonWildcardTypeArguments(); - setState(1187); createdName(); - setState(1188); classCreatorRest(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(1190); createdName(); - setState(1193); - switch (_input.LA(1)) { - case LBRACK: - { - setState(1191); arrayCreatorRest(); - } - break; - case LPAREN: - { - setState(1192); classCreatorRest(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CreatedNameContext extends ParserRuleContext { - public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) { - return getRuleContext(TypeArgumentsOrDiamondContext.class,i); - } - public TerminalNode Identifier(int i) { - return getToken(JavaParser.Identifier, i); - } - public List<TerminalNode> Identifier() { return getTokens(JavaParser.Identifier); } - public List<TypeArgumentsOrDiamondContext> typeArgumentsOrDiamond() { - return getRuleContexts(TypeArgumentsOrDiamondContext.class); - } - 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 JavaListener ) ((JavaListener)listener).enterCreatedName(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitCreatedName(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitCreatedName(this); - else return visitor.visitChildren(this); - } - } - - public final CreatedNameContext createdName() throws RecognitionException { - CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_createdName); - int _la; - try { - setState(1212); - switch (_input.LA(1)) { - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(1197); match(Identifier); - setState(1199); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1198); typeArgumentsOrDiamond(); - } - } - - setState(1208); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==DOT) { - { - { - setState(1201); match(DOT); - setState(1202); match(Identifier); - setState(1204); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1203); typeArgumentsOrDiamond(); - } - } - - } - } - setState(1210); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - enterOuterAlt(_localctx, 2); - { - setState(1211); primitiveType(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InnerCreatorContext extends ParserRuleContext { - public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() { - return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public ClassCreatorRestContext classCreatorRest() { - return getRuleContext(ClassCreatorRestContext.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 JavaListener ) ((JavaListener)listener).enterInnerCreator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitInnerCreator(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitInnerCreator(this); - else return visitor.visitChildren(this); - } - } - - public final InnerCreatorContext innerCreator() throws RecognitionException { - InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_innerCreator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1214); match(Identifier); - setState(1216); - _la = _input.LA(1); - if (_la==LT) { - { - setState(1215); nonWildcardTypeArgumentsOrDiamond(); - } - } - - setState(1218); classCreatorRest(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ArrayCreatorRestContext extends ParserRuleContext { - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List<ExpressionContext> expression() { - return getRuleContexts(ExpressionContext.class); - } - public ArrayInitializerContext arrayInitializer() { - return getRuleContext(ArrayInitializerContext.class,0); - } - 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 JavaListener ) ((JavaListener)listener).enterArrayCreatorRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitArrayCreatorRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitArrayCreatorRest(this); - else return visitor.visitChildren(this); - } - } - - public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException { - ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_arrayCreatorRest); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1220); match(LBRACK); - setState(1248); - switch (_input.LA(1)) { - case RBRACK: - { - setState(1221); match(RBRACK); - setState(1226); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==LBRACK) { - { - { - setState(1222); match(LBRACK); - setState(1223); match(RBRACK); - } - } - setState(1228); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1229); arrayInitializer(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case IntegerLiteral: - case FloatingPointLiteral: - case BooleanLiteral: - case CharacterLiteral: - case StringLiteral: - case NullLiteral: - case LPAREN: - case LT: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case Identifier: - { - setState(1230); expression(0); - setState(1231); match(RBRACK); - setState(1238); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,140,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(1232); match(LBRACK); - setState(1233); expression(0); - setState(1234); match(RBRACK); - } - } - } - setState(1240); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,140,_ctx); - } - setState(1245); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,141,_ctx); - while ( _alt!=2 && _alt!=-1 ) { - if ( _alt==1 ) { - { - { - setState(1241); match(LBRACK); - setState(1242); match(RBRACK); - } - } - } - setState(1247); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,141,_ctx); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassCreatorRestContext extends ParserRuleContext { - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.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 JavaListener ) ((JavaListener)listener).enterClassCreatorRest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitClassCreatorRest(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitClassCreatorRest(this); - else return visitor.visitChildren(this); - } - } - - public final ClassCreatorRestContext classCreatorRest() throws RecognitionException { - ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_classCreatorRest); - try { - enterOuterAlt(_localctx, 1); - { - setState(1250); arguments(); - setState(1252); - switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { - case 1: - { - setState(1251); classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExplicitGenericInvocationContext extends ParserRuleContext { - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class,0); - } - public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { - return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); - } - public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterExplicitGenericInvocation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitExplicitGenericInvocation(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitExplicitGenericInvocation(this); - else return visitor.visitChildren(this); - } - } - - public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException { - ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_explicitGenericInvocation); - try { - enterOuterAlt(_localctx, 1); - { - setState(1254); nonWildcardTypeArguments(); - setState(1255); explicitGenericInvocationSuffix(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NonWildcardTypeArgumentsContext extends ParserRuleContext { - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class,0); - } - public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterNonWildcardTypeArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitNonWildcardTypeArguments(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitNonWildcardTypeArguments(this); - else return visitor.visitChildren(this); - } - } - - public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException { - NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_nonWildcardTypeArguments); - try { - enterOuterAlt(_localctx, 1); - { - setState(1257); match(LT); - setState(1258); typeList(); - setState(1259); match(GT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterTypeArgumentsOrDiamond(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitTypeArgumentsOrDiamond(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitTypeArgumentsOrDiamond(this); - else return visitor.visitChildren(this); - } - } - - public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { - TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_typeArgumentsOrDiamond); - try { - setState(1264); - switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1261); match(LT); - setState(1262); match(GT); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1263); typeArguments(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext { - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class,0); - } - public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitNonWildcardTypeArgumentsOrDiamond(this); - else return visitor.visitChildren(this); - } - } - - public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException { - NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_nonWildcardTypeArgumentsOrDiamond); - try { - setState(1269); - switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1266); match(LT); - setState(1267); match(GT); - } - break; - - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1268); nonWildcardTypeArguments(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SuperSuffixContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.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 JavaListener ) ((JavaListener)listener).enterSuperSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitSuperSuffix(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitSuperSuffix(this); - else return visitor.visitChildren(this); - } - } - - public final SuperSuffixContext superSuffix() throws RecognitionException { - SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_superSuffix); - try { - setState(1277); - switch (_input.LA(1)) { - case LPAREN: - enterOuterAlt(_localctx, 1); - { - setState(1271); arguments(); - } - break; - case DOT: - enterOuterAlt(_localctx, 2); - { - setState(1272); match(DOT); - setState(1273); match(Identifier); - setState(1275); - switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { - case 1: - { - setState(1274); arguments(); - } - break; - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExplicitGenericInvocationSuffixContext extends ParserRuleContext { - public SuperSuffixContext superSuffix() { - return getRuleContext(SuperSuffixContext.class,0); - } - public TerminalNode Identifier() { return getToken(JavaParser.Identifier, 0); } - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.class,0); - } - public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterExplicitGenericInvocationSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitExplicitGenericInvocationSuffix(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitExplicitGenericInvocationSuffix(this); - else return visitor.visitChildren(this); - } - } - - public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException { - ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_explicitGenericInvocationSuffix); - try { - setState(1283); - switch (_input.LA(1)) { - case SUPER: - enterOuterAlt(_localctx, 1); - { - setState(1279); match(SUPER); - setState(1280); superSuffix(); - } - break; - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(1281); match(Identifier); - setState(1282); arguments(); - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ArgumentsContext extends ParserRuleContext { - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class,0); - } - public ArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_arguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).enterArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof JavaListener ) ((JavaListener)listener).exitArguments(this); - } - @Override - public <T> T accept(ParseTreeVisitor<? extends T> visitor) { - if ( visitor instanceof JavaVisitor ) return ((JavaVisitor<? extends T>)visitor).visitArguments(this); - else return visitor.visitChildren(this); - } - } - - public final ArgumentsContext arguments() throws RecognitionException { - ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_arguments); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1285); match(LPAREN); - setState(1287); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L [...] - { - setState(1286); expressionList(); - } - } - - setState(1289); 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 87: return expression_sempred((ExpressionContext)_localctx, predIndex); - } - return true; - } - private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 0: return 13 >= _localctx._p; - - case 1: return 12 >= _localctx._p; - - case 2: return 11 >= _localctx._p; - - case 3: return 10 >= _localctx._p; - - case 4: return 8 >= _localctx._p; - - case 5: return 7 >= _localctx._p; - - case 6: return 6 >= _localctx._p; - - case 7: return 5 >= _localctx._p; - - case 8: return 4 >= _localctx._p; - - case 9: return 3 >= _localctx._p; - - case 10: return 1 >= _localctx._p; - - case 11: return 2 >= _localctx._p; - - case 12: return 25 >= _localctx._p; - - case 13: return 24 >= _localctx._p; - - case 14: return 23 >= _localctx._p; - - case 15: return 22 >= _localctx._p; - - case 17: return 20 >= _localctx._p; - - case 16: return 21 >= _localctx._p; - - case 19: return 16 >= _localctx._p; - - case 18: return 19 >= _localctx._p; - - case 20: return 9 >= _localctx._p; - } - return true; - } - - public static final String _serializedATN = - "\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3k\u050e\4\2\t\2\4"+ - "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ - "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ - "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ - "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ - "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ - ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ - "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ - "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ - "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ - "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ - "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\3\2\5\2\u00ce\n\2\3\2\7\2\u00d1"+ - "\n\2\f\2\16\2\u00d4\13\2\3\2\7\2\u00d7\n\2\f\2\16\2\u00da\13\2\3\2\3\2"+ - "\3\3\7\3\u00df\n\3\f\3\16\3\u00e2\13\3\3\3\3\3\3\3\3\3\3\4\3\4\5\4\u00ea"+ - "\n\4\3\4\3\4\3\4\5\4\u00ef\n\4\3\4\3\4\3\5\7\5\u00f4\n\5\f\5\16\5\u00f7"+ - "\13\5\3\5\3\5\7\5\u00fb\n\5\f\5\16\5\u00fe\13\5\3\5\3\5\7\5\u0102\n\5"+ - "\f\5\16\5\u0105\13\5\3\5\3\5\7\5\u0109\n\5\f\5\16\5\u010c\13\5\3\5\3\5"+ - "\5\5\u0110\n\5\3\6\3\6\5\6\u0114\n\6\3\7\3\7\5\7\u0118\n\7\3\b\3\b\5\b"+ - "\u011c\n\b\3\t\3\t\3\t\5\t\u0121\n\t\3\t\3\t\5\t\u0125\n\t\3\t\3\t\5\t"+ - "\u0129\n\t\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u0131\n\n\f\n\16\n\u0134\13\n\3"+ - "\n\3\n\3\13\3\13\3\13\5\13\u013b\n\13\3\f\3\f\3\f\7\f\u0140\n\f\f\f\16"+ - "\f\u0143\13\f\3\r\3\r\3\r\3\r\5\r\u0149\n\r\3\r\3\r\5\r\u014d\n\r\3\r"+ - "\5\r\u0150\n\r\3\r\5\r\u0153\n\r\3\r\3\r\3\16\3\16\3\16\7\16\u015a\n\16"+ - "\f\16\16\16\u015d\13\16\3\17\7\17\u0160\n\17\f\17\16\17\u0163\13\17\3"+ - "\17\3\17\5\17\u0167\n\17\3\17\5\17\u016a\n\17\3\20\3\20\7\20\u016e\n\20"+ - "\f\20\16\20\u0171\13\20\3\21\3\21\3\21\5\21\u0176\n\21\3\21\3\21\5\21"+ - "\u017a\n\21\3\21\3\21\3\22\3\22\3\22\7\22\u0181\n\22\f\22\16\22\u0184"+ - "\13\22\3\23\3\23\7\23\u0188\n\23\f\23\16\23\u018b\13\23\3\23\3\23\3\24"+ - "\3\24\7\24\u0191\n\24\f\24\16\24\u0194\13\24\3\24\3\24\3\25\3\25\5\25"+ - "\u019a\n\25\3\25\3\25\7\25\u019e\n\25\f\25\16\25\u01a1\13\25\3\25\5\25"+ - "\u01a4\n\25\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\5\26\u01af\n"+ - "\26\3\27\3\27\5\27\u01b3\n\27\3\27\3\27\3\27\3\27\7\27\u01b9\n\27\f\27"+ - "\16\27\u01bc\13\27\3\27\3\27\5\27\u01c0\n\27\3\27\3\27\5\27\u01c4\n\27"+ - "\3\30\3\30\3\30\3\31\3\31\3\31\3\31\5\31\u01cd\n\31\3\31\3\31\3\32\3\32"+ - "\3\32\3\33\3\33\3\33\3\33\3\34\7\34\u01d9\n\34\f\34\16\34\u01dc\13\34"+ - "\3\34\3\34\5\34\u01e0\n\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\5\35\u01e9"+ - "\n\35\3\36\3\36\3\36\3\36\7\36\u01ef\n\36\f\36\16\36\u01f2\13\36\3\36"+ - "\3\36\3\37\3\37\3\37\7\37\u01f9\n\37\f\37\16\37\u01fc\13\37\3\37\3\37"+ - "\3\37\3 \3 \5 \u0203\n \3 \3 \3 \3 \7 \u0209\n \f \16 \u020c\13 \3 \3"+ - " \5 \u0210\n \3 \3 \3!\3!\3!\3\"\3\"\3\"\7\"\u021a\n\"\f\"\16\"\u021d"+ - "\13\"\3#\3#\3#\5#\u0222\n#\3$\3$\3$\7$\u0227\n$\f$\16$\u022a\13$\3%\3"+ - "%\5%\u022e\n%\3&\3&\3&\3&\7&\u0234\n&\f&\16&\u0237\13&\3&\5&\u023a\n&"+ - "\5&\u023c\n&\3&\3&\3\'\3\'\3(\3(\3(\7(\u0245\n(\f(\16(\u0248\13(\3(\3"+ - "(\3(\7(\u024d\n(\f(\16(\u0250\13(\5(\u0252\n(\3)\3)\5)\u0256\n)\3)\3)"+ - "\3)\5)\u025b\n)\7)\u025d\n)\f)\16)\u0260\13)\3*\3*\3+\3+\3+\3+\7+\u0268"+ - "\n+\f+\16+\u026b\13+\3+\3+\3,\3,\3,\3,\5,\u0273\n,\5,\u0275\n,\3-\3-\3"+ - "-\7-\u027a\n-\f-\16-\u027d\13-\3.\3.\5.\u0281\n.\3.\3.\3/\3/\3/\7/\u0288"+ - "\n/\f/\16/\u028b\13/\3/\3/\5/\u028f\n/\3/\5/\u0292\n/\3\60\7\60\u0295"+ - "\n\60\f\60\16\60\u0298\13\60\3\60\3\60\3\60\3\61\7\61\u029e\n\61\f\61"+ - "\16\61\u02a1\13\61\3\61\3\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3"+ - "\64\7\64\u02ae\n\64\f\64\16\64\u02b1\13\64\3\65\3\65\3\66\3\66\3\66\3"+ - "\66\3\66\5\66\u02ba\n\66\3\66\5\66\u02bd\n\66\3\67\3\67\38\38\38\78\u02c4"+ - "\n8\f8\168\u02c7\138\39\39\39\39\3:\3:\3:\5:\u02d0\n:\3;\3;\3;\3;\7;\u02d6"+ - "\n;\f;\16;\u02d9\13;\5;\u02db\n;\3;\5;\u02de\n;\3;\3;\3<\3<\3<\3<\3<\3"+ - "=\3=\7=\u02e9\n=\f=\16=\u02ec\13=\3=\3=\3>\7>\u02f1\n>\f>\16>\u02f4\13"+ - ">\3>\3>\5>\u02f8\n>\3?\3?\3?\3?\3?\3?\5?\u0300\n?\3?\3?\5?\u0304\n?\3"+ - "?\3?\5?\u0308\n?\3?\3?\5?\u030c\n?\5?\u030e\n?\3@\3@\5@\u0312\n@\3A\3"+ - "A\3A\3A\5A\u0318\nA\3B\3B\3C\3C\3C\3D\3D\7D\u0321\nD\fD\16D\u0324\13D"+ - "\3D\3D\3E\3E\3E\5E\u032b\nE\3F\3F\3F\3G\7G\u0331\nG\fG\16G\u0334\13G\3"+ - "G\3G\3G\3H\3H\3H\3H\3H\5H\u033e\nH\3H\3H\3H\3H\3H\3H\3H\5H\u0347\nH\3"+ - "H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\6H\u035c\nH\r"+ - "H\16H\u035d\3H\5H\u0361\nH\3H\5H\u0364\nH\3H\3H\3H\3H\7H\u036a\nH\fH\16"+ - "H\u036d\13H\3H\5H\u0370\nH\3H\3H\3H\3H\7H\u0376\nH\fH\16H\u0379\13H\3"+ - "H\7H\u037c\nH\fH\16H\u037f\13H\3H\3H\3H\3H\3H\3H\3H\3H\5H\u0389\nH\3H"+ - "\3H\3H\3H\3H\3H\3H\5H\u0392\nH\3H\3H\3H\5H\u0397\nH\3H\3H\3H\3H\3H\3H"+ - "\3H\3H\5H\u03a1\nH\3I\3I\3I\7I\u03a6\nI\fI\16I\u03a9\13I\3I\3I\3I\3I\3"+ - "I\3J\3J\3J\7J\u03b3\nJ\fJ\16J\u03b6\13J\3K\3K\3K\3L\3L\3L\5L\u03be\nL"+ - "\3L\3L\3M\3M\3M\7M\u03c5\nM\fM\16M\u03c8\13M\3N\7N\u03cb\nN\fN\16N\u03ce"+ - "\13N\3N\3N\3N\3N\3N\3O\6O\u03d6\nO\rO\16O\u03d7\3O\6O\u03db\nO\rO\16O"+ - "\u03dc\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\5P\u03e9\nP\3Q\3Q\5Q\u03ed\nQ\3Q"+ - "\3Q\5Q\u03f1\nQ\3Q\3Q\5Q\u03f5\nQ\5Q\u03f7\nQ\3R\3R\5R\u03fb\nR\3S\7S"+ - "\u03fe\nS\fS\16S\u0401\13S\3S\3S\3S\3S\3S\3T\3T\3U\3U\3U\3U\3V\3V\3V\7"+ - "V\u0411\nV\fV\16V\u0414\13V\3W\3W\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y"+ - "\3Y\3Y\3Y\5Y\u0427\nY\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u0437"+ - "\nY\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y"+ - "\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u045c\nY\3Y\3Y\3Y\3Y\3Y\3Y"+ - "\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u046f\nY\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y"+ - "\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u0481\nY\3Y\3Y\3Y\3Y\3Y\3Y\7Y\u0489\nY\fY"+ - "\16Y\u048c\13Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ - "Z\5Z\u04a1\nZ\5Z\u04a3\nZ\3[\3[\3[\3[\3[\3[\3[\5[\u04ac\n[\5[\u04ae\n"+ - "[\3\\\3\\\5\\\u04b2\n\\\3\\\3\\\3\\\5\\\u04b7\n\\\7\\\u04b9\n\\\f\\\16"+ - "\\\u04bc\13\\\3\\\5\\\u04bf\n\\\3]\3]\5]\u04c3\n]\3]\3]\3^\3^\3^\3^\7"+ - "^\u04cb\n^\f^\16^\u04ce\13^\3^\3^\3^\3^\3^\3^\3^\7^\u04d7\n^\f^\16^\u04da"+ - "\13^\3^\3^\7^\u04de\n^\f^\16^\u04e1\13^\5^\u04e3\n^\3_\3_\5_\u04e7\n_"+ - "\3`\3`\3`\3a\3a\3a\3a\3b\3b\3b\5b\u04f3\nb\3c\3c\3c\5c\u04f8\nc\3d\3d"+ - "\3d\3d\5d\u04fe\nd\5d\u0500\nd\3e\3e\3e\3e\5e\u0506\ne\3f\3f\5f\u050a"+ - "\nf\3f\3f\3f\2g\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62"+ - "\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+ - "\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0"+ - "\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8"+ - "\u00ba\u00bc\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\2\16\6\2 ,,\60"+ - "\60\63\63\6\2\3\3\24\24#%()\n\2\5\5\7\7\n\n\20\20\26\26\35\35\37\37\'"+ - "\'\4\2\23\23**\3\2\65:\3\2QT\3\2GH\4\2UVZZ\3\2ST\4\2EFLM\4\2KKNN\3\2Q"+ - "R\u058b\2\u00cd\3\2\2\2\4\u00e0\3\2\2\2\6\u00e7\3\2\2\2\b\u010f\3\2\2"+ - "\2\n\u0113\3\2\2\2\f\u0117\3\2\2\2\16\u011b\3\2\2\2\20\u011d\3\2\2\2\22"+ - "\u012c\3\2\2\2\24\u0137\3\2\2\2\26\u013c\3\2\2\2\30\u0144\3\2\2\2\32\u0156"+ - "\3\2\2\2\34\u0161\3\2\2\2\36\u016b\3\2\2\2 \u0172\3\2\2\2\"\u017d\3\2"+ - "\2\2$\u0185\3\2\2\2&\u018e\3\2\2\2(\u01a3\3\2\2\2*\u01ae\3\2\2\2,\u01b2"+ - "\3\2\2\2.\u01c5\3\2\2\2\60\u01c8\3\2\2\2\62\u01d0\3\2\2\2\64\u01d3\3\2"+ - "\2\2\66\u01df\3\2\2\28\u01e8\3\2\2\2:\u01ea\3\2\2\2<\u01f5\3\2\2\2>\u0202"+ - "\3\2\2\2@\u0213\3\2\2\2B\u0216\3\2\2\2D\u021e\3\2\2\2F\u0223\3\2\2\2H"+ - "\u022d\3\2\2\2J\u022f\3\2\2\2L\u023f\3\2\2\2N\u0251\3\2\2\2P\u0253\3\2"+ - "\2\2R\u0261\3\2\2\2T\u0263\3\2\2\2V\u0274\3\2\2\2X\u0276\3\2\2\2Z\u027e"+ - "\3\2\2\2\\\u0291\3\2\2\2^\u0296\3\2\2\2`\u029f\3\2\2\2b\u02a6\3\2\2\2"+ - "d\u02a8\3\2\2\2f\u02aa\3\2\2\2h\u02b2\3\2\2\2j\u02b4\3\2\2\2l\u02be\3"+ - "\2\2\2n\u02c0\3\2\2\2p\u02c8\3\2\2\2r\u02cf\3\2\2\2t\u02d1\3\2\2\2v\u02e1"+ - "\3\2\2\2x\u02e6\3\2\2\2z\u02f7\3\2\2\2|\u030d\3\2\2\2~\u0311\3\2\2\2\u0080"+ - "\u0313\3\2\2\2\u0082\u0319\3\2\2\2\u0084\u031b\3\2\2\2\u0086\u031e\3\2"+ - "\2\2\u0088\u032a\3\2\2\2\u008a\u032c\3\2\2\2\u008c\u0332\3\2\2\2\u008e"+ - "\u03a0\3\2\2\2\u0090\u03a2\3\2\2\2\u0092\u03af\3\2\2\2\u0094\u03b7\3\2"+ - "\2\2\u0096\u03ba\3\2\2\2\u0098\u03c1\3\2\2\2\u009a\u03cc\3\2\2\2\u009c"+ - "\u03d5\3\2\2\2\u009e\u03e8\3\2\2\2\u00a0\u03f6\3\2\2\2\u00a2\u03fa\3\2"+ - "\2\2\u00a4\u03ff\3\2\2\2\u00a6\u0407\3\2\2\2\u00a8\u0409\3\2\2\2\u00aa"+ - "\u040d\3\2\2\2\u00ac\u0415\3\2\2\2\u00ae\u0417\3\2\2\2\u00b0\u0426\3\2"+ - "\2\2\u00b2\u04a2\3\2\2\2\u00b4\u04ad\3\2\2\2\u00b6\u04be\3\2\2\2\u00b8"+ - "\u04c0\3\2\2\2\u00ba\u04c6\3\2\2\2\u00bc\u04e4\3\2\2\2\u00be\u04e8\3\2"+ - "\2\2\u00c0\u04eb\3\2\2\2\u00c2\u04f2\3\2\2\2\u00c4\u04f7\3\2\2\2\u00c6"+ - "\u04ff\3\2\2\2\u00c8\u0505\3\2\2\2\u00ca\u0507\3\2\2\2\u00cc\u00ce\5\4"+ - "\3\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d2\3\2\2\2\u00cf"+ - "\u00d1\5\6\4\2\u00d0\u00cf\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2"+ - "\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d8\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d5"+ - "\u00d7\5\b\5\2\u00d6\u00d5\3\2\2\2\u00d7\u00da\3\2\2\2\u00d8\u00d6\3\2"+ - "\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00db\3\2\2\2\u00da\u00d8\3\2\2\2\u00db"+ - "\u00dc\7\2\2\3\u00dc\3\3\2\2\2\u00dd\u00df\5j\66\2\u00de\u00dd\3\2\2\2"+ - "\u00df\u00e2\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e3"+ - "\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3\u00e4\7\"\2\2\u00e4\u00e5\5f\64\2\u00e5"+ - "\u00e6\7A\2\2\u00e6\5\3\2\2\2\u00e7\u00e9\7\33\2\2\u00e8\u00ea\7(\2\2"+ - "\u00e9\u00e8\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\u00ee"+ - "\5f\64\2\u00ec\u00ed\7C\2\2\u00ed\u00ef\7U\2\2\u00ee\u00ec\3\2\2\2\u00ee"+ - "\u00ef\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f1\7A\2\2\u00f1\7\3\2\2\2"+ - "\u00f2\u00f4\5\f\7\2\u00f3\u00f2\3\2\2\2\u00f4\u00f7\3\2\2\2\u00f5\u00f3"+ - "\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f8\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8"+ - "\u0110\5\20\t\2\u00f9\u00fb\5\f\7\2\u00fa\u00f9\3\2\2\2\u00fb\u00fe\3"+ - "\2\2\2\u00fc\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00ff\3\2\2\2\u00fe"+ - "\u00fc\3\2\2\2\u00ff\u0110\5\30\r\2\u0100\u0102\5\f\7\2\u0101\u0100\3"+ - "\2\2\2\u0102\u0105\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104"+ - "\u0106\3\2\2\2\u0105\u0103\3\2\2\2\u0106\u0110\5 \21\2\u0107\u0109\5\f"+ - "\7\2\u0108\u0107\3\2\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a"+ - "\u010b\3\2\2\2\u010b\u010d\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0110\5v"+ - "<\2\u010e\u0110\7A\2\2\u010f\u00f5\3\2\2\2\u010f\u00fc\3\2\2\2\u010f\u0103"+ - "\3\2\2\2\u010f\u010a\3\2\2\2\u010f\u010e\3\2\2\2\u0110\t\3\2\2\2\u0111"+ - "\u0114\5\f\7\2\u0112\u0114\t\2\2\2\u0113\u0111\3\2\2\2\u0113\u0112\3\2"+ - "\2\2\u0114\13\3\2\2\2\u0115\u0118\5j\66\2\u0116\u0118\t\3\2\2\u0117\u0115"+ - "\3\2\2\2\u0117\u0116\3\2\2\2\u0118\r\3\2\2\2\u0119\u011c\7\24\2\2\u011a"+ - "\u011c\5j\66\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2\2\2\u011c\17\3\2\2"+ - "\2\u011d\u011e\7\13\2\2\u011e\u0120\7f\2\2\u011f\u0121\5\22\n\2\u0120"+ - "\u011f\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0124\3\2\2\2\u0122\u0123\7\23"+ - "\2\2\u0123\u0125\5N(\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125\u0128"+ - "\3\2\2\2\u0126\u0127\7\32\2\2\u0127\u0129\5\"\22\2\u0128\u0126\3\2\2\2"+ - "\u0128\u0129\3\2\2\2\u0129\u012a\3\2\2\2\u012a\u012b\5$\23\2\u012b\21"+ - "\3\2\2\2\u012c\u012d\7F\2\2\u012d\u0132\5\24\13\2\u012e\u012f\7B\2\2\u012f"+ - "\u0131\5\24\13\2\u0130\u012e\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130\3"+ - "\2\2\2\u0132\u0133\3\2\2\2\u0133\u0135\3\2\2\2\u0134\u0132\3\2\2\2\u0135"+ - "\u0136\7E\2\2\u0136\23\3\2\2\2\u0137\u013a\7f\2\2\u0138\u0139\7\23\2\2"+ - "\u0139\u013b\5\26\f\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b\25"+ - "\3\2\2\2\u013c\u0141\5N(\2\u013d\u013e\7W\2\2\u013e\u0140\5N(\2\u013f"+ - "\u013d\3\2\2\2\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141\u0142\3\2"+ - "\2\2\u0142\27\3\2\2\2\u0143\u0141\3\2\2\2\u0144\u0145\7\22\2\2\u0145\u0148"+ - "\7f\2\2\u0146\u0147\7\32\2\2\u0147\u0149\5\"\22\2\u0148\u0146\3\2\2\2"+ - "\u0148\u0149\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014c\7=\2\2\u014b\u014d"+ - "\5\32\16\2\u014c\u014b\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u014f\3\2\2\2"+ - "\u014e\u0150\7B\2\2\u014f\u014e\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152"+ - "\3\2\2\2\u0151\u0153\5\36\20\2\u0152\u0151\3\2\2\2\u0152\u0153\3\2\2\2"+ - "\u0153\u0154\3\2\2\2\u0154\u0155\7>\2\2\u0155\31\3\2\2\2\u0156\u015b\5"+ - "\34\17\2\u0157\u0158\7B\2\2\u0158\u015a\5\34\17\2\u0159\u0157\3\2\2\2"+ - "\u015a\u015d\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\33"+ - "\3\2\2\2\u015d\u015b\3\2\2\2\u015e\u0160\5j\66\2\u015f\u015e\3\2\2\2\u0160"+ - "\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0164\3\2"+ - "\2\2\u0163\u0161\3\2\2\2\u0164\u0166\7f\2\2\u0165\u0167\5\u00caf\2\u0166"+ - "\u0165\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0169\3\2\2\2\u0168\u016a\5$"+ - "\23\2\u0169\u0168\3\2\2\2\u0169\u016a\3\2\2\2\u016a\35\3\2\2\2\u016b\u016f"+ - "\7A\2\2\u016c\u016e\5(\25\2\u016d\u016c\3\2\2\2\u016e\u0171\3\2\2\2\u016f"+ - "\u016d\3\2\2\2\u016f\u0170\3\2\2\2\u0170\37\3\2\2\2\u0171\u016f\3\2\2"+ - "\2\u0172\u0173\7\36\2\2\u0173\u0175\7f\2\2\u0174\u0176\5\22\n\2\u0175"+ - "\u0174\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0179\3\2\2\2\u0177\u0178\7\23"+ - "\2\2\u0178\u017a\5\"\22\2\u0179\u0177\3\2\2\2\u0179\u017a\3\2\2\2\u017a"+ - "\u017b\3\2\2\2\u017b\u017c\5&\24\2\u017c!\3\2\2\2\u017d\u0182\5N(\2\u017e"+ - "\u017f\7B\2\2\u017f\u0181\5N(\2\u0180\u017e\3\2\2\2\u0181\u0184\3\2\2"+ - "\2\u0182\u0180\3\2\2\2\u0182\u0183\3\2\2\2\u0183#\3\2\2\2\u0184\u0182"+ - "\3\2\2\2\u0185\u0189\7=\2\2\u0186\u0188\5(\25\2\u0187\u0186\3\2\2\2\u0188"+ - "\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018c\3\2"+ - "\2\2\u018b\u0189\3\2\2\2\u018c\u018d\7>\2\2\u018d%\3\2\2\2\u018e\u0192"+ - "\7=\2\2\u018f\u0191\5\66\34\2\u0190\u018f\3\2\2\2\u0191\u0194\3\2\2\2"+ - "\u0192\u0190\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u0195\3\2\2\2\u0194\u0192"+ - "\3\2\2\2\u0195\u0196\7>\2\2\u0196\'\3\2\2\2\u0197\u01a4\7A\2\2\u0198\u019a"+ - "\7(\2\2\u0199\u0198\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019b\3\2\2\2\u019b"+ - "\u01a4\5\u0086D\2\u019c\u019e\5\n\6\2\u019d\u019c\3\2\2\2\u019e\u01a1"+ - "\3\2\2\2\u019f\u019d\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1"+ - "\u019f\3\2\2\2\u01a2\u01a4\5*\26\2\u01a3\u0197\3\2\2\2\u01a3\u0199\3\2"+ - "\2\2\u01a3\u019f\3\2\2\2\u01a4)\3\2\2\2\u01a5\u01af\5,\27\2\u01a6\u01af"+ - "\5.\30\2\u01a7\u01af\5\64\33\2\u01a8\u01af\5\60\31\2\u01a9\u01af\5\62"+ - "\32\2\u01aa\u01af\5 \21\2\u01ab\u01af\5v<\2\u01ac\u01af\5\20\t\2\u01ad"+ - "\u01af\5\30\r\2\u01ae\u01a5\3\2\2\2\u01ae\u01a6\3\2\2\2\u01ae\u01a7\3"+ - "\2\2\2\u01ae\u01a8\3\2\2\2\u01ae\u01a9\3\2\2\2\u01ae\u01aa\3\2\2\2\u01ae"+ - "\u01ab\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af+\3\2\2\2"+ - "\u01b0\u01b3\5N(\2\u01b1\u01b3\7\62\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b1"+ - "\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5\7f\2\2\u01b5\u01ba\5Z.\2\u01b6"+ - "\u01b7\7?\2\2\u01b7\u01b9\7@\2\2\u01b8\u01b6\3\2\2\2\u01b9\u01bc\3\2\2"+ - "\2\u01ba\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb\u01bf\3\2\2\2\u01bc\u01ba"+ - "\3\2\2\2\u01bd\u01be\7/\2\2\u01be\u01c0\5X-\2\u01bf\u01bd\3\2\2\2\u01bf"+ - "\u01c0\3\2\2\2\u01c0\u01c3\3\2\2\2\u01c1\u01c4\5b\62\2\u01c2\u01c4\7A"+ - "\2\2\u01c3\u01c1\3\2\2\2\u01c3\u01c2\3\2\2\2\u01c4-\3\2\2\2\u01c5\u01c6"+ - "\5\22\n\2\u01c6\u01c7\5,\27\2\u01c7/\3\2\2\2\u01c8\u01c9\7f\2\2\u01c9"+ - "\u01cc\5Z.\2\u01ca\u01cb\7/\2\2\u01cb\u01cd\5X-\2\u01cc\u01ca\3\2\2\2"+ - "\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01cf\5d\63\2\u01cf\61"+ - "\3\2\2\2\u01d0\u01d1\5\22\n\2\u01d1\u01d2\5\60\31\2\u01d2\63\3\2\2\2\u01d3"+ - "\u01d4\5N(\2\u01d4\u01d5\5B\"\2\u01d5\u01d6\7A\2\2\u01d6\65\3\2\2\2\u01d7"+ - "\u01d9\5\n\6\2\u01d8\u01d7\3\2\2\2\u01d9\u01dc\3\2\2\2\u01da\u01d8\3\2"+ - "\2\2\u01da\u01db\3\2\2\2\u01db\u01dd\3\2\2\2\u01dc\u01da\3\2\2\2\u01dd"+ - "\u01e0\58\35\2\u01de\u01e0\7A\2\2\u01df\u01da\3\2\2\2\u01df\u01de\3\2"+ - "\2\2\u01e0\67\3\2\2\2\u01e1\u01e9\5:\36\2\u01e2\u01e9\5> \2\u01e3\u01e9"+ - "\5@!\2\u01e4\u01e9\5 \21\2\u01e5\u01e9\5v<\2\u01e6\u01e9\5\20\t\2\u01e7"+ - "\u01e9\5\30\r\2\u01e8\u01e1\3\2\2\2\u01e8\u01e2\3\2\2\2\u01e8\u01e3\3"+ - "\2\2\2\u01e8\u01e4\3\2\2\2\u01e8\u01e5\3\2\2\2\u01e8\u01e6\3\2\2\2\u01e8"+ - "\u01e7\3\2\2\2\u01e99\3\2\2\2\u01ea\u01eb\5N(\2\u01eb\u01f0\5<\37\2\u01ec"+ - "\u01ed\7B\2\2\u01ed\u01ef\5<\37\2\u01ee\u01ec\3\2\2\2\u01ef\u01f2\3\2"+ - "\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f3\3\2\2\2\u01f2"+ - "\u01f0\3\2\2\2\u01f3\u01f4\7A\2\2\u01f4;\3\2\2\2\u01f5\u01fa\7f\2\2\u01f6"+ - "\u01f7\7?\2\2\u01f7\u01f9\7@\2\2\u01f8\u01f6\3\2\2\2\u01f9\u01fc\3\2\2"+ - "\2\u01fa\u01f8\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fd\3\2\2\2\u01fc\u01fa"+ - "\3\2\2\2\u01fd\u01fe\7D\2\2\u01fe\u01ff\5H%\2\u01ff=\3\2\2\2\u0200\u0203"+ - "\5N(\2\u0201\u0203\7\62\2\2\u0202\u0200\3\2\2\2\u0202\u0201\3\2\2\2\u0203"+ - "\u0204\3\2\2\2\u0204\u0205\7f\2\2\u0205\u020a\5Z.\2\u0206\u0207\7?\2\2"+ - "\u0207\u0209\7@\2\2\u0208\u0206\3\2\2\2\u0209\u020c\3\2\2\2\u020a\u0208"+ - "\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020f\3\2\2\2\u020c\u020a\3\2\2\2\u020d"+ - "\u020e\7/\2\2\u020e\u0210\5X-\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2\2"+ - "\2\u0210\u0211\3\2\2\2\u0211\u0212\7A\2\2\u0212?\3\2\2\2\u0213\u0214\5"+ - "\22\n\2\u0214\u0215\5> \2\u0215A\3\2\2\2\u0216\u021b\5D#\2\u0217\u0218"+ - "\7B\2\2\u0218\u021a\5D#\2\u0219\u0217\3\2\2\2\u021a\u021d\3\2\2\2\u021b"+ - "\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021cC\3\2\2\2\u021d\u021b\3\2\2\2"+ - "\u021e\u0221\5F$\2\u021f\u0220\7D\2\2\u0220\u0222\5H%\2\u0221\u021f\3"+ - "\2\2\2\u0221\u0222\3\2\2\2\u0222E\3\2\2\2\u0223\u0228\7f\2\2\u0224\u0225"+ - "\7?\2\2\u0225\u0227\7@\2\2\u0226\u0224\3\2\2\2\u0227\u022a\3\2\2\2\u0228"+ - "\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229G\3\2\2\2\u022a\u0228\3\2\2\2"+ - "\u022b\u022e\5J&\2\u022c\u022e\5\u00b0Y\2\u022d\u022b\3\2\2\2\u022d\u022c"+ - "\3\2\2\2\u022eI\3\2\2\2\u022f\u023b\7=\2\2\u0230\u0235\5H%\2\u0231\u0232"+ - "\7B\2\2\u0232\u0234\5H%\2\u0233\u0231\3\2\2\2\u0234\u0237\3\2\2\2\u0235"+ - "\u0233\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0239\3\2\2\2\u0237\u0235\3\2"+ - "\2\2\u0238\u023a\7B\2\2\u0239\u0238\3\2\2\2\u0239\u023a\3\2\2\2\u023a"+ - "\u023c\3\2\2\2\u023b\u0230\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023d\3\2"+ - "\2\2\u023d\u023e\7>\2\2\u023eK\3\2\2\2\u023f\u0240\7f\2\2\u0240M\3\2\2"+ - "\2\u0241\u0246\5P)\2\u0242\u0243\7?\2\2\u0243\u0245\7@\2\2\u0244\u0242"+ - "\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2\u0246\u0247\3\2\2\2\u0247"+ - "\u0252\3\2\2\2\u0248\u0246\3\2\2\2\u0249\u024e\5R*\2\u024a\u024b\7?\2"+ - "\2\u024b\u024d\7@\2\2\u024c\u024a\3\2\2\2\u024d\u0250\3\2\2\2\u024e\u024c"+ - "\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0251"+ - "\u0241\3\2\2\2\u0251\u0249\3\2\2\2\u0252O\3\2\2\2\u0253\u0255\7f\2\2\u0254"+ - "\u0256\5T+\2\u0255\u0254\3\2\2\2\u0255\u0256\3\2\2\2\u0256\u025e\3\2\2"+ - "\2\u0257\u0258\7C\2\2\u0258\u025a\7f\2\2\u0259\u025b\5T+\2\u025a\u0259"+ - "\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025d\3\2\2\2\u025c\u0257\3\2\2\2\u025d"+ - "\u0260\3\2\2\2\u025e\u025c\3\2\2\2\u025e\u025f\3\2\2\2\u025fQ\3\2\2\2"+ - "\u0260\u025e\3\2\2\2\u0261\u0262\t\4\2\2\u0262S\3\2\2\2\u0263\u0264\7"+ - "F\2\2\u0264\u0269\5V,\2\u0265\u0266\7B\2\2\u0266\u0268\5V,\2\u0267\u0265"+ - "\3\2\2\2\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a"+ - "\u026c\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026d\7E\2\2\u026dU\3\2\2\2\u026e"+ - "\u0275\5N(\2\u026f\u0272\7I\2\2\u0270\u0271\t\5\2\2\u0271\u0273\5N(\2"+ - "\u0272\u0270\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0275\3\2\2\2\u0274\u026e"+ - "\3\2\2\2\u0274\u026f\3\2\2\2\u0275W\3\2\2\2\u0276\u027b\5f\64\2\u0277"+ - "\u0278\7B\2\2\u0278\u027a\5f\64\2\u0279\u0277\3\2\2\2\u027a\u027d\3\2"+ - "\2\2\u027b\u0279\3\2\2\2\u027b\u027c\3\2\2\2\u027cY\3\2\2\2\u027d\u027b"+ - "\3\2\2\2\u027e\u0280\7;\2\2\u027f\u0281\5\\/\2\u0280\u027f\3\2\2\2\u0280"+ - "\u0281\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0283\7<\2\2\u0283[\3\2\2\2\u0284"+ - "\u0289\5^\60\2\u0285\u0286\7B\2\2\u0286\u0288\5^\60\2\u0287\u0285\3\2"+ - "\2\2\u0288\u028b\3\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a"+ - "\u028e\3\2\2\2\u028b\u0289\3\2\2\2\u028c\u028d\7B\2\2\u028d\u028f\5`\61"+ - "\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028f\u0292\3\2\2\2\u0290\u0292"+ - "\5`\61\2\u0291\u0284\3\2\2\2\u0291\u0290\3\2\2\2\u0292]\3\2\2\2\u0293"+ - "\u0295\5\16\b\2\u0294\u0293\3\2\2\2\u0295\u0298\3\2\2\2\u0296\u0294\3"+ - "\2\2\2\u0296\u0297\3\2\2\2\u0297\u0299\3\2\2\2\u0298\u0296\3\2\2\2\u0299"+ - "\u029a\5N(\2\u029a\u029b\5F$\2\u029b_\3\2\2\2\u029c\u029e\5\16\b\2\u029d"+ - "\u029c\3\2\2\2\u029e\u02a1\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2"+ - "\2\2\u02a0\u02a2\3\2\2\2\u02a1\u029f\3\2\2\2\u02a2\u02a3\5N(\2\u02a3\u02a4"+ - "\7h\2\2\u02a4\u02a5\5F$\2\u02a5a\3\2\2\2\u02a6\u02a7\5\u0086D\2\u02a7"+ - "c\3\2\2\2\u02a8\u02a9\5\u0086D\2\u02a9e\3\2\2\2\u02aa\u02af\7f\2\2\u02ab"+ - "\u02ac\7C\2\2\u02ac\u02ae\7f\2\2\u02ad\u02ab\3\2\2\2\u02ae\u02b1\3\2\2"+ - "\2\u02af\u02ad\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0g\3\2\2\2\u02b1\u02af"+ - "\3\2\2\2\u02b2\u02b3\t\6\2\2\u02b3i\3\2\2\2\u02b4\u02b5\7g\2\2\u02b5\u02bc"+ - "\5l\67\2\u02b6\u02b9\7;\2\2\u02b7\u02ba\5n8\2\u02b8\u02ba\5r:\2\u02b9"+ - "\u02b7\3\2\2\2\u02b9\u02b8\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\3\2"+ - "\2\2\u02bb\u02bd\7<\2\2\u02bc\u02b6\3\2\2\2\u02bc\u02bd\3\2\2\2\u02bd"+ - "k\3\2\2\2\u02be\u02bf\5f\64\2\u02bfm\3\2\2\2\u02c0\u02c5\5p9\2\u02c1\u02c2"+ - "\7B\2\2\u02c2\u02c4\5p9\2\u02c3\u02c1\3\2\2\2\u02c4\u02c7\3\2\2\2\u02c5"+ - "\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6o\3\2\2\2\u02c7\u02c5\3\2\2\2"+ - "\u02c8\u02c9\7f\2\2\u02c9\u02ca\7D\2\2\u02ca\u02cb\5r:\2\u02cbq\3\2\2"+ - "\2\u02cc\u02d0\5\u00b0Y\2\u02cd\u02d0\5j\66\2\u02ce\u02d0\5t;\2\u02cf"+ - "\u02cc\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02ce\3\2\2\2\u02d0s\3\2\2\2"+ - "\u02d1\u02da\7=\2\2\u02d2\u02d7\5r:\2\u02d3\u02d4\7B\2\2\u02d4\u02d6\5"+ - "r:\2\u02d5\u02d3\3\2\2\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7"+ - "\u02d8\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02d2\3\2"+ - "\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2\2\2\u02dc\u02de\7B\2\2\u02dd"+ - "\u02dc\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e0\7>"+ - "\2\2\u02e0u\3\2\2\2\u02e1\u02e2\7g\2\2\u02e2\u02e3\7\36\2\2\u02e3\u02e4"+ - "\7f\2\2\u02e4\u02e5\5x=\2\u02e5w\3\2\2\2\u02e6\u02ea\7=\2\2\u02e7\u02e9"+ - "\5z>\2\u02e8\u02e7\3\2\2\2\u02e9\u02ec\3\2\2\2\u02ea\u02e8\3\2\2\2\u02ea"+ - "\u02eb\3\2\2\2\u02eb\u02ed\3\2\2\2\u02ec\u02ea\3\2\2\2\u02ed\u02ee\7>"+ - "\2\2\u02eey\3\2\2\2\u02ef\u02f1\5\n\6\2\u02f0\u02ef\3\2\2\2\u02f1\u02f4"+ - "\3\2\2\2\u02f2\u02f0\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f5\3\2\2\2\u02f4"+ - "\u02f2\3\2\2\2\u02f5\u02f8\5|?\2\u02f6\u02f8\7A\2\2\u02f7\u02f2\3\2\2"+ - "\2\u02f7\u02f6\3\2\2\2\u02f8{\3\2\2\2\u02f9\u02fa\5N(\2\u02fa\u02fb\5"+ - "~@\2\u02fb\u02fc\7A\2\2\u02fc\u030e\3\2\2\2\u02fd\u02ff\5\20\t\2\u02fe"+ - "\u0300\7A\2\2\u02ff\u02fe\3\2\2\2\u02ff\u0300\3\2\2\2\u0300\u030e\3\2"+ - "\2\2\u0301\u0303\5 \21\2\u0302\u0304\7A\2\2\u0303\u0302\3\2\2\2\u0303"+ - "\u0304\3\2\2\2\u0304\u030e\3\2\2\2\u0305\u0307\5\30\r\2\u0306\u0308\7"+ - "A\2\2\u0307\u0306\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u030e\3\2\2\2\u0309"+ - "\u030b\5v<\2\u030a\u030c\7A\2\2\u030b\u030a\3\2\2\2\u030b\u030c\3\2\2"+ - "\2\u030c\u030e\3\2\2\2\u030d\u02f9\3\2\2\2\u030d\u02fd\3\2\2\2\u030d\u0301"+ - "\3\2\2\2\u030d\u0305\3\2\2\2\u030d\u0309\3\2\2\2\u030e}\3\2\2\2\u030f"+ - "\u0312\5\u0080A\2\u0310\u0312\5\u0082B\2\u0311\u030f\3\2\2\2\u0311\u0310"+ - "\3\2\2\2\u0312\177\3\2\2\2\u0313\u0314\7f\2\2\u0314\u0315\7;\2\2\u0315"+ - "\u0317\7<\2\2\u0316\u0318\5\u0084C\2\u0317\u0316\3\2\2\2\u0317\u0318\3"+ - "\2\2\2\u0318\u0081\3\2\2\2\u0319\u031a\5B\"\2\u031a\u0083\3\2\2\2\u031b"+ - "\u031c\7\16\2\2\u031c\u031d\5r:\2\u031d\u0085\3\2\2\2\u031e\u0322\7=\2"+ - "\2\u031f\u0321\5\u0088E\2\u0320\u031f\3\2\2\2\u0321\u0324\3\2\2\2\u0322"+ - "\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0325\3\2\2\2\u0324\u0322\3\2"+ - "\2\2\u0325\u0326\7>\2\2\u0326\u0087\3\2\2\2\u0327\u032b\5\u008aF\2\u0328"+ - "\u032b\5\u008eH\2\u0329\u032b\5\b\5\2\u032a\u0327\3\2\2\2\u032a\u0328"+ - "\3\2\2\2\u032a\u0329\3\2\2\2\u032b\u0089\3\2\2\2\u032c\u032d\5\u008cG"+ - "\2\u032d\u032e\7A\2\2\u032e\u008b\3\2\2\2\u032f\u0331\5\16\b\2\u0330\u032f"+ - "\3\2\2\2\u0331\u0334\3\2\2\2\u0332\u0330\3\2\2\2\u0332\u0333\3\2\2\2\u0333"+ - "\u0335\3\2\2\2\u0334\u0332\3\2\2\2\u0335\u0336\5N(\2\u0336\u0337\5B\""+ - "\2\u0337\u008d\3\2\2\2\u0338\u03a1\5\u0086D\2\u0339\u033a\7\4\2\2\u033a"+ - "\u033d\5\u00b0Y\2\u033b\u033c\7J\2\2\u033c\u033e\5\u00b0Y\2\u033d\u033b"+ - "\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u0340\7A\2\2\u0340"+ - "\u03a1\3\2\2\2\u0341\u0342\7\30\2\2\u0342\u0343\5\u00a8U\2\u0343\u0346"+ - "\5\u008eH\2\u0344\u0345\7\21\2\2\u0345\u0347\5\u008eH\2\u0346\u0344\3"+ - "\2\2\2\u0346\u0347\3\2\2\2\u0347\u03a1\3\2\2\2\u0348\u0349\7\27\2\2\u0349"+ - "\u034a\7;\2\2\u034a\u034b\5\u00a0Q\2\u034b\u034c\7<\2\2\u034c\u034d\5"+ - "\u008eH\2\u034d\u03a1\3\2\2\2\u034e\u034f\7\64\2\2\u034f\u0350\5\u00a8"+ - "U\2\u0350\u0351\5\u008eH\2\u0351\u03a1\3\2\2\2\u0352\u0353\7\17\2\2\u0353"+ - "\u0354\5\u008eH\2\u0354\u0355\7\64\2\2\u0355\u0356\5\u00a8U\2\u0356\u0357"+ - "\7A\2\2\u0357\u03a1\3\2\2\2\u0358\u0359\7\61\2\2\u0359\u0363\5\u0086D"+ - "\2\u035a\u035c\5\u0090I\2\u035b\u035a\3\2\2\2\u035c\u035d\3\2\2\2\u035d"+ - "\u035b\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u0360\3\2\2\2\u035f\u0361\5\u0094"+ - "K\2\u0360\u035f\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u0364\3\2\2\2\u0362"+ - "\u0364\5\u0094K\2\u0363\u035b\3\2\2\2\u0363\u0362\3\2\2\2\u0364\u03a1"+ - "\3\2\2\2\u0365\u0366\7\61\2\2\u0366\u0367\5\u0096L\2\u0367\u036b\5\u0086"+ - "D\2\u0368\u036a\5\u0090I\2\u0369\u0368\3\2\2\2\u036a\u036d\3\2\2\2\u036b"+ - "\u0369\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036f\3\2\2\2\u036d\u036b\3\2"+ - "\2\2\u036e\u0370\5\u0094K\2\u036f\u036e\3\2\2\2\u036f\u0370\3\2\2\2\u0370"+ - "\u03a1\3\2\2\2\u0371\u0372\7+\2\2\u0372\u0373\5\u00a8U\2\u0373\u0377\7"+ - "=\2\2\u0374\u0376\5\u009cO\2\u0375\u0374\3\2\2\2\u0376\u0379\3\2\2\2\u0377"+ - "\u0375\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u037d\3\2\2\2\u0379\u0377\3\2"+ - "\2\2\u037a\u037c\5\u009eP\2\u037b\u037a\3\2\2\2\u037c\u037f\3\2\2\2\u037d"+ - "\u037b\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u0380\3\2\2\2\u037f\u037d\3\2"+ - "\2\2\u0380\u0381\7>\2\2\u0381\u03a1\3\2\2\2\u0382\u0383\7,\2\2\u0383\u0384"+ - "\5\u00a8U\2\u0384\u0385\5\u0086D\2\u0385\u03a1\3\2\2\2\u0386\u0388\7&"+ - "\2\2\u0387\u0389\5\u00b0Y\2\u0388\u0387\3\2\2\2\u0388\u0389\3\2\2\2\u0389"+ - "\u038a\3\2\2\2\u038a\u03a1\7A\2\2\u038b\u038c\7.\2\2\u038c\u038d\5\u00b0"+ - "Y\2\u038d\u038e\7A\2\2\u038e\u03a1\3\2\2\2\u038f\u0391\7\6\2\2\u0390\u0392"+ - "\7f\2\2\u0391\u0390\3\2\2\2\u0391\u0392\3\2\2\2\u0392\u0393\3\2\2\2\u0393"+ - "\u03a1\7A\2\2\u0394\u0396\7\r\2\2\u0395\u0397\7f\2\2\u0396\u0395\3\2\2"+ - "\2\u0396\u0397\3\2\2\2\u0397\u0398\3\2\2\2\u0398\u03a1\7A\2\2\u0399\u03a1"+ - "\7A\2\2\u039a\u039b\5\u00acW\2\u039b\u039c\7A\2\2\u039c\u03a1\3\2\2\2"+ - "\u039d\u039e\7f\2\2\u039e\u039f\7J\2\2\u039f\u03a1\5\u008eH\2\u03a0\u0338"+ - "\3\2\2\2\u03a0\u0339\3\2\2\2\u03a0\u0341\3\2\2\2\u03a0\u0348\3\2\2\2\u03a0"+ - "\u034e\3\2\2\2\u03a0\u0352\3\2\2\2\u03a0\u0358\3\2\2\2\u03a0\u0365\3\2"+ - "\2\2\u03a0\u0371\3\2\2\2\u03a0\u0382\3\2\2\2\u03a0\u0386\3\2\2\2\u03a0"+ - "\u038b\3\2\2\2\u03a0\u038f\3\2\2\2\u03a0\u0394\3\2\2\2\u03a0\u0399\3\2"+ - "\2\2\u03a0\u039a\3\2\2\2\u03a0\u039d\3\2\2\2\u03a1\u008f\3\2\2\2\u03a2"+ - "\u03a3\7\t\2\2\u03a3\u03a7\7;\2\2\u03a4\u03a6\5\16\b\2\u03a5\u03a4\3\2"+ - "\2\2\u03a6\u03a9\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8"+ - "\u03aa\3\2\2\2\u03a9\u03a7\3\2\2\2\u03aa\u03ab\5\u0092J\2\u03ab\u03ac"+ - "\7f\2\2\u03ac\u03ad\7<\2\2\u03ad\u03ae\5\u0086D\2\u03ae\u0091\3\2\2\2"+ - "\u03af\u03b4\5f\64\2\u03b0\u03b1\7X\2\2\u03b1\u03b3\5f\64\2\u03b2\u03b0"+ - "\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5"+ - "\u0093\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\7\25\2\2\u03b8\u03b9\5"+ - "\u0086D\2\u03b9\u0095\3\2\2\2\u03ba\u03bb\7;\2\2\u03bb\u03bd\5\u0098M"+ - "\2\u03bc\u03be\7A\2\2\u03bd\u03bc\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03bf"+ - "\3\2\2\2\u03bf\u03c0\7<\2\2\u03c0\u0097\3\2\2\2\u03c1\u03c6\5\u009aN\2"+ - "\u03c2\u03c3\7A\2\2\u03c3\u03c5\5\u009aN\2\u03c4\u03c2\3\2\2\2\u03c5\u03c8"+ - "\3\2\2\2\u03c6\u03c4\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u0099\3\2\2\2\u03c8"+ - "\u03c6\3\2\2\2\u03c9\u03cb\5\16\b\2\u03ca\u03c9\3\2\2\2\u03cb\u03ce\3"+ - "\2\2\2\u03cc\u03ca\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u03cf\3\2\2\2\u03ce"+ - "\u03cc\3\2\2\2\u03cf\u03d0\5P)\2\u03d0\u03d1\5F$\2\u03d1\u03d2\7D\2\2"+ - "\u03d2\u03d3\5\u00b0Y\2\u03d3\u009b\3\2\2\2\u03d4\u03d6\5\u009eP\2\u03d5"+ - "\u03d4\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03d5\3\2\2\2\u03d7\u03d8\3\2"+ - "\2\2\u03d8\u03da\3\2\2\2\u03d9\u03db\5\u0088E\2\u03da\u03d9\3\2\2\2\u03db"+ - "\u03dc\3\2\2\2\u03dc\u03da\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u009d\3\2"+ - "\2\2\u03de\u03df\7\b\2\2\u03df\u03e0\5\u00aeX\2\u03e0\u03e1\7J\2\2\u03e1"+ - "\u03e9\3\2\2\2\u03e2\u03e3\7\b\2\2\u03e3\u03e4\5L\'\2\u03e4\u03e5\7J\2"+ - "\2\u03e5\u03e9\3\2\2\2\u03e6\u03e7\7\16\2\2\u03e7\u03e9\7J\2\2\u03e8\u03de"+ - "\3\2\2\2\u03e8\u03e2\3\2\2\2\u03e8\u03e6\3\2\2\2\u03e9\u009f\3\2\2\2\u03ea"+ - "\u03f7\5\u00a4S\2\u03eb\u03ed\5\u00a2R\2\u03ec\u03eb\3\2\2\2\u03ec\u03ed"+ - "\3\2\2\2\u03ed\u03ee\3\2\2\2\u03ee\u03f0\7A\2\2\u03ef\u03f1\5\u00b0Y\2"+ - "\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f4"+ - "\7A\2\2\u03f3\u03f5\5\u00a6T\2\u03f4\u03f3\3\2\2\2\u03f4\u03f5\3\2\2\2"+ - "\u03f5\u03f7\3\2\2\2\u03f6\u03ea\3\2\2\2\u03f6\u03ec\3\2\2\2\u03f7\u00a1"+ - "\3\2\2\2\u03f8\u03fb\5\u008cG\2\u03f9\u03fb\5\u00aaV\2\u03fa\u03f8\3\2"+ - "\2\2\u03fa\u03f9\3\2\2\2\u03fb\u00a3\3\2\2\2\u03fc\u03fe\5\16\b\2\u03fd"+ - "\u03fc\3\2\2\2\u03fe\u0401\3\2\2\2\u03ff\u03fd\3\2\2\2\u03ff\u0400\3\2"+ - "\2\2\u0400\u0402\3\2\2\2\u0401\u03ff\3\2\2\2\u0402\u0403\5N(\2\u0403\u0404"+ - "\7f\2\2\u0404\u0405\7J\2\2\u0405\u0406\5\u00b0Y\2\u0406\u00a5\3\2\2\2"+ - "\u0407\u0408\5\u00aaV\2\u0408\u00a7\3\2\2\2\u0409\u040a\7;\2\2\u040a\u040b"+ - "\5\u00b0Y\2\u040b\u040c\7<\2\2\u040c\u00a9\3\2\2\2\u040d\u0412\5\u00b0"+ - "Y\2\u040e\u040f\7B\2\2\u040f\u0411\5\u00b0Y\2\u0410\u040e\3\2\2\2\u0411"+ - "\u0414\3\2\2\2\u0412\u0410\3\2\2\2\u0412\u0413\3\2\2\2\u0413\u00ab\3\2"+ - "\2\2\u0414\u0412\3\2\2\2\u0415\u0416\5\u00b0Y\2\u0416\u00ad\3\2\2\2\u0417"+ - "\u0418\5\u00b0Y\2\u0418\u00af\3\2\2\2\u0419\u041a\bY\1\2\u041a\u041b\7"+ - ";\2\2\u041b\u041c\5N(\2\u041c\u041d\7<\2\2\u041d\u041e\5\u00b0Y\2\u041e"+ - "\u0427\3\2\2\2\u041f\u0420\t\7\2\2\u0420\u0427\5\u00b0Y\2\u0421\u0422"+ - "\t\b\2\2\u0422\u0427\5\u00b0Y\2\u0423\u0427\5\u00b2Z\2\u0424\u0425\7!"+ - "\2\2\u0425\u0427\5\u00b4[\2\u0426\u0419\3\2\2\2\u0426\u041f\3\2\2\2\u0426"+ - "\u0421\3\2\2\2\u0426\u0423\3\2\2\2\u0426\u0424\3\2\2\2\u0427\u048a\3\2"+ - "\2\2\u0428\u0429\6Y\2\3\u0429\u042a\t\t\2\2\u042a\u0489\5\u00b0Y\2\u042b"+ - "\u042c\6Y\3\3\u042c\u042d\t\n\2\2\u042d\u0489\5\u00b0Y\2\u042e\u0436\6"+ - "Y\4\3\u042f\u0430\7F\2\2\u0430\u0437\7F\2\2\u0431\u0432\7E\2\2\u0432\u0433"+ - "\7E\2\2\u0433\u0437\7E\2\2\u0434\u0435\7E\2\2\u0435\u0437\7E\2\2\u0436"+ - "\u042f\3\2\2\2\u0436\u0431\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u0438\3\2"+ - "\2\2\u0438\u0489\5\u00b0Y\2\u0439\u043a\6Y\5\3\u043a\u043b\t\13\2\2\u043b"+ - "\u0489\5\u00b0Y\2\u043c\u043d\6Y\6\3\u043d\u043e\t\f\2\2\u043e\u0489\5"+ - "\u00b0Y\2\u043f\u0440\6Y\7\3\u0440\u0441\7W\2\2\u0441\u0489\5\u00b0Y\2"+ - "\u0442\u0443\6Y\b\3\u0443\u0444\7Y\2\2\u0444\u0489\5\u00b0Y\2\u0445\u0446"+ - "\6Y\t\3\u0446\u0447\7X\2\2\u0447\u0489\5\u00b0Y\2\u0448\u0449\6Y\n\3\u0449"+ - "\u044a\7O\2\2\u044a\u0489\5\u00b0Y\2\u044b\u044c\6Y\13\3\u044c\u044d\7"+ - "P\2\2\u044d\u0489\5\u00b0Y\2\u044e\u045b\6Y\f\3\u044f\u045c\7D\2\2\u0450"+ - "\u045c\7[\2\2\u0451\u045c\7\\\2\2\u0452\u045c\7]\2\2\u0453\u045c\7^\2"+ - "\2\u0454\u045c\7_\2\2\u0455\u045c\7`\2\2\u0456\u045c\7a\2\2\u0457\u045c"+ - "\7d\2\2\u0458\u045c\7e\2\2\u0459\u045c\7c\2\2\u045a\u045c\7b\2\2\u045b"+ - "\u044f\3\2\2\2\u045b\u0450\3\2\2\2\u045b\u0451\3\2\2\2\u045b\u0452\3\2"+ - "\2\2\u045b\u0453\3\2\2\2\u045b\u0454\3\2\2\2\u045b\u0455\3\2\2\2\u045b"+ - "\u0456\3\2\2\2\u045b\u0457\3\2\2\2\u045b\u0458\3\2\2\2\u045b\u0459\3\2"+ - "\2\2\u045b\u045a\3\2\2\2\u045c\u045d\3\2\2\2\u045d\u0489\5\u00b0Y\2\u045e"+ - "\u045f\6Y\r\3\u045f\u0460\7I\2\2\u0460\u0461\5\u00b0Y\2\u0461\u0462\7"+ - "J\2\2\u0462\u0463\5\u00b0Y\2\u0463\u0489\3\2\2\2\u0464\u0465\6Y\16\3\u0465"+ - "\u0466\7C\2\2\u0466\u0489\7f\2\2\u0467\u0468\6Y\17\3\u0468\u0469\7C\2"+ - "\2\u0469\u0489\7-\2\2\u046a\u046b\6Y\20\3\u046b\u046c\7C\2\2\u046c\u046e"+ - "\7!\2\2\u046d\u046f\5\u00c0a\2\u046e\u046d\3\2\2\2\u046e\u046f\3\2\2\2"+ - "\u046f\u0470\3\2\2\2\u0470\u0489\5\u00b8]\2\u0471\u0472\6Y\21\3\u0472"+ - "\u0473\7C\2\2\u0473\u0474\7*\2\2\u0474\u0489\5\u00c6d\2\u0475\u0476\6"+ - "Y\22\3\u0476\u0477\7C\2\2\u0477\u0489\5\u00be`\2\u0478\u0479\6Y\23\3\u0479"+ - "\u047a\7?\2\2\u047a\u047b\5\u00b0Y\2\u047b\u047c\7@\2\2\u047c\u0489\3"+ - "\2\2\2\u047d\u047e\6Y\24\3\u047e\u0480\7;\2\2\u047f\u0481\5\u00aaV\2\u0480"+ - "\u047f\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u0482\3\2\2\2\u0482\u0489\7<"+ - "\2\2\u0483\u0484\6Y\25\3\u0484\u0489\t\r\2\2\u0485\u0486\6Y\26\3\u0486"+ - "\u0487\7\34\2\2\u0487\u0489\5N(\2\u0488\u0428\3\2\2\2\u0488\u042b\3\2"+ - "\2\2\u0488\u042e\3\2\2\2\u0488\u0439\3\2\2\2\u0488\u043c\3\2\2\2\u0488"+ - "\u043f\3\2\2\2\u0488\u0442\3\2\2\2\u0488\u0445\3\2\2\2\u0488\u0448\3\2"+ - "\2\2\u0488\u044b\3\2\2\2\u0488\u044e\3\2\2\2\u0488\u045e\3\2\2\2\u0488"+ - "\u0464\3\2\2\2\u0488\u0467\3\2\2\2\u0488\u046a\3\2\2\2\u0488\u0471\3\2"+ - "\2\2\u0488\u0475\3\2\2\2\u0488\u0478\3\2\2\2\u0488\u047d\3\2\2\2\u0488"+ - "\u0483\3\2\2\2\u0488\u0485\3\2\2\2\u0489\u048c\3\2\2\2\u048a\u0488\3\2"+ - "\2\2\u048a\u048b\3\2\2\2\u048b\u00b1\3\2\2\2\u048c\u048a\3\2\2\2\u048d"+ - "\u048e\7;\2\2\u048e\u048f\5\u00b0Y\2\u048f\u0490\7<\2\2\u0490\u04a3\3"+ - "\2\2\2\u0491\u04a3\7-\2\2\u0492\u04a3\7*\2\2\u0493\u04a3\5h\65\2\u0494"+ - "\u04a3\7f\2\2\u0495\u0496\5N(\2\u0496\u0497\7C\2\2\u0497\u0498\7\13\2"+ - "\2\u0498\u04a3\3\2\2\2\u0499\u049a\7\62\2\2\u049a\u049b\7C\2\2\u049b\u04a3"+ - "\7\13\2\2\u049c\u04a0\5\u00c0a\2\u049d\u04a1\5\u00c8e\2\u049e\u049f\7"+ - "-\2\2\u049f\u04a1\5\u00caf\2\u04a0\u049d\3\2\2\2\u04a0\u049e\3\2\2\2\u04a1"+ - "\u04a3\3\2\2\2\u04a2\u048d\3\2\2\2\u04a2\u0491\3\2\2\2\u04a2\u0492\3\2"+ - "\2\2\u04a2\u0493\3\2\2\2\u04a2\u0494\3\2\2\2\u04a2\u0495\3\2\2\2\u04a2"+ - "\u0499\3\2\2\2\u04a2\u049c\3\2\2\2\u04a3\u00b3\3\2\2\2\u04a4\u04a5\5\u00c0"+ - "a\2\u04a5\u04a6\5\u00b6\\\2\u04a6\u04a7\5\u00bc_\2\u04a7\u04ae\3\2\2\2"+ - "\u04a8\u04ab\5\u00b6\\\2\u04a9\u04ac\5\u00ba^\2\u04aa\u04ac\5\u00bc_\2"+ - "\u04ab\u04a9\3\2\2\2\u04ab\u04aa\3\2\2\2\u04ac\u04ae\3\2\2\2\u04ad\u04a4"+ - "\3\2\2\2\u04ad\u04a8\3\2\2\2\u04ae\u00b5\3\2\2\2\u04af\u04b1\7f\2\2\u04b0"+ - "\u04b2\5\u00c2b\2\u04b1\u04b0\3\2\2\2\u04b1\u04b2\3\2\2\2\u04b2\u04ba"+ - "\3\2\2\2\u04b3\u04b4\7C\2\2\u04b4\u04b6\7f\2\2\u04b5\u04b7\5\u00c2b\2"+ - "\u04b6\u04b5\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04b9\3\2\2\2\u04b8\u04b3"+ - "\3\2\2\2\u04b9\u04bc\3\2\2\2\u04ba\u04b8\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb"+ - "\u04bf\3\2\2\2\u04bc\u04ba\3\2\2\2\u04bd\u04bf\5R*\2\u04be\u04af\3\2\2"+ - "\2\u04be\u04bd\3\2\2\2\u04bf\u00b7\3\2\2\2\u04c0\u04c2\7f\2\2\u04c1\u04c3"+ - "\5\u00c4c\2\u04c2\u04c1\3\2\2\2\u04c2\u04c3\3\2\2\2\u04c3\u04c4\3\2\2"+ - "\2\u04c4\u04c5\5\u00bc_\2\u04c5\u00b9\3\2\2\2\u04c6\u04e2\7?\2\2\u04c7"+ - "\u04cc\7@\2\2\u04c8\u04c9\7?\2\2\u04c9\u04cb\7@\2\2\u04ca\u04c8\3\2\2"+ - "\2\u04cb\u04ce\3\2\2\2\u04cc\u04ca\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cf"+ - "\3\2\2\2\u04ce\u04cc\3\2\2\2\u04cf\u04e3\5J&\2\u04d0\u04d1\5\u00b0Y\2"+ - "\u04d1\u04d8\7@\2\2\u04d2\u04d3\7?\2\2\u04d3\u04d4\5\u00b0Y\2\u04d4\u04d5"+ - "\7@\2\2\u04d5\u04d7\3\2\2\2\u04d6\u04d2\3\2\2\2\u04d7\u04da\3\2\2\2\u04d8"+ - "\u04d6\3\2\2\2\u04d8\u04d9\3\2\2\2\u04d9\u04df\3\2\2\2\u04da\u04d8\3\2"+ - "\2\2\u04db\u04dc\7?\2\2\u04dc\u04de\7@\2\2\u04dd\u04db\3\2\2\2\u04de\u04e1"+ - "\3\2\2\2\u04df\u04dd\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u04e3\3\2\2\2\u04e1"+ - "\u04df\3\2\2\2\u04e2\u04c7\3\2\2\2\u04e2\u04d0\3\2\2\2\u04e3\u00bb\3\2"+ - "\2\2\u04e4\u04e6\5\u00caf\2\u04e5\u04e7\5$\23\2\u04e6\u04e5\3\2\2\2\u04e6"+ - "\u04e7\3\2\2\2\u04e7\u00bd\3\2\2\2\u04e8\u04e9\5\u00c0a\2\u04e9\u04ea"+ - "\5\u00c8e\2\u04ea\u00bf\3\2\2\2\u04eb\u04ec\7F\2\2\u04ec\u04ed\5\"\22"+ - "\2\u04ed\u04ee\7E\2\2\u04ee\u00c1\3\2\2\2\u04ef\u04f0\7F\2\2\u04f0\u04f3"+ - "\7E\2\2\u04f1\u04f3\5T+\2\u04f2\u04ef\3\2\2\2\u04f2\u04f1\3\2\2\2\u04f3"+ - "\u00c3\3\2\2\2\u04f4\u04f5\7F\2\2\u04f5\u04f8\7E\2\2\u04f6\u04f8\5\u00c0"+ - "a\2\u04f7\u04f4\3\2\2\2\u04f7\u04f6\3\2\2\2\u04f8\u00c5\3\2\2\2\u04f9"+ - "\u0500\5\u00caf\2\u04fa\u04fb\7C\2\2\u04fb\u04fd\7f\2\2\u04fc\u04fe\5"+ - "\u00caf\2\u04fd\u04fc\3\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u0500\3\2\2\2"+ - "\u04ff\u04f9\3\2\2\2\u04ff\u04fa\3\2\2\2\u0500\u00c7\3\2\2\2\u0501\u0502"+ - "\7*\2\2\u0502\u0506\5\u00c6d\2\u0503\u0504\7f\2\2\u0504\u0506\5\u00ca"+ - "f\2\u0505\u0501\3\2\2\2\u0505\u0503\3\2\2\2\u0506\u00c9\3\2\2\2\u0507"+ - "\u0509\7;\2\2\u0508\u050a\5\u00aaV\2\u0509\u0508\3\2\2\2\u0509\u050a\3"+ - "\2\2\2\u050a\u050b\3\2\2\2\u050b\u050c\7<\2\2\u050c\u00cb\3\2\2\2\u0098"+ - "\u00cd\u00d2\u00d8\u00e0\u00e9\u00ee\u00f5\u00fc\u0103\u010a\u010f\u0113"+ - "\u0117\u011b\u0120\u0124\u0128\u0132\u013a\u0141\u0148\u014c\u014f\u0152"+ - "\u015b\u0161\u0166\u0169\u016f\u0175\u0179\u0182\u0189\u0192\u0199\u019f"+ - "\u01a3\u01ae\u01b2\u01ba\u01bf\u01c3\u01cc\u01da\u01df\u01e8\u01f0\u01fa"+ - "\u0202\u020a\u020f\u021b\u0221\u0228\u022d\u0235\u0239\u023b\u0246\u024e"+ - "\u0251\u0255\u025a\u025e\u0269\u0272\u0274\u027b\u0280\u0289\u028e\u0291"+ - "\u0296\u029f\u02af\u02b9\u02bc\u02c5\u02cf\u02d7\u02da\u02dd\u02ea\u02f2"+ - "\u02f7\u02ff\u0303\u0307\u030b\u030d\u0311\u0317\u0322\u032a\u0332\u033d"+ - "\u0346\u035d\u0360\u0363\u036b\u036f\u0377\u037d\u0388\u0391\u0396\u03a0"+ - "\u03a7\u03b4\u03bd\u03c6\u03cc\u03d7\u03dc\u03e8\u03ec\u03f0\u03f4\u03f6"+ - "\u03fa\u03ff\u0412\u0426\u0436\u045b\u046e\u0480\u0488\u048a\u04a0\u04a2"+ - "\u04ab\u04ad\u04b1\u04b6\u04ba\u04be\u04c2\u04cc\u04d8\u04df\u04e2\u04e6"+ - "\u04f2\u04f7\u04fd\u04ff\u0505\u0509"; - public static final ATN _ATN = - ATNSimulator.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); - } - } -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java b/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java deleted file mode 100644 index 7fd0fda..0000000 --- a/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java +++ /dev/null @@ -1,744 +0,0 @@ -// Generated from Java.g4 by ANTLR 4.1 -package org.nuiton.i18n.plugin.parser.java; - -/* - * #%L - * I18n :: Maven Plugin - * $Id$ - * $HeadURL$ - * %% - * Copyright (C) 2007 - 2014 CodeLutin - * %% - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Lesser Public License for more details. - * - * You should have received a copy of the GNU General Lesser Public - * License along with this program. If not, see - * <http://www.gnu.org/licenses/lgpl-3.0.html>. - * #L% - */ -import org.antlr.v4.runtime.misc.NotNull; -import org.antlr.v4.runtime.tree.ParseTreeVisitor; - -/** - * This interface defines a complete generic visitor for a parse tree produced - * by {@link JavaParser}. - * - * @param <T> The return type of the visit operation. Use {@link Void} for - * operations with no return type. - */ -public interface JavaVisitor<T> extends ParseTreeVisitor<T> { - /** - * Visit a parse tree produced by {@link JavaParser#innerCreator}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInnerCreator(@NotNull JavaParser.InnerCreatorContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#genericMethodDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitGenericMethodDeclaration(@NotNull JavaParser.GenericMethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#expressionList}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitExpressionList(@NotNull JavaParser.ExpressionListContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeDeclaration(@NotNull JavaParser.TypeDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#forUpdate}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitForUpdate(@NotNull JavaParser.ForUpdateContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotation}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotation(@NotNull JavaParser.AnnotationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enumConstant}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnumConstant(@NotNull JavaParser.EnumConstantContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#importDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitImportDeclaration(@NotNull JavaParser.ImportDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationMethodOrConstantRest(@NotNull JavaParser.AnnotationMethodOrConstantRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enumConstantName}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnumConstantName(@NotNull JavaParser.EnumConstantNameContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#finallyBlock}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitFinallyBlock(@NotNull JavaParser.FinallyBlockContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#variableDeclarators}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitVariableDeclarators(@NotNull JavaParser.VariableDeclaratorsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#elementValuePairs}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitElementValuePairs(@NotNull JavaParser.ElementValuePairsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInterfaceMethodDeclaration(@NotNull JavaParser.InterfaceMethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInterfaceBodyDeclaration(@NotNull JavaParser.InterfaceBodyDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enumConstants}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnumConstants(@NotNull JavaParser.EnumConstantsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#catchClause}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitCatchClause(@NotNull JavaParser.CatchClauseContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#constantExpression}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitConstantExpression(@NotNull JavaParser.ConstantExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enumDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnumDeclaration(@NotNull JavaParser.EnumDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitExplicitGenericInvocationSuffix(@NotNull JavaParser.ExplicitGenericInvocationSuffixContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeParameter}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeParameter(@NotNull JavaParser.TypeParameterContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enumBodyDeclarations}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnumBodyDeclarations(@NotNull JavaParser.EnumBodyDeclarationsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeBound}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeBound(@NotNull JavaParser.TypeBoundContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#statementExpression}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitStatementExpression(@NotNull JavaParser.StatementExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#variableInitializer}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitVariableInitializer(@NotNull JavaParser.VariableInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#block}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitBlock(@NotNull JavaParser.BlockContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitGenericInterfaceMethodDeclaration(@NotNull JavaParser.GenericInterfaceMethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#localVariableDeclarationStatement}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitLocalVariableDeclarationStatement(@NotNull JavaParser.LocalVariableDeclarationStatementContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#superSuffix}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitSuperSuffix(@NotNull JavaParser.SuperSuffixContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#fieldDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitFieldDeclaration(@NotNull JavaParser.FieldDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#formalParameterList}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitFormalParameterList(@NotNull JavaParser.FormalParameterListContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#explicitGenericInvocation}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitExplicitGenericInvocation(@NotNull JavaParser.ExplicitGenericInvocationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#parExpression}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitParExpression(@NotNull JavaParser.ParExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#switchLabel}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitSwitchLabel(@NotNull JavaParser.SwitchLabelContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeParameters}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeParameters(@NotNull JavaParser.TypeParametersContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#qualifiedName}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitQualifiedName(@NotNull JavaParser.QualifiedNameContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassDeclaration(@NotNull JavaParser.ClassDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationConstantRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationConstantRest(@NotNull JavaParser.AnnotationConstantRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#arguments}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitArguments(@NotNull JavaParser.ArgumentsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#constructorBody}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitConstructorBody(@NotNull JavaParser.ConstructorBodyContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#formalParameters}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitFormalParameters(@NotNull JavaParser.FormalParametersContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeArgument}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeArgument(@NotNull JavaParser.TypeArgumentContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#forInit}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitForInit(@NotNull JavaParser.ForInitContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#variableDeclarator}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitVariableDeclarator(@NotNull JavaParser.VariableDeclaratorContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationTypeDeclaration(@NotNull JavaParser.AnnotationTypeDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#expression}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitExpression(@NotNull JavaParser.ExpressionContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#resources}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitResources(@NotNull JavaParser.ResourcesContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#formalParameter}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitFormalParameter(@NotNull JavaParser.FormalParameterContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#type}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitType(@NotNull JavaParser.TypeContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitElementValueArrayInitializer(@NotNull JavaParser.ElementValueArrayInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationName}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationName(@NotNull JavaParser.AnnotationNameContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#enhancedForControl}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitEnhancedForControl(@NotNull JavaParser.EnhancedForControlContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationMethodRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationMethodRest(@NotNull JavaParser.AnnotationMethodRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#primary}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitPrimary(@NotNull JavaParser.PrimaryContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classBody}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassBody(@NotNull JavaParser.ClassBodyContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassOrInterfaceModifier(@NotNull JavaParser.ClassOrInterfaceModifierContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#defaultValue}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitDefaultValue(@NotNull JavaParser.DefaultValueContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#variableModifier}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitVariableModifier(@NotNull JavaParser.VariableModifierContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#constDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitConstDeclaration(@NotNull JavaParser.ConstDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#createdName}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitCreatedName(@NotNull JavaParser.CreatedNameContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#interfaceDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInterfaceDeclaration(@NotNull JavaParser.InterfaceDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#packageDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitPackageDeclaration(@NotNull JavaParser.PackageDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#constantDeclarator}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitConstantDeclarator(@NotNull JavaParser.ConstantDeclaratorContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#catchType}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitCatchType(@NotNull JavaParser.CatchTypeContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeArguments}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeArguments(@NotNull JavaParser.TypeArgumentsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classCreatorRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassCreatorRest(@NotNull JavaParser.ClassCreatorRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#modifier}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitModifier(@NotNull JavaParser.ModifierContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#statement}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitStatement(@NotNull JavaParser.StatementContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#interfaceBody}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInterfaceBody(@NotNull JavaParser.InterfaceBodyContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classBodyDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassBodyDeclaration(@NotNull JavaParser.ClassBodyDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#lastFormalParameter}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitLastFormalParameter(@NotNull JavaParser.LastFormalParameterContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#forControl}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitForControl(@NotNull JavaParser.ForControlContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeList}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeList(@NotNull JavaParser.TypeListContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#localVariableDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitLocalVariableDeclaration(@NotNull JavaParser.LocalVariableDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#variableDeclaratorId}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitVariableDeclaratorId(@NotNull JavaParser.VariableDeclaratorIdContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#compilationUnit}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitCompilationUnit(@NotNull JavaParser.CompilationUnitContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#elementValue}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitElementValue(@NotNull JavaParser.ElementValueContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#classOrInterfaceType}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitClassOrInterfaceType(@NotNull JavaParser.ClassOrInterfaceTypeContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitTypeArgumentsOrDiamond(@NotNull JavaParser.TypeArgumentsOrDiamondContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationTypeElementDeclaration(@NotNull JavaParser.AnnotationTypeElementDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#blockStatement}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitBlockStatement(@NotNull JavaParser.BlockStatementContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationTypeBody}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationTypeBody(@NotNull JavaParser.AnnotationTypeBodyContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#qualifiedNameList}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitQualifiedNameList(@NotNull JavaParser.QualifiedNameListContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#creator}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitCreator(@NotNull JavaParser.CreatorContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#memberDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitMemberDeclaration(@NotNull JavaParser.MemberDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#methodDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitMethodDeclaration(@NotNull JavaParser.MethodDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#annotationTypeElementRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitAnnotationTypeElementRest(@NotNull JavaParser.AnnotationTypeElementRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#resourceSpecification}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitResourceSpecification(@NotNull JavaParser.ResourceSpecificationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#constructorDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitConstructorDeclaration(@NotNull JavaParser.ConstructorDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#resource}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitResource(@NotNull JavaParser.ResourceContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#elementValuePair}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitElementValuePair(@NotNull JavaParser.ElementValuePairContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#methodBody}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitMethodBody(@NotNull JavaParser.MethodBodyContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#arrayInitializer}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitArrayInitializer(@NotNull JavaParser.ArrayInitializerContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitNonWildcardTypeArgumentsOrDiamond(@NotNull JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#primitiveType}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitPrimitiveType(@NotNull JavaParser.PrimitiveTypeContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitNonWildcardTypeArguments(@NotNull JavaParser.NonWildcardTypeArgumentsContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#arrayCreatorRest}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitArrayCreatorRest(@NotNull JavaParser.ArrayCreatorRestContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitInterfaceMemberDeclaration(@NotNull JavaParser.InterfaceMemberDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitGenericConstructorDeclaration(@NotNull JavaParser.GenericConstructorDeclarationContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#literal}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitLiteral(@NotNull JavaParser.LiteralContext ctx); - - /** - * Visit a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. - * @param ctx the parse tree - * @return the visitor result - */ - T visitSwitchBlockStatementGroup(@NotNull JavaParser.SwitchBlockStatementGroupContext ctx); -} \ No newline at end of file diff --git a/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java b/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java index 1a9b1ca..f3e70f5 100644 --- a/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java +++ b/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java @@ -5,7 +5,7 @@ * $Id$ * $HeadURL$ * %% - * Copyright (C) 2007 - 2011 CodeLutin + * Copyright (C) 2007 - 2016 CodeLutin * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as @@ -32,10 +32,15 @@ import org.junit.Before; import org.junit.Test; import org.nuiton.io.SortedProperties; +import static org.nuiton.i18n.I18n.t; + import java.io.File; import java.io.IOException; +import java.util.ArrayList; import java.util.HashSet; +import java.util.List; import java.util.Set; +import java.util.function.Consumer; /** * Tests the class {@link ParserJavaMojo.JavaFileParser} @@ -154,6 +159,55 @@ public class JavaFileParserTest { parseLine(file, new String[]{"e", "aa"}, "a", "b", "c", "d"); } + /** + * Test que la synthax java 8 est supportée. + * @throws IOException + */ + @Test + public void getJava8Keys() throws IOException { + String classContent = "" + + "package org.nuiton.i18n;" + + "import org.nuiton.i18n.I18n;" + + "class TestFuction8 {" + + " public static void main() {" + + " List<String> test = new ArrayList<>();" + + " test.removeIf(s -> s.isEmpty());" + + " test.forEach(s -> t(s));" + + " test.forEach((s) -> t(\"new string found\", s));" + + " test.forEach(s -> t(\"new string found 2\"));" + + "" + + " Consumer<String> translator = s -> t(\"new string in consumer\");" + + " test.forEach(translator);" + + " }" + + "}"; + + File file = new File(FileUtils.getTempDirectory(), "getJava8Keys"); + FileUtils.write(file, classContent); + + parseLine(file, new String[]{"s"}, "new string found", "new string found 2", "new string in consumer"); + } + + /** + * Test que l'enchainement de deux appels t(t("")) est bien détecté. + * @throws IOException + */ + @Test + public void getDoubleTKeys() throws IOException { + String classContent = "" + + "package org.nuiton.i18n;" + + "import org.nuiton.i18n.I18n;" + + "class TestFuction8 {" + + " public static void main() {" + + " System.out.println(t(t(\"test deux t\"), \"no\"));" + + " }" + + "}"; + + File file = new File(FileUtils.getTempDirectory(), "getDoubleTKeys"); + FileUtils.write(file, classContent); + + parseLine(file, new String[]{"no"}, "test deux t"); + } + protected void parseLine(File f, String[] notExpectedKeys, String... expectedKeys) throws IOException { parser.parseFile(f); diff --git a/nuiton-i18n-editor/pom.xml b/nuiton-i18n-editor/pom.xml index 50db04d..a204af8 100644 --- a/nuiton-i18n-editor/pom.xml +++ b/nuiton-i18n-editor/pom.xml @@ -3,7 +3,7 @@ #%L I18n :: I18n Editor %% - Copyright (C) 2010 CodeLutin + Copyright (C) 2010 - 2016 CodeLutin %% This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as @@ -32,7 +32,7 @@ <parent> <groupId>org.nuiton</groupId> <artifactId>i18n</artifactId> - <version>2.9-SNAPSHOT</version> + <version>3.4-SNAPSHOT</version> </parent> <groupId>org.nuiton.i18n</groupId> @@ -105,8 +105,8 @@ <!-- main class in jar --> <maven.jar.main.class>org.nuiton.i18n.editor.I18nEditor</maven.jar.main.class> - <jaxxVersion>2.8-SNAPSHOT</jaxxVersion> - <nuitonUtilsVersion>3.0-SNAPSHOT</nuitonUtilsVersion> + <jaxxVersion>2.28.2</jaxxVersion> + <nuitonUtilsVersion>3.0-rc-11</nuitonUtilsVersion> <!-- default license to use --> <license.licenseName>gpl_v3</license.licenseName> diff --git a/pom.xml b/pom.xml index 43c9ea4..e765ec3 100644 --- a/pom.xml +++ b/pom.xml @@ -63,7 +63,7 @@ <projectId>i18n</projectId> <processorVersion>1.3</processorVersion> - <antlrVersion>4.3</antlrVersion> + <antlrVersion>4.5.2-1</antlrVersion> <!--Multilanguage maven-site --> <locales>fr,en</locales> @@ -137,11 +137,11 @@ <artifactId>antlr4-runtime</artifactId> <version>${antlrVersion}</version> </dependency> - <dependency> + <!-- <dependency> <groupId>org.antlr</groupId> <artifactId>antlr4-annotations</artifactId> <version>${antlrVersion}</version> - </dependency> + </dependency> --> <dependency> <groupId>org.nuiton.processor</groupId> -- To stop receiving notification emails like this one, please contact nuiton.org SCM administrator <admin+scm@nuiton.org>.
participants (1)
-
nuiton.org scm