Author: tchemit Date: 2014-02-04 05:42:39 +0100 (Tue, 04 Feb 2014) New Revision: 2019 Url: http://nuiton.org/projects/i18n/repository/revisions/2019 Log: fixes #1586: Add new AST parser for java file (prefer use antlr with java 1.7 parser instead of poor java 1.5 parser) fixes #1535: Commented keys are parsed in GWT parser mojo fixes #2687: Rename I18n methods to be compatible with jre 8 Added: trunk/i18n-maven-plugin/src/main/antlr4/ trunk/i18n-maven-plugin/src/main/antlr4/Java.g4 trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/GWTJavaFileParserTest.java trunk/src/site/apt/migrate.apt trunk/src/site/en/apt/migrate.apt Modified: trunk/i18n-maven-plugin/README.txt trunk/i18n-maven-plugin/pom.xml trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java trunk/i18n-maven-plugin/src/site/apt/index.apt trunk/i18n-maven-plugin/src/site/en/apt/index.apt trunk/i18n-maven-plugin/src/site/site_en.xml trunk/i18n-maven-plugin/src/site/site_fr.xml trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java trunk/pom.xml trunk/src/site/site_en.xml trunk/src/site/site_fr.xml Modified: trunk/i18n-maven-plugin/README.txt =================================================================== --- trunk/i18n-maven-plugin/README.txt 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/README.txt 2014-02-04 04:42:39 UTC (rev 2019) @@ -1,2 +1,6 @@ To deploy new version of pom: mvn deploy To install localy: mvn install + +To regenerate the Java parser in package org.nuiton.i18n.plugin.parser.java : + +mvn -Pgenerate-java-parser Modified: trunk/i18n-maven-plugin/pom.xml =================================================================== --- trunk/i18n-maven-plugin/pom.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/pom.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -54,9 +54,8 @@ </dependency> <dependency> - <groupId>com.google.code.javaparser</groupId> - <artifactId>javaparser</artifactId> - <version>1.0.8</version> + <groupId>org.antlr</groupId> + <artifactId>antlr4-runtime</artifactId> </dependency> <dependency> @@ -310,5 +309,40 @@ </plugins> </build> </profile> + + <profile> + <id>generate-java-parser</id> + + <build> + <defaultGoal>generate-sources</defaultGoal> + <plugins> + <plugin> + <groupId>org.antlr</groupId> + <artifactId>antlr4-maven-plugin</artifactId> + <version>4.1</version> + <executions> + <execution> + <goals> + <goal>antlr4</goal> + </goals> + <phase>generate-sources</phase> + <configuration> + <encoding>UTF-8</encoding> + <listener>true</listener> + <visitor>true</visitor> + <sourceDirectory>${project.basedir}/src/main/antlr4</sourceDirectory> + <outputDirectory>${project.basedir}/src/main/java/org/nuiton/i18n/plugin/parser/java</outputDirectory> + <arguments> + <argument>-package</argument> + <argument>org.nuiton.i18n.plugin.parser.java</argument> + </arguments> + </configuration> + </execution> + </executions> + + </plugin> + </plugins> + </build> + </profile> </profiles> </project> Added: trunk/i18n-maven-plugin/src/main/antlr4/Java.g4 =================================================================== --- trunk/i18n-maven-plugin/src/main/antlr4/Java.g4 (rev 0) +++ trunk/i18n-maven-plugin/src/main/antlr4/Java.g4 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,1020 @@ +/* + [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 + ; Modified: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserGWTJavaMojo.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -24,6 +24,12 @@ */ 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; import org.apache.maven.plugins.annotations.LifecyclePhase; import org.apache.maven.plugins.annotations.Mojo; @@ -34,18 +40,19 @@ 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.io.FileUpdater; import org.nuiton.io.MirroredFileUpdater; import org.nuiton.io.SortedProperties; -import org.nuiton.processor.ProcessorUtil; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStreamReader; -import java.io.LineNumberReader; +import java.io.Reader; import java.util.HashSet; -import java.util.List; import java.util.Set; import java.util.regex.Pattern; @@ -154,7 +161,7 @@ ); } - protected class GWTJavaFileParser extends AbstractFileParser { + protected static class GWTJavaFileParser extends AbstractFileParser { public GWTJavaFileParser(Log log, @@ -162,121 +169,93 @@ SortedProperties oldParser, Pattern acceptKeyPattern, boolean showTouchedFiles) { - super(log, encoding, oldParser, acceptKeyPattern,showTouchedFiles); + super(log, encoding, oldParser, acceptKeyPattern, showTouchedFiles); } - protected File prepareFile(File file) throws IOException { +// protected File prepareFile(File file) throws IOException { +// +// // clean the jsp to make it xml +// +// File result = entryUpdater.getMirrorFile(file); +// if (isVerbose()) { +// getLog().info("Will process [" + file + "] to " + result); +// } +// try { +// createDirectoryIfNecessary(result.getParentFile()); +// } catch (IOException e) { +// // don't care about it... +// } +// GWTJavaProcessor processor = new GWTJavaProcessor(); +// processor.setVerbose(isVerbose()); +// processor.process(file, result, getEncoding()); +// return result; +// } - // clean the jsp to make it xml - - File result = entryUpdater.getMirrorFile(file); - if (isVerbose()) { - getLog().info("Will process [" + file + "] to " + result); - } - try { - createDirectoryIfNecessary(result.getParentFile()); - } catch (IOException e) { - // don't care about it... - } - GWTJavaProcessor processor = new GWTJavaProcessor(); - processor.setVerbose(isVerbose()); - processor.process(file, result, getEncoding()); - return result; - } - @Override public void parseFile(File file) throws IOException { - // clean the jsp to make it xml - - File processedFile = prepareFile(file); - - // process file to obtain - String line = null; - LineNumberReader lnr = new LineNumberReader(new InputStreamReader( - new FileInputStream(processedFile), getEncoding())); + Reader inputStream = new InputStreamReader(new FileInputStream(file), "UTF-8"); try { - while ((line = lnr.readLine()) != null) { - parseLine(processedFile, line); - } + // parse the file + TokenStream tokenStream = new CommonTokenStream(new JavaLexer(new ANTLRInputStream(inputStream))); + JavaParser parser = new JavaParser(tokenStream); + + JavaParser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); + compilationUnitContext.accept(new JavaParserVisitor(file)); + inputStream.close(); } catch (Exception e) { - if (line != null) { - getLog().error( - "could not parse line (" + lnr.getLineNumber() + ") '" - + line + "' of file " + file); - } throw new ParserException(e); } finally { - lnr.close(); + IOUtils.closeQuietly(inputStream); } } @Override public void parseLine(File file, String line) throws IOException { - - String key = line.trim(); - - if (key.isEmpty()) { - // no key detected on this line - return; - } - -// // one key found in file, so file is marked as touched -// setTouched(true); - // Found a i18n key, register it. - if (getLog().isDebugEnabled()) { - getLog().debug(file.getName() + " detected key = " + key); - } - registerKey(key); } - } - /** - * To Extract i18n keys from GWT java files. - * <p/> - * Says keep content only of those patterns : - * <ul> - * <li>{@code @Key("XXX")}</li> - * <li>{@code @LocalizableResource.Key("XXX")}</li> - * <li>{@code @com.google.gwt.i18n.client.LocalizableResource.Key("XXX")}</li> - * </ul> - * - * @author tchemit <chemit@codelutin.com> - * @since 2.1 - */ - public static class GWTJavaProcessor extends ProcessorHelper.AbstractParserProcessor { + protected class JavaParserVisitor extends JavaBaseVisitor<Void> { - protected ProcessorUtil.FragmentExtractor filter1 = - new ProcessorUtil.FragmentExtractor( - "@Key(\"", - "\")" - ); + protected final Set<String> annotationPrefix; - protected ProcessorUtil.FragmentExtractor filter2 = - new ProcessorUtil.FragmentExtractor( - "@LocalizableResource.Key(\"", - "\")" - ); + protected final File file; - protected ProcessorUtil.FragmentExtractor filter3 = - new ProcessorUtil.FragmentExtractor( - "@com.google.gwt.i18n.client.LocalizableResource.Key(\"", - "\")" - ); + private JavaParserVisitor(File file) { + this.file = file; + annotationPrefix = new HashSet<String>(); + annotationPrefix.add("Key"); + annotationPrefix.add("LocalizableResource.Key"); + annotationPrefix.add("com.google.gwt.i18n.client.LocalizableResource.Key"); + } + @Override + public Void visitAnnotation(@NotNull JavaParser.AnnotationContext ctx) { + boolean match = false; + if (ctx.getChildCount() > 3) { + ParseTree child = ctx.getChild(1); + String childText = child.getText(); + if (annotationPrefix.contains(childText)) { - @Override - public void process(File filein, - File fileout, - String encoding) throws IOException { - - Set<String> keys = new HashSet<String>(); - extractKeys(filter1, filein, encoding, verbose, keys); - extractKeys(filter2, filein, encoding, verbose, keys); - extractKeys(filter3, filein, encoding, verbose, keys); - saveKeysToFile(fileout, keys); + // key is argument 1 of child 2 + String firstArgs = ctx.getChild(3).getText(); + if (firstArgs.matches("^\"[^\"]+\"$")) { + String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); + if (getLog().isDebugEnabled()) { + getLog().debug(file.getName() + " detected key = " + key); + } + ParserGWTJavaMojo.GWTJavaFileParser.this.registerKey(key); + } + match = true; + } + } + Void aVoid = null; + if (!match) { + // continue visit + aVoid = super.visitAnnotation(ctx); + } + return aVoid; + } } - } } \ No newline at end of file Modified: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/impl/ParserJavaMojo.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -25,13 +25,11 @@ package org.nuiton.i18n.plugin.parser.impl; -import japa.parser.JavaParser; -import japa.parser.ParseException; -import japa.parser.ast.CompilationUnit; -import japa.parser.ast.expr.Expression; -import japa.parser.ast.expr.MethodCallExpr; -import japa.parser.ast.visitor.VoidVisitorAdapter; -import org.apache.commons.io.FileUtils; +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; import org.apache.maven.plugins.annotations.LifecyclePhase; @@ -43,6 +41,9 @@ 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.io.FileUpdater; import org.nuiton.io.FileUpdaterHelper; import org.nuiton.io.SortedProperties; @@ -50,6 +51,10 @@ import java.io.File; import java.io.FileInputStream; import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Reader; +import java.util.HashSet; +import java.util.Set; import java.util.regex.Pattern; /** @@ -136,43 +141,61 @@ @Override public void parseFile(File file) throws IOException { - CompilationUnit cu; - FileInputStream inputStream = FileUtils.openInputStream(file); + Reader inputStream = new InputStreamReader(new FileInputStream(file), "UTF-8"); try { // parse the file - cu = JavaParser.parse(inputStream); + TokenStream tokenStream = new CommonTokenStream(new JavaLexer(new ANTLRInputStream(inputStream))); + JavaParser parser = new JavaParser(tokenStream); + + JavaParser.CompilationUnitContext compilationUnitContext = parser.compilationUnit(); + compilationUnitContext.accept(new JavaParserVisitor(file)); inputStream.close(); - } catch (ParseException e) { + } catch (Exception e) { throw new ParserException(e); } finally { IOUtils.closeQuietly(inputStream); } - - // visit and print the methods names - new MethodVisitor(file).visit(cu, null); } @Override public void parseLine(File file, String line) throws IOException { } - /** - * Simple visitor implementation for visiting MethodDeclaration nodes. - */ - class MethodVisitor extends VoidVisitorAdapter<String> { + protected class JavaParserVisitor extends JavaBaseVisitor<Void> { + protected final Set<String> simpleI18nMethodPrefix; + + protected final Set<String> complexI18nMethodPrefix; + protected final File file; - MethodVisitor(File file) { + private JavaParserVisitor(File file) { this.file = file; + simpleI18nMethodPrefix = new HashSet<String>(); + complexI18nMethodPrefix = new HashSet<String>(); + simpleI18nMethodPrefix.add("org.nuiton.i18n.I18n.n"); + simpleI18nMethodPrefix.add("org.nuiton.i18n.I18n.t"); + simpleI18nMethodPrefix.add("I18n.n"); + simpleI18nMethodPrefix.add("I18n.t"); + simpleI18nMethodPrefix.add("n"); + simpleI18nMethodPrefix.add("t"); + complexI18nMethodPrefix.add("org.nuiton.i18n.I18n.l"); + complexI18nMethodPrefix.add("I18n.l"); + complexI18nMethodPrefix.add("l"); } @Override - public void visit(MethodCallExpr n, String arg) { + public Void visitExpression(@NotNull JavaParser.ExpressionContext ctx) { - if (n.getName().matches("[nt]?")) { - if (n.getArgs().size() == 1) { - String firstArgs = n.getArgs().get(0).toString(); + boolean match = false; + if (ctx.getChildCount() > 2) { + 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); + String firstArgs = arguments.getChild(0).getText(); if (firstArgs.matches("^\"[^\"]+\"$")) { String key = firstArgs.substring(1).substring(0, firstArgs.length() - 2); if (getLog().isDebugEnabled()) { @@ -180,31 +203,30 @@ } ParserJavaMojo.JavaFileParser.this.registerKey(key); } + match = true; + } else if (complexI18nMethodPrefix.contains(childText)) { - } - } - if (n.getName().matches("[l]?")) { - if (n.getArgs().size() == 2) { - Expression arg1 = n.getArgs().get(0); - Expression arg2 = n.getArgs().get(1); - //FIXME tchemit-2014-02-03 We should test that the first args is Locale typed - boolean accept = arg1.toString().contains("Locale"); - String keyParams = arg2.toString(); - boolean match = accept && keyParams.matches("^\"[^\"]+\"$"); - - if (match) { - String key = keyParams.substring(1).substring(0, keyParams.length() - 2); + // key is argument 2 of child 2 + JavaParser.ExpressionListContext arguments = (JavaParser.ExpressionListContext) ctx.getChild(2); + String firstArgs = arguments.getChild(2).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.visitExpression(ctx); + } + return aVoid; } } - } Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/Java.tokens 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,201 @@ +PACKAGE=32 +LT=68 +WHILE=50 +MOD=88 +CONST=10 +MOD_ASSIGN=96 +CASE=6 +NEW=31 +CHAR=8 +DO=13 +DIV_ASSIGN=92 +BREAK=4 +Identifier=100 +NOTEQUAL=76 +MUL_ASSIGN=91 +FINAL=18 +RPAREN=58 +INC=79 +IMPORT=25 +CARET=87 +THIS=43 +RETURN=36 +DOUBLE=14 +VOID=48 +SUPER=40 +GOTO=23 +COMMENT=104 +RBRACK=62 +LSHIFT_ASSIGN=97 +GE=75 +RBRACE=60 +LINE_COMMENT=105 +STATIC=38 +PRIVATE=33 +ADD_ASSIGN=89 +SWITCH=41 +STRICTFP=39 +ELSE=15 +ELLIPSIS=102 +NATIVE=30 +THROWS=45 +INT=27 +ASSERT=2 +MUL=83 +TRY=47 +WS=103 +BITOR=86 +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 +LPAREN=57 +IF=22 +AT=101 +SYNCHRONIZED=42 +BOOLEAN=3 +IMPLEMENTS=24 +CONTINUE=11 +COMMA=64 +TRANSIENT=46 +EQUAL=73 +XOR_ASSIGN=95 +TILDE=70 +DOT=65 +ADD=81 +BYTE=5 +VOLATILE=49 +DEFAULT=12 +SHORT=37 +BANG=69 +INSTANCEOF=26 +RSHIFT_ASSIGN=98 +SEMI=63 +StringLiteral=55 +COLON=72 +OR_ASSIGN=94 +ENUM=16 +QUESTION=71 +FINALLY=19 +URSHIFT_ASSIGN=99 +ASSIGN=66 +INTERFACE=28 +IntegerLiteral=51 +DIV=84 +LONG=29 +PUBLIC=35 +EXTENDS=17 +SUB_ASSIGN=90 +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 +'byte'=5 +'import'=25 +'++'=79 +'static'=38 +'else'=15 +'catch'=7 +'final'=18 +'^='=95 +'extends'=17 +'+='=89 +'native'=30 +'break'=4 +'...'=102 +'{'=59 +'>>='=98 +'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 +'public'=35 +'-='=90 +'<<='=97 +']'=62 +'short'=37 +'long'=29 +'enum'=16 +'!'=69 +'transient'=46 +'|'=86 +'finally'=19 +'assert'=2 +'class'=9 +'new'=31 +'|='=94 +'throws'=45 +'null'=56 +'const'=10 +'goto'=23 +'='=66 +'@'=101 +'throw'=44 +')'=58 +'*='=91 +'%'=88 +'do'=13 +'super'=40 +'case'=6 +'char'=8 +'strictfp'=39 +'float'=20 +'}'=60 +'boolean'=3 +'abstract'=1 +'double'=14 +'<='=74 +'!='=76 +'continue'=11 +'--'=80 +'<'=68 +'*'=83 +'['=61 +'&'=85 +'interface'=28 Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,1352 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; + +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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseListener.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,822 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; +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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaBaseVisitor.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,546 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; +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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaLexer.tokens 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,201 @@ +PACKAGE=32 +LT=68 +WHILE=50 +MOD=88 +CONST=10 +MOD_ASSIGN=96 +CASE=6 +NEW=31 +CHAR=8 +DO=13 +DIV_ASSIGN=92 +BREAK=4 +Identifier=100 +NOTEQUAL=76 +MUL_ASSIGN=91 +FINAL=18 +RPAREN=58 +INC=79 +IMPORT=25 +CARET=87 +THIS=43 +RETURN=36 +DOUBLE=14 +VOID=48 +SUPER=40 +GOTO=23 +COMMENT=104 +RBRACK=62 +LSHIFT_ASSIGN=97 +GE=75 +RBRACE=60 +LINE_COMMENT=105 +STATIC=38 +PRIVATE=33 +ADD_ASSIGN=89 +SWITCH=41 +STRICTFP=39 +ELSE=15 +ELLIPSIS=102 +NATIVE=30 +THROWS=45 +INT=27 +ASSERT=2 +MUL=83 +TRY=47 +WS=103 +BITOR=86 +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 +LPAREN=57 +IF=22 +AT=101 +SYNCHRONIZED=42 +BOOLEAN=3 +IMPLEMENTS=24 +CONTINUE=11 +COMMA=64 +TRANSIENT=46 +EQUAL=73 +XOR_ASSIGN=95 +TILDE=70 +DOT=65 +ADD=81 +BYTE=5 +VOLATILE=49 +DEFAULT=12 +SHORT=37 +BANG=69 +INSTANCEOF=26 +RSHIFT_ASSIGN=98 +SEMI=63 +StringLiteral=55 +COLON=72 +OR_ASSIGN=94 +ENUM=16 +QUESTION=71 +FINALLY=19 +URSHIFT_ASSIGN=99 +ASSIGN=66 +INTERFACE=28 +IntegerLiteral=51 +DIV=84 +LONG=29 +PUBLIC=35 +EXTENDS=17 +SUB_ASSIGN=90 +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 +'byte'=5 +'import'=25 +'++'=79 +'static'=38 +'else'=15 +'catch'=7 +'final'=18 +'^='=95 +'extends'=17 +'+='=89 +'native'=30 +'break'=4 +'...'=102 +'{'=59 +'>>='=98 +'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 +'public'=35 +'-='=90 +'<<='=97 +']'=62 +'short'=37 +'long'=29 +'enum'=16 +'!'=69 +'transient'=46 +'|'=86 +'finally'=19 +'assert'=2 +'class'=9 +'new'=31 +'|='=94 +'throws'=45 +'null'=56 +'const'=10 +'goto'=23 +'='=66 +'@'=101 +'throw'=44 +')'=58 +'*='=91 +'%'=88 +'do'=13 +'super'=40 +'case'=6 +'char'=8 +'strictfp'=39 +'float'=20 +'}'=60 +'boolean'=3 +'abstract'=1 +'double'=14 +'<='=74 +'!='=76 +'continue'=11 +'--'=80 +'<'=68 +'*'=83 +'['=61 +'&'=85 +'interface'=28 Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,1121 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; +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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaListener.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,8360 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; +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) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 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) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 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)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) { + { + { + 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 << (LT - 68)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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 << (LT - 68)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) { + { + 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) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) { + { + { + 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)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral) | (1L << BooleanLiteral) | (1L << CharacterLiteral) | (1L << StringLiteral) | (1L << NullLiteral) | (1L << LPAREN) | (1L << LBRACE) | (1L << SEMI))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (LT - 68)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelContext extends ParserRuleContext { + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public EnumConstantNameContext enumConstantName() { + return getRuleContext(EnumConstantNameContext.class,0); + } + public SwitchLabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabel; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof 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 << (LT - 68)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)) | (1L << (AT - 68)))) != 0)) { + { + 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)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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)) | (1L << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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 << (BANG - 68)) | (1L << (TILDE - 68)) | (1L << (INC - 68)) | (1L << (DEC - 68)) | (1L << (ADD - 68)) | (1L << (SUB - 68)) | (1L << (Identifier - 68)))) != 0)) { + { + 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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaParser.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java =================================================================== --- trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java (rev 0) +++ trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,720 @@ +// Generated from Java.g4 by ANTLR 4.1 +package org.nuiton.i18n.plugin.parser.java; +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 Property changes on: trunk/i18n-maven-plugin/src/main/java/org/nuiton/i18n/plugin/parser/java/JavaVisitor.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Modified: trunk/i18n-maven-plugin/src/site/apt/index.apt =================================================================== --- trunk/i18n-maven-plugin/src/site/apt/index.apt 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/site/apt/index.apt 2014-02-04 04:42:39 UTC (rev 2019) @@ -42,12 +42,8 @@ * {{{./parserValidation-mojo.html} i18n:parserValidation}} parse XWorks validation sources. - * {{{./parserJsp-mojo.html} i18n:parserJsp}} parse JSP sources. - * {{{./parserGWTJava-mojo.html} i18n:parserGWTJava}} parse GWT java sources. - * {{{./parserTapestry-mojo.html} i18n:parserTapestry}} parse Tapestry templates sources. - * {{{./get-mojo.html} i18n:get}} assembly getter computed by parser-like goals. * {{{./gen-mojo.html} i18n:gen}} generate i18n bundle from getters. Modified: trunk/i18n-maven-plugin/src/site/en/apt/index.apt =================================================================== --- trunk/i18n-maven-plugin/src/site/en/apt/index.apt 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/site/en/apt/index.apt 2014-02-04 04:42:39 UTC (rev 2019) @@ -42,11 +42,7 @@ * {{{./parserValidation-mojo.html} i18n:parserValidation}} parse XWorks validation sources. - * {{{./parserJsp-mojo.html} i18n:parserJsp}} parse jsp sources. - * {{{./parserGWTJava-mojo.html} i18n:parserGWTJava}} parse GWT java sources. - - * {{{./parserTapestry-mojo.html} i18n:parserTapestry}} parse Tapestry template sources. * {{{./get-mojo.html} i18n:get}} assembly getter computed by parser-like goals. Modified: trunk/i18n-maven-plugin/src/site/site_en.xml =================================================================== --- trunk/i18n-maven-plugin/src/site/site_en.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/site/site_en.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -35,11 +35,11 @@ <head> <script type="text/javascript" - src="http://maven-site.chorem.org/public/js/mavenpom-site.js"> + src="${mavenpomSiteCommonResourcesUrl}/public/js/mavenpom-site.js"> </script> <link rel="stylesheet" type="text/css" - href="http://maven-site.chorem.org/public/css/mavenpom-site.css"/> + href="${mavenpomSiteCommonResourcesUrl}/public/css/mavenpom-site.css"/> </head> <breadcrumbs> @@ -66,10 +66,9 @@ <item name="Parser Goals" href="plugin-info.html"> <item name="parserJava" href="parserJava-mojo.html"/> <item name="parserXml" href="parserXml-mojo.html"/> - <item name="parserJsp" href="parserJsp-mojo.html"/> <item name="parserGWTJava" href="parserGWTJava-mojo.html"/> - <item name="parserTapestry" href="parserTapestry-mojo.html"/> <item name="parserValidation" href="parserValidation-mojo.html"/> + <item name="parserStruts" href="parserStruts2-mojo.html"/> <item name="get" href="get-mojo.html"/> <item name="gen" href="gen-mojo.html"/> </item> @@ -88,7 +87,7 @@ <footer> - <div id='projectMetas' + <div id='projectMetas' locale='en' projectversion='${project.version}' platform='${project.platform}' projectid='${project.projectId}' @@ -97,7 +96,9 @@ scmwebeditorurl='${project.scmwebeditorUrl}' siteSourcesType='${project.siteSourcesType}' piwikEnabled='${project.piwikEnabled}' - piwikId='${project.piwikId}'> + piwikId='${project.piwikId}' + scmwebeditor_skipDefaultFiles="true"> + <!--scmwebeditor_vmFiles=",library.html,"--> </div> </footer> Modified: trunk/i18n-maven-plugin/src/site/site_fr.xml =================================================================== --- trunk/i18n-maven-plugin/src/site/site_fr.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/site/site_fr.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -35,11 +35,11 @@ <head> <script type="text/javascript" - src="http://maven-site.chorem.org/public/js/mavenpom-site.js"> + src="${mavenpomSiteCommonResourcesUrl}/public/js/mavenpom-site.js"> </script> <link rel="stylesheet" type="text/css" - href="http://maven-site.chorem.org/public/css/mavenpom-site.css"/> + href="${mavenpomSiteCommonResourcesUrl}/public/css/mavenpom-site.css"/> </head> <breadcrumbs> @@ -64,8 +64,7 @@ <item name="Parser Goals" href="plugin-info.html"> <item name="parserJava" href="parserJava-mojo.html"/> <item name="parserXml" href="parserXml-mojo.html"/> - <item name="parserJsp" href="parserJsp-mojo.html"/> - <item name="parserTapestry" href="parserTapestry-mojo.html"/> + <item name="parserStruts2" href="parserStruts2-mojo.html"/> <item name="parserGWTJava" href="parserGWTJava-mojo.html"/> <item name="parserValidation" href="parserValidation-mojo.html"/> <item name="get" href="get-mojo.html"/> @@ -86,7 +85,7 @@ <footer> - <div id='projectMetas' + <div id='projectMetas' locale='fr' projectversion='${project.version}' platform='${project.platform}' projectid='${project.projectId}' @@ -95,7 +94,9 @@ scmwebeditorurl='${project.scmwebeditorUrl}' siteSourcesType='${project.siteSourcesType}' piwikEnabled='${project.piwikEnabled}' - piwikId='${project.piwikId}'> + piwikId='${project.piwikId}' + scmwebeditor_skipDefaultFiles="true"> + <!--scmwebeditor_vmFiles=",library.html,"--> </div> </footer> Added: trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/GWTJavaFileParserTest.java =================================================================== --- trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/GWTJavaFileParserTest.java (rev 0) +++ trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/GWTJavaFileParserTest.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,98 @@ +package org.nuiton.i18n.plugin.parser.impl; + +import org.apache.commons.io.FileUtils; +import org.apache.maven.plugin.logging.SystemStreamLog; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.nuiton.io.SortedProperties; + +import java.io.File; +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; + +/** + * Created on 2/4/14. + * + * @author Tony Chemit <chemit@codelutin.com> + * @since 3.0 + */ +public class GWTJavaFileParserTest { + + public static final String ENCODING = "utf-8"; + + protected static final SystemStreamLog log = new SystemStreamLog(); + + protected ParserGWTJavaMojo.GWTJavaFileParser parser; + + protected SortedProperties oldParser; + + protected Set<String> detectedKeys; + + @Before + public void setUp() throws Exception { + oldParser = new SortedProperties(ENCODING); + + parser = new ParserGWTJavaMojo.GWTJavaFileParser( + log, + ENCODING, + oldParser, + null, + false) { + @Override + protected void registerKey(String key) { + detectedKeys.add(key); + } + }; + detectedKeys = new HashSet<String>(); + } + + + @After + public void tearDown() throws Exception { + detectedKeys.clear(); + detectedKeys = null; + parser = null; + } + + @Test + public void testParseFile() throws Exception { + String classContent = "" + + "package org.nuiton.i18n;\n" + + "import org.nuiton.i18n.I18n;\n" + + "import static org.nuiton.i18n.I18n.t;\n" + + "class TestFuctionN {\n" + + "@Key(\"a\") String key;\n" + + "@ LocalizableResource.Key(\"b\") String key2;\n" + + "@com.google.gwt.i18n.client.LocalizableResource.Key(\"c\") String key3;\n" + + "@KKey(\"d\") String key4;\n" + + "//@KKey(\"e\") String key4;\n" + + "/*@KKey(\"f\") String key4;*/\n" + + "}"; + + File file = new File(FileUtils.getTempDirectory(), "getKeys"); + FileUtils.write(file, classContent); + + parseFile(file, new String[]{"d","e","f"}, "a", "b", "c"); + } + + protected void parseFile(File f, String[] notExpectedKeys, String... expectedKeys) throws IOException { + parser.parseFile(f); + + for (String expectedKey : expectedKeys) { + + Assert.assertTrue("Key " + expectedKey + + " was expected from file " + f, + detectedKeys.contains(expectedKey)); + } + + for (String expectedKey : notExpectedKeys) { + + Assert.assertFalse("Key " + expectedKey + + " was NOT expected from file " + f, + detectedKeys.contains(expectedKey)); + } + } +} Property changes on: trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/GWTJavaFileParserTest.java ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Modified: trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java =================================================================== --- trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/i18n-maven-plugin/src/test/java/org/nuiton/i18n/plugin/parser/impl/JavaFileParserTest.java 2014-02-04 04:42:39 UTC (rev 2019) @@ -91,7 +91,7 @@ "import static org.nuiton.i18n.I18n.t;" + "class TestFuctionN {" + "String key = I18n.t(\"a\");" + - "String key2 = org.nuiton.i18n.t(\"b\");" + + "String key2 = org.nuiton.i18n.I18n.t(\"b\");" + "String key3 = t(\"c\");" + "String key4 = t(" + "\"d\");" + @@ -102,26 +102,7 @@ File file = new File(FileUtils.getTempDirectory(), "getKeys"); FileUtils.write(file, classContent); -// String line; - -// line = "n(\"a\");"; parseLine(file, new String[]{"e"}, "a", "b", "c", "d"); - -// File file = new File("getKeys"); -// String line; -// -// line = "t(\"myKey\");"; -// parseLine(file, line, "myKey"); -// -// line = "t(\"MyKey\" "; -// parseLine(file, line, "MyKey"); -// -// line = " blabla t(\"myKey2\");"; -// parseLine(file, line, "myKey2"); -// -// line = " blabla \n somewhere else..." + -// "t(\"myKey3\");"; -// parseLine(file, line, "myKey3"); } @Test @@ -133,7 +114,7 @@ "import static org.nuiton.i18n.I18n.n;" + "class TestFuctionN {" + "String key = I18n.n(\"a\");" + - "String key2 = org.nuiton.i18n.n(\"b\");" + + "String key2 = org.nuiton.i18n.I18n.n(\"b\");" + "String key3 = n(\"c\");" + "String key4 = n(" + "\"d\");" + @@ -144,32 +125,7 @@ File file = new File(FileUtils.getTempDirectory(), "getKeys2"); FileUtils.write(file, classContent); -// String line; - -// line = "n(\"a\");"; parseLine(file, new String[]{"e"}, "a", "b", "c", "d"); - -// line = ".n(\"b\");"; -// parseLine(file, line, "b"); -// -// line = " n(\"c\");"; -// parseLine(file, line, "c"); -// -// line = "aan(\"d\");"; -// parseBadLine(file, line, "d"); -// -// line = "aa n(\"e\");"; -// parseLine(file, line, "e"); -// -// line = "n(\"f\" "; -// parseLine(file, line, "f"); -// -// line = " blabla n(\"g\");"; -// parseLine(file, line, "g"); -// -// line = " blabla \n somewhere else..." + -// "n(\"h\");"; -// parseLine(file, line, "h"); } @Test @@ -184,7 +140,7 @@ "class TestFuctionN {" + "String key = I18n.l(Locale.UK, \"a\");" + "/*FIXME Can't detect this String key = I18n.l(UK, \"aa\");*/" + - "String key2 = org.nuiton.i18n.l(Locale.UK, \"b\");" + + "String key2 = org.nuiton.i18n.I18n.l(Locale.UK, \"b\");" + "String key3 = l(Locale.UK, \"c\");" + "String key4 = l(Locale.UK, " + "\"d\");" + @@ -195,47 +151,9 @@ File file = new File(FileUtils.getTempDirectory(), "getKeys3"); FileUtils.write(file, classContent); -// String line; - -// line = "n(\"a\");"; parseLine(file, new String[]{"e", "aa"}, "a", "b", "c", "d"); - -// String line; -// File file = new File("getKeys3"); -// -// line = "l(Locale.UK, \"myKey\");"; -// parseLine(file, line, "myKey"); -// -// line = ".l(Locale.UK, \"myKey\");"; -// parseLine(file, line, "myKey"); -// -// line = " l(Locale.UK, \"myKey\");"; -// parseLine(file, line, "myKey"); -// -// line = "al(Locale.UK, \"myKey\");"; -// parseBadLine(file, line, "myKey"); -// -// line = "l( Locale.UK , \"MyKey\""; -// parseLine(file, line, "MyKey"); -// -// line = " blabla l(Locale.UK, \"myKey2\");"; -// parseLine(file, line, "myKey2"); -// -// line = " blabla \n somewhere else..." + -// "l(Locale.UK, \"myKey3\");"; -// parseLine(file, line, "myKey3"); } - protected void parseLine(File f, String line, String... expectedKeys) throws IOException { - parser.parseLine(f, line); - for (String expectedKey : expectedKeys) { - - Assert.assertTrue("Key " + expectedKey + - " was expected from line " + line, - detectedKeys.contains(expectedKey)); - } - } - protected void parseLine(File f, String[] notExpectedKeys, String... expectedKeys) throws IOException { parser.parseFile(f); @@ -254,13 +172,4 @@ } } - protected void parseBadLine(File f, String line, String... expectedKeys) throws IOException { - parser.parseLine(f, line); - for (String expectedKey : expectedKeys) { - - Assert.assertFalse("Key " + expectedKey + - " was not expected from line " + line, - detectedKeys.contains(expectedKey)); - } - } } Modified: trunk/pom.xml =================================================================== --- trunk/pom.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/pom.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -77,6 +77,12 @@ <dependencies> <dependency> + <groupId>org.antlr</groupId> + <artifactId>antlr4-runtime</artifactId> + <version>4.1</version> + </dependency> + + <dependency> <groupId>org.nuiton.processor</groupId> <artifactId>nuiton-processor</artifactId> <version>${processorVersion}</version> Added: trunk/src/site/apt/migrate.apt =================================================================== --- trunk/src/site/apt/migrate.apt (rev 0) +++ trunk/src/site/apt/migrate.apt 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,49 @@ + +---- +Migrate +---- +---- +2014-02-03 +---- + +Migration guide + + You will find on this page some useful informations about how to migrate when som eAPI or mojo configuration changes. + +* Version 3.0 + + In version 3.0, there is some API modifications on class <I18n> (to be jdk 1.8 compatible) + (see {{{https://nuiton.org/issues/2687} Issue 2687}}). + + * <I18n._> method is renamed to <I18n.t>. + + * <I18n.n_> method is renamed to <I18n.n>. + + * <I18n.l_> method is renamed to <I18n.l> + + [] + + You can apply these command on you project to do the migration + +------------------------------------------------------------------------- +for f in $(grep -m 1 -I -nr 'I18n' . | grep -v '.svn' | awk -F ':' '{print $1}') ; do \ + echo $f ; \ + sed -i -e 's/I18n\([.]\)n_/I18n\1n/g' $f ; \ + sed -i -e 's/I18n\([.]\)l_/I18n\1l/g' $f ; \ + sed -i -e 's/I18n\([.]\)_/I18n\1t/g' $f ; \ + sed -i -e 's/n_(/n(/g' $f ; \ + sed -i -e 's/l_(/l(/g' $f ; \ + sed -i -e 's/_(/t(/g' $f ; \ +done +------------------------------------------------------------------------- + + For jaxx application, apply also this: + +------------------------------------------------------------------------- +for f in $(find -name "*.css") ; do \ + echo $f ; \ + sed -i -e 's/n_(/n(/g' $f ; \ + sed -i -e 's/l_(/l(/g' $f ; \ + sed -i -e 's/_(/t(/g' $f ; \ +done +------------------------------------------------------------------------- \ No newline at end of file Property changes on: trunk/src/site/apt/migrate.apt ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Added: trunk/src/site/en/apt/migrate.apt =================================================================== --- trunk/src/site/en/apt/migrate.apt (rev 0) +++ trunk/src/site/en/apt/migrate.apt 2014-02-04 04:42:39 UTC (rev 2019) @@ -0,0 +1,49 @@ + +---- +Migrate +---- +---- +2014-02-03 +---- + +Migration guide + + You will find on this page some useful informations about how to migrate when som eAPI or mojo configuration changes. + +* Version 3.0 + + In version 3.0, there is some API modifications on class <I18n> (to be jdk 1.8 compatible) + (see {{{https://nuiton.org/issues/2687} Issue 2687}}). + + * <I18n._> method is renamed to <I18n.t>. + + * <I18n.n_> method is renamed to <I18n.n>. + + * <I18n.l_> method is renamed to <I18n.l> + + [] + + You can apply these command on you project to do the migration + +------------------------------------------------------------------------- +for f in $(grep -m 1 -I -nr 'I18n' . | grep -v '.svn' | awk -F ':' '{print $1}') ; do \ + echo $f ; \ + sed -i -e 's/I18n\([.]\)n_/I18n\1n/g' $f ; \ + sed -i -e 's/I18n\([.]\)l_/I18n\1l/g' $f ; \ + sed -i -e 's/I18n\([.]\)_/I18n\1t/g' $f ; \ + sed -i -e 's/n_(/n(/g' $f ; \ + sed -i -e 's/l_(/l(/g' $f ; \ + sed -i -e 's/_(/t(/g' $f ; \ +done +------------------------------------------------------------------------- + + For jaxx application, apply also this: + +------------------------------------------------------------------------- +for f in $(find -name "*.css") ; do \ + echo $f ; \ + sed -i -e 's/n_(/n(/g' $f ; \ + sed -i -e 's/l_(/l(/g' $f ; \ + sed -i -e 's/_(/t(/g' $f ; \ +done +------------------------------------------------------------------------- \ No newline at end of file Property changes on: trunk/src/site/en/apt/migrate.apt ___________________________________________________________________ Added: svn:keywords + Author Date Id Revision Added: svn:eol-style + native Modified: trunk/src/site/site_en.xml =================================================================== --- trunk/src/site/site_en.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/src/site/site_en.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -39,7 +39,7 @@ <skin> <groupId>org.apache.maven.skins</groupId> <artifactId>maven-fluido-skin</artifactId> - <version>1.3.0</version> + <version>${fluidoSkinVersion}</version> </skin> <custom> @@ -64,11 +64,11 @@ <head> <script type="text/javascript" - src="http://maven-site.chorem.org/public/js/mavenpom-site.js"> + src="${mavenpomSiteCommonResourcesUrl}/public/js/mavenpom-site.js"> </script> <link rel="stylesheet" type="text/css" - href="http://maven-site.chorem.org/public/css/mavenpom-site.css"/> + href="${mavenpomSiteCommonResourcesUrl}/public/css/mavenpom-site.css"/> </head> <breadcrumbs> @@ -81,7 +81,7 @@ </menu> <links> - <item name="nuiton.org" href="http://www.nuiton.org"/> + <item name="nuiton.org" href="https://nuiton.org"/> <item name="CodeLutin" href="http://codelutin.com"/> <item name="Libre-Entreprise" href="http://www.libre-entreprise.org/"/> <!--item name="[fr" href="../index.html" /> @@ -91,6 +91,7 @@ <menu name="User"> <item name="Home" href="index.html"/> <item name="Presentation" href="presentation.html"/> + <item name="Migrate" href="migrate.html"/> <item name="Best Practices" href="bestPractices.html"/> <item name="Use with GWT" href="gwt.html"/> </menu> @@ -107,17 +108,11 @@ <menu ref="modules"/> - <!--menu name="Modules"> - <item name="I18n :: Api" href="../nuiton-i18n/en/index.html"/> - <item name="I18n :: Maven Plugin" - href="../maven-i18n-plugin/en/index.html"/> - </menu--> - <menu ref="reports"/> <footer> - <div id='projectMetas' + <div id='projectMetas' locale='en' projectversion='${project.version}' platform='${project.platform}' projectid='${project.projectId}' @@ -126,7 +121,9 @@ scmwebeditorurl='${project.scmwebeditorUrl}' siteSourcesType='${project.siteSourcesType}' piwikEnabled='${project.piwikEnabled}' - piwikId='${project.piwikId}'> + piwikId='${project.piwikId}' + scmwebeditor_vmFiles=",library.html," + scmwebeditor_skipDefaultFiles="true"> </div> </footer> </body> Modified: trunk/src/site/site_fr.xml =================================================================== --- trunk/src/site/site_fr.xml 2014-02-03 12:06:44 UTC (rev 2018) +++ trunk/src/site/site_fr.xml 2014-02-04 04:42:39 UTC (rev 2019) @@ -39,7 +39,7 @@ <skin> <groupId>org.apache.maven.skins</groupId> <artifactId>maven-fluido-skin</artifactId> - <version>1.3.0</version> + <version>${fluidoSkinVersion}</version> </skin> <custom> @@ -64,11 +64,11 @@ <head> <script type="text/javascript" - src="http://maven-site.chorem.org/public/js/mavenpom-site.js"> + src="${mavenpomSiteCommonResourcesUrl}/public/js/mavenpom-site.js"> </script> <link rel="stylesheet" type="text/css" - href="http://maven-site.chorem.org/public/css/mavenpom-site.css"/> + href="${mavenpomSiteCommonResourcesUrl}/public/css/mavenpom-site.css"/> </head> <breadcrumbs> @@ -76,7 +76,7 @@ </breadcrumbs> <links> - <item name="nuiton.org" href="http://www.nuiton.org"/> + <item name="nuiton.org" href="https://nuiton.org"/> <item name="CodeLutin" href="http://codelutin.com"/> <item name="Libre-Entreprise" href="http://www.libre-entreprise.org/"/> </links> @@ -89,6 +89,7 @@ <menu name="Utilisateur"> <item name="Accueil" href="index.html"/> <item name="Présentation" href="presentation.html"/> + <item name="Migration" href="migrate.html"/> <item name="Best Practices" href="bestPractices.html"/> <item name="Utilisation avec GWT" href="gwt.html"/> </menu> @@ -109,7 +110,7 @@ <footer> - <div id='projectMetas' + <div id='projectMetas' locale='fr' projectversion='${project.version}' platform='${project.platform}' projectid='${project.projectId}' @@ -118,7 +119,9 @@ scmwebeditorurl='${project.scmwebeditorUrl}' siteSourcesType='${project.siteSourcesType}' piwikEnabled='${project.piwikEnabled}' - piwikId='${project.piwikId}'> + piwikId='${project.piwikId}' + scmwebeditor_vmFiles=",library.html," + scmwebeditor_skipDefaultFiles="true"> </div> </footer> </body>