diff --git a/.classpath b/.classpath index 20f5e915..11f44fce 100755 --- a/.classpath +++ b/.classpath @@ -6,5 +6,6 @@ + diff --git a/bin/.gitignore b/bin/.gitignore index 4ce50fc9..56a30e6a 100644 --- a/bin/.gitignore +++ b/bin/.gitignore @@ -1,6 +1,6 @@ -/de -/plugindevelopment -/mycompiler -/mytypereconstruction -/syntaxTree -/userinterface +/bytecode/ +/de/ +/mycompiler/ +/parser/ +/plugindevelopment/ +/syntaxTree/ diff --git a/src/de/dhbwstuttgart/antlr/.classpath b/src/de/dhbwstuttgart/antlr/.classpath new file mode 100644 index 00000000..27af59ee --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.gitignore b/src/de/dhbwstuttgart/antlr/.gitignore new file mode 100644 index 00000000..2561ed57 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.gitignore @@ -0,0 +1,107 @@ +/Java8Parser$AnnotationConstantRestContext.class +/Java8Parser$AnnotationContext.class +/Java8Parser$AnnotationMethodRestContext.class +/Java8Parser$CatchClauseContext.class +/Java8Parser$CatchTypeContext.class +/Java8Parser$ClassBodyContext.class +/Java8Parser$ClassCreatorRestContext.class +/Java8Parser$ClassDeclarationContext.class +/Java8Parser$CompilationUnitContext.class +/Java8Parser$ConstantDeclaratorContext.class +/Java8Parser$ConstantExpressionContext.class +/Java8Parser$ConstructorDeclarationContext.class +/Java8Parser$ElementValuePairsContext.class +/Java8Parser$EnumDeclarationContext.class +/Java8Parser$ExpressionContext.class +/Java8Parser$ExpressionListContext.class +/Java8Parser$FieldDeclarationContext.class +/Java8Parser$ForControlContext.class +/Java8Parser$ForUpdateContext.class +/Java8Parser$FormalParameterListContext.class +/Java8Parser$GenericConstructorDeclarationContext.class +/Java8Parser$InnerCreatorContext.class +/Java8Parser$InterfaceBodyContext.class +/Java8Parser$InterfaceMemberDeclarationContext.class +/Java8Parser$InterfaceMethodDeclarationContext.class +/Java8Parser$LastFormalParameterContext.class +/Java8Parser$LiteralContext.class +/Java8Parser$LocalVariableDeclarationStatementContext.class +/Java8Parser$MethodDeclarationContext.class +/Java8Parser$ModifierContext.class +/Java8Parser$NonWildcardTypeArgumentsContext.class +/Java8Parser$PrimitiveTypeContext.class +/Java8Parser$ResourceSpecificationContext.class +/Java8Parser$ResourcesContext.class +/Java8Parser$SwitchBlockStatementGroupContext.class +/Java8Parser$TypeArgumentsOrDiamondContext.class +/Java8Parser$TypeBoundContext.class +/Java8Parser$TypeDeclarationContext.class +/Java8Parser$TypeListContext.class +/Java8Parser$TypeParametersContext.class +/Java8Parser$VariableDeclaratorIdContext.class +/Java8Parser$VariableInitializerContext.class +/Java8Parser$VariableModifierContext.class +/SyntaxTreeBuilder.class +/Test.class +/Java8BaseListener.class +/Java8Lexer.class +/Java8Listener.class +/Java8Parser$AnnotationMethodOrConstantRestContext.class +/Java8Parser$AnnotationNameContext.class +/Java8Parser$AnnotationTypeBodyContext.class +/Java8Parser$AnnotationTypeDeclarationContext.class +/Java8Parser$AnnotationTypeElementDeclarationContext.class +/Java8Parser$AnnotationTypeElementRestContext.class +/Java8Parser$ArgumentsContext.class +/Java8Parser$ArrayCreatorRestContext.class +/Java8Parser$ArrayInitializerContext.class +/Java8Parser$BlockContext.class +/Java8Parser$BlockStatementContext.class +/Java8Parser$ClassBodyDeclarationContext.class +/Java8Parser$ClassOrInterfaceModifierContext.class +/Java8Parser$ClassOrInterfaceTypeContext.class +/Java8Parser$ConstDeclarationContext.class +/Java8Parser$ConstructorBodyContext.class +/Java8Parser$CreatedNameContext.class +/Java8Parser$CreatorContext.class +/Java8Parser$DefaultValueContext.class +/Java8Parser$ElementValueArrayInitializerContext.class +/Java8Parser$ElementValueContext.class +/Java8Parser$ElementValuePairContext.class +/Java8Parser$EnhancedForControlContext.class +/Java8Parser$EnumBodyDeclarationsContext.class +/Java8Parser$EnumConstantContext.class +/Java8Parser$EnumConstantNameContext.class +/Java8Parser$EnumConstantsContext.class +/Java8Parser$ExplicitGenericInvocationContext.class +/Java8Parser$ExplicitGenericInvocationSuffixContext.class +/Java8Parser$FinallyBlockContext.class +/Java8Parser$ForInitContext.class +/Java8Parser$FormalParameterContext.class +/Java8Parser$FormalParametersContext.class +/Java8Parser$GenericInterfaceMethodDeclarationContext.class +/Java8Parser$GenericMethodDeclarationContext.class +/Java8Parser$ImportDeclarationContext.class +/Java8Parser$InterfaceBodyDeclarationContext.class +/Java8Parser$InterfaceDeclarationContext.class +/Java8Parser$LocalVariableDeclarationContext.class +/Java8Parser$MemberDeclarationContext.class +/Java8Parser$MethodBodyContext.class +/Java8Parser$NonWildcardTypeArgumentsOrDiamondContext.class +/Java8Parser$PackageDeclarationContext.class +/Java8Parser$ParExpressionContext.class +/Java8Parser$PrimaryContext.class +/Java8Parser$QualifiedNameContext.class +/Java8Parser$QualifiedNameListContext.class +/Java8Parser$ResourceContext.class +/Java8Parser$StatementContext.class +/Java8Parser$StatementExpressionContext.class +/Java8Parser$SuperSuffixContext.class +/Java8Parser$SwitchLabelContext.class +/Java8Parser$TypeArgumentContext.class +/Java8Parser$TypeArgumentsContext.class +/Java8Parser$TypeContext.class +/Java8Parser$TypeParameterContext.class +/Java8Parser$VariableDeclaratorContext.class +/Java8Parser$VariableDeclaratorsContext.class +/Java8Parser.class diff --git a/src/de/dhbwstuttgart/antlr/.idea/.name b/src/de/dhbwstuttgart/antlr/.idea/.name new file mode 100644 index 00000000..b1431328 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/.name @@ -0,0 +1 @@ +antlr \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/.idea/antlr.iml b/src/de/dhbwstuttgart/antlr/.idea/antlr.iml new file mode 100644 index 00000000..b3a364e2 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/antlr.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/compiler.xml b/src/de/dhbwstuttgart/antlr/.idea/compiler.xml new file mode 100644 index 00000000..217af471 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/compiler.xml @@ -0,0 +1,23 @@ + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/copyright/profiles_settings.xml b/src/de/dhbwstuttgart/antlr/.idea/copyright/profiles_settings.xml new file mode 100644 index 00000000..e7bedf33 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/copyright/profiles_settings.xml @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/.idea/encodings.xml b/src/de/dhbwstuttgart/antlr/.idea/encodings.xml new file mode 100644 index 00000000..e206d70d --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/encodings.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/libraries/antlr_4_4_complete.xml b/src/de/dhbwstuttgart/antlr/.idea/libraries/antlr_4_4_complete.xml new file mode 100644 index 00000000..698589c2 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/libraries/antlr_4_4_complete.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/.idea/misc.xml b/src/de/dhbwstuttgart/antlr/.idea/misc.xml new file mode 100644 index 00000000..308776f1 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/misc.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/modules.xml b/src/de/dhbwstuttgart/antlr/.idea/modules.xml new file mode 100644 index 00000000..240806a4 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/modules.xml @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/scopes/scope_settings.xml b/src/de/dhbwstuttgart/antlr/.idea/scopes/scope_settings.xml new file mode 100644 index 00000000..922003b8 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/scopes/scope_settings.xml @@ -0,0 +1,5 @@ + + + + \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/.idea/vcs.xml b/src/de/dhbwstuttgart/antlr/.idea/vcs.xml new file mode 100644 index 00000000..275077f8 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/vcs.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.idea/workspace.xml b/src/de/dhbwstuttgart/antlr/.idea/workspace.xml new file mode 100644 index 00000000..aa55e581 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.idea/workspace.xml @@ -0,0 +1,572 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + localhost + 5050 + + + + + + + + + + 1409770188585 + 1409770188585 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + No facets are configured + + + + + + + + + + + + + + + 1.8 + + + + + + + + antlr + + + + + + + + 1.8 + + + + + + + + antlr-4.4-complete + + + + + + + + + diff --git a/src/de/dhbwstuttgart/antlr/.project b/src/de/dhbwstuttgart/antlr/.project new file mode 100644 index 00000000..44689db8 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/.project @@ -0,0 +1,17 @@ + + + AntlrTest + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/src/de/dhbwstuttgart/antlr/Java8.g4 b/src/de/dhbwstuttgart/antlr/Java8.g4 new file mode 100644 index 00000000..2b1c778a --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8.g4 @@ -0,0 +1,1028 @@ +/* + [The "BSD licence"] + Copyright (c) 2014 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 8 grammar for ANTLR v4 derived from ANTLR v3 Java grammar. + * Follows syntax from spec: + * http://docs.oracle.com/javase/specs/jls/se8/html/jls-19.html + * Uses ANTLR v4's left-recursive expression notation. + * + * You can test with + * + * $ antlr4 Java.g4 + * $ javac *.java + * $ grun Java compilationUnit *.java + * + * Or, +~/antlr/code/grammars-v4/java8 $ j Test . +/Users/parrt/antlr/code/grammars-v4/java8/./Java8BaseListener.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Lexer.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Listener.java +/Users/parrt/antlr/code/grammars-v4/java8/./Java8Parser.java +/Users/parrt/antlr/code/grammars-v4/java8/./Test.java +Total lexer+parser time 384ms. + */ +grammar Java8; + +// 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 + ( '=' + | '+=' + | '-=' + | '*=' + | '/=' + | '&=' + | '|=' + | '^=' + | '>>=' + | '>>>=' + | '<<=' + | '%=' + ) + expression + ; + +primary + : '(' expression ')' + | 'this' + | 'super' + | literal + | Identifier + | type '.' 'class' + | 'void' '.' 'class' + | nonWildcardTypeArguments (explicitGenericInvocationSuffix | 'this' arguments) + ; + +creator + : nonWildcardTypeArguments createdName classCreatorRest + | createdName (arrayCreatorRest | classCreatorRest) + ; + +createdName + : Identifier typeArgumentsOrDiamond? ('.' Identifier typeArgumentsOrDiamond?)* + | primitiveType + ; + +innerCreator + : Identifier nonWildcardTypeArgumentsOrDiamond? classCreatorRest + ; + +arrayCreatorRest + : '[' + ( ']' ('[' ']')* arrayInitializer + | expression ']' ('[' expression ']')* ('[' ']')* + ) + ; + +classCreatorRest + : arguments classBody? + ; + +explicitGenericInvocation + : nonWildcardTypeArguments explicitGenericInvocationSuffix + ; + +nonWildcardTypeArguments + : '<' typeList '>' + ; + +typeArgumentsOrDiamond + : '<' '>' + | typeArguments + ; + +nonWildcardTypeArgumentsOrDiamond + : '<' '>' + | nonWildcardTypeArguments + ; + +superSuffix + : arguments + | '.' Identifier arguments? + ; + +explicitGenericInvocationSuffix + : 'super' superSuffix + | Identifier arguments + ; + +arguments + : '(' expressionList? ')' + ; + +// LEXER + +// §3.9 Keywords + +ABSTRACT : 'abstract'; +ASSERT : 'assert'; +BOOLEAN : 'boolean'; +BREAK : 'break'; +BYTE : 'byte'; +CASE : 'case'; +CATCH : 'catch'; +CHAR : 'char'; +CLASS : 'class'; +CONST : 'const'; +CONTINUE : 'continue'; +DEFAULT : 'default'; +DO : 'do'; +DOUBLE : 'double'; +ELSE : 'else'; +ENUM : 'enum'; +EXTENDS : 'extends'; +FINAL : 'final'; +FINALLY : 'finally'; +FLOAT : 'float'; +FOR : 'for'; +IF : 'if'; +GOTO : 'goto'; +IMPLEMENTS : 'implements'; +IMPORT : 'import'; +INSTANCEOF : 'instanceof'; +INT : 'int'; +INTERFACE : 'interface'; +LONG : 'long'; +NATIVE : 'native'; +NEW : 'new'; +PACKAGE : 'package'; +PRIVATE : 'private'; +PROTECTED : 'protected'; +PUBLIC : 'public'; +RETURN : 'return'; +SHORT : 'short'; +STATIC : 'static'; +STRICTFP : 'strictfp'; +SUPER : 'super'; +SWITCH : 'switch'; +SYNCHRONIZED : 'synchronized'; +THIS : 'this'; +THROW : 'throw'; +THROWS : 'throws'; +TRANSIENT : 'transient'; +TRY : 'try'; +VOID : 'void'; +VOLATILE : 'volatile'; +WHILE : 'while'; + +// §3.10.1 Integer Literals + +IntegerLiteral + : DecimalIntegerLiteral + | HexIntegerLiteral + | OctalIntegerLiteral + | BinaryIntegerLiteral + ; + +fragment +DecimalIntegerLiteral + : DecimalNumeral IntegerTypeSuffix? + ; + +fragment +HexIntegerLiteral + : HexNumeral IntegerTypeSuffix? + ; + +fragment +OctalIntegerLiteral + : OctalNumeral IntegerTypeSuffix? + ; + +fragment +BinaryIntegerLiteral + : BinaryNumeral IntegerTypeSuffix? + ; + +fragment +IntegerTypeSuffix + : [lL] + ; + +fragment +DecimalNumeral + : '0' + | NonZeroDigit (Digits? | Underscores Digits) + ; + +fragment +Digits + : Digit (DigitOrUnderscore* Digit)? + ; + +fragment +Digit + : '0' + | NonZeroDigit + ; + +fragment +NonZeroDigit + : [1-9] + ; + +fragment +DigitOrUnderscore + : Digit + | '_' + ; + +fragment +Underscores + : '_'+ + ; + +fragment +HexNumeral + : '0' [xX] HexDigits + ; + +fragment +HexDigits + : HexDigit (HexDigitOrUnderscore* HexDigit)? + ; + +fragment +HexDigit + : [0-9a-fA-F] + ; + +fragment +HexDigitOrUnderscore + : HexDigit + | '_' + ; + +fragment +OctalNumeral + : '0' Underscores? OctalDigits + ; + +fragment +OctalDigits + : OctalDigit (OctalDigitOrUnderscore* OctalDigit)? + ; + +fragment +OctalDigit + : [0-7] + ; + +fragment +OctalDigitOrUnderscore + : OctalDigit + | '_' + ; + +fragment +BinaryNumeral + : '0' [bB] BinaryDigits + ; + +fragment +BinaryDigits + : BinaryDigit (BinaryDigitOrUnderscore* BinaryDigit)? + ; + +fragment +BinaryDigit + : [01] + ; + +fragment +BinaryDigitOrUnderscore + : BinaryDigit + | '_' + ; + +// §3.10.2 Floating-Point Literals + +FloatingPointLiteral + : DecimalFloatingPointLiteral + | HexadecimalFloatingPointLiteral + ; + +fragment +DecimalFloatingPointLiteral + : Digits '.' Digits? ExponentPart? FloatTypeSuffix? + | '.' Digits ExponentPart? FloatTypeSuffix? + | Digits ExponentPart FloatTypeSuffix? + | Digits FloatTypeSuffix + ; + +fragment +ExponentPart + : ExponentIndicator SignedInteger + ; + +fragment +ExponentIndicator + : [eE] + ; + +fragment +SignedInteger + : Sign? Digits + ; + +fragment +Sign + : [+-] + ; + +fragment +FloatTypeSuffix + : [fFdD] + ; + +fragment +HexadecimalFloatingPointLiteral + : HexSignificand BinaryExponent FloatTypeSuffix? + ; + +fragment +HexSignificand + : HexNumeral '.'? + | '0' [xX] HexDigits? '.' HexDigits + ; + +fragment +BinaryExponent + : BinaryExponentIndicator SignedInteger + ; + +fragment +BinaryExponentIndicator + : [pP] + ; + +// §3.10.3 Boolean Literals + +BooleanLiteral + : 'true' + | 'false' + ; + +// §3.10.4 Character Literals + +CharacterLiteral + : '\'' SingleCharacter '\'' + | '\'' EscapeSequence '\'' + ; + +fragment +SingleCharacter + : ~['\\] + ; + +// §3.10.5 String Literals + +StringLiteral + : '"' StringCharacters? '"' + ; + +fragment +StringCharacters + : StringCharacter+ + ; + +fragment +StringCharacter + : ~["\\] + | EscapeSequence + ; + +// §3.10.6 Escape Sequences for Character and String Literals + +fragment +EscapeSequence + : '\\' [btnfr"'\\] + | OctalEscape + | UnicodeEscape + ; + +fragment +OctalEscape + : '\\' OctalDigit + | '\\' OctalDigit OctalDigit + | '\\' ZeroToThree OctalDigit OctalDigit + ; + +fragment +UnicodeEscape + : '\\' 'u' HexDigit HexDigit HexDigit HexDigit + ; + +fragment +ZeroToThree + : [0-3] + ; + +// §3.10.7 The Null Literal + +NullLiteral + : 'null' + ; + +// §3.11 Separators + +LPAREN : '('; +RPAREN : ')'; +LBRACE : '{'; +RBRACE : '}'; +LBRACK : '['; +RBRACK : ']'; +SEMI : ';'; +COMMA : ','; +DOT : '.'; + +// §3.12 Operators + +ASSIGN : '='; +GT : '>'; +LT : '<'; +BANG : '!'; +TILDE : '~'; +QUESTION : '?'; +COLON : ':'; +EQUAL : '=='; +LE : '<='; +GE : '>='; +NOTEQUAL : '!='; +AND : '&&'; +OR : '||'; +INC : '++'; +DEC : '--'; +ADD : '+'; +SUB : '-'; +MUL : '*'; +DIV : '/'; +BITAND : '&'; +BITOR : '|'; +CARET : '^'; +MOD : '%'; + +ADD_ASSIGN : '+='; +SUB_ASSIGN : '-='; +MUL_ASSIGN : '*='; +DIV_ASSIGN : '/='; +AND_ASSIGN : '&='; +OR_ASSIGN : '|='; +XOR_ASSIGN : '^='; +MOD_ASSIGN : '%='; +LSHIFT_ASSIGN : '<<='; +RSHIFT_ASSIGN : '>>='; +URSHIFT_ASSIGN : '>>>='; + +// §3.8 Identifiers (must appear after all keywords in the grammar) + +Identifier + : JavaLetter JavaLetterOrDigit* + ; + +fragment +JavaLetter + : [a-zA-Z$_] // these are the "java letters" below 0xFF + | // covers all characters above 0xFF which are not a surrogate + ~[\u0000-\u00FF\uD800-\uDBFF] + {Character.isJavaIdentifierStart(_input.LA(-1))}? + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + {Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? + ; + +fragment +JavaLetterOrDigit + : [a-zA-Z0-9$_] // these are the "java letters or digits" below 0xFF + | // covers all characters above 0xFF which are not a surrogate + ~[\u0000-\u00FF\uD800-\uDBFF] + {Character.isJavaIdentifierPart(_input.LA(-1))}? + | // covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF + [\uD800-\uDBFF] [\uDC00-\uDFFF] + {Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}? + ; + +// +// Additional symbols not defined in the lexical specification +// + +AT : '@'; +ELLIPSIS : '...'; + +// +// Whitespace and comments +// + +WS : [ \t\r\n\u000C]+ -> skip + ; + +COMMENT + : '/*' .*? '*/' -> skip + ; + +LINE_COMMENT + : '//' ~[\r\n]* -> skip + ; diff --git a/src/de/dhbwstuttgart/antlr/Java8.tokens b/src/de/dhbwstuttgart/antlr/Java8.tokens new file mode 100644 index 00000000..3f62bddf --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8.tokens @@ -0,0 +1,201 @@ +THROW=44 +STATIC=38 +INTERFACE=28 +AND_ASSIGN=93 +BREAK=4 +BYTE=5 +ELSE=15 +IF=22 +ENUM=16 +SUB=82 +BANG=69 +LPAREN=57 +DOT=65 +CASE=6 +AT=101 +LINE_COMMENT=105 +StringLiteral=55 +ELLIPSIS=102 +LBRACK=61 +PUBLIC=35 +THROWS=45 +NullLiteral=56 +RSHIFT_ASSIGN=98 +LBRACE=59 +GOTO=23 +SUB_ASSIGN=90 +SEMI=63 +CHAR=8 +ASSIGN=66 +COMMENT=104 +IMPORT=25 +BITOR=86 +CATCH=7 +MUL_ASSIGN=91 +DOUBLE=14 +PROTECTED=34 +LONG=29 +COMMA=64 +BITAND=85 +PRIVATE=33 +CONTINUE=11 +DIV=84 +FloatingPointLiteral=52 +LE=74 +CharacterLiteral=54 +VOLATILE=49 +EXTENDS=17 +INSTANCEOF=26 +NEW=31 +ADD=81 +LT=68 +CLASS=9 +DO=13 +FINALLY=19 +Identifier=100 +CONST=10 +PACKAGE=32 +OR_ASSIGN=94 +TRY=47 +IntegerLiteral=51 +SYNCHRONIZED=42 +MUL=83 +FOR=21 +FINAL=18 +RPAREN=58 +CARET=87 +URSHIFT_ASSIGN=99 +BOOLEAN=3 +NOTEQUAL=76 +RBRACK=62 +RBRACE=60 +AND=77 +THIS=43 +SWITCH=41 +VOID=48 +TRANSIENT=46 +INC=79 +FLOAT=20 +NATIVE=30 +DIV_ASSIGN=92 +BooleanLiteral=53 +ABSTRACT=1 +STRICTFP=39 +INT=27 +QUESTION=71 +RETURN=36 +LSHIFT_ASSIGN=97 +ADD_ASSIGN=89 +WS=103 +GE=75 +SUPER=40 +OR=78 +DEC=80 +MOD=88 +XOR_ASSIGN=95 +ASSERT=2 +EQUAL=73 +IMPLEMENTS=24 +COLON=72 +GT=67 +SHORT=37 +MOD_ASSIGN=96 +WHILE=50 +TILDE=70 +DEFAULT=12 +'import'=25 +'-'=82 +')'=58 +'super'=40 +'else'=15 +'%'=88 +'!'=69 +'>'=67 +'public'=35 +'=='=73 +'--'=80 +'|'=86 +'['=61 +':'=72 +'...'=102 +'throw'=44 +'case'=6 +'.'=65 +'this'=43 +'*'=83 +'switch'=41 +'synchronized'=42 +'&'=85 +'double'=14 +'break'=4 +'short'=37 +'<='=74 +'enum'=16 +'try'=47 +'?'=71 +'if'=22 +'extends'=17 +'goto'=23 +'}'=60 +'instanceof'=26 +';'=63 +'||'=78 +'>>='=98 +'class'=9 +'return'=36 +'&='=93 +'catch'=7 +'native'=30 +'continue'=11 +'strictfp'=39 +'/'=84 +'*='=91 +'+'=81 +'final'=18 +'protected'=34 +'static'=38 +'@'=101 +'transient'=46 +'~'=70 +'assert'=2 +']'=62 +'<'=68 +'++'=79 +'>>>='=99 +'>='=75 +'long'=29 +'boolean'=3 +'const'=10 +'abstract'=1 +'implements'=24 +'volatile'=49 +'throws'=45 +'/='=92 +','=64 +'-='=90 +'do'=13 +'package'=32 +'('=57 +'null'=56 +'int'=27 +'|='=94 +'for'=21 +'^'=87 +'<<='=97 +'='=66 +'byte'=5 +'&&'=77 +'^='=95 +'void'=48 +'while'=50 +'{'=59 +'float'=20 +'!='=76 +'new'=31 +'char'=8 +'finally'=19 +'interface'=28 +'%='=96 +'private'=33 +'+='=89 +'default'=12 diff --git a/src/de/dhbwstuttgart/antlr/Java8BaseVisitor.java b/src/de/dhbwstuttgart/antlr/Java8BaseVisitor.java new file mode 100644 index 00000000..0050e6c7 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8BaseVisitor.java @@ -0,0 +1,723 @@ +package de.dhbwstuttgart.antlr; + +// Generated from Java8.g4 by ANTLR 4.4 +import org.antlr.v4.runtime.misc.NotNull; +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link Java8Visitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public class Java8BaseVisitor extends AbstractParseTreeVisitor implements Java8Visitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMemberDeclaration(@NotNull Java8Parser.MemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDefaultValue(@NotNull Java8Parser.DefaultValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeElementDeclaration(@NotNull Java8Parser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitType(@NotNull Java8Parser.TypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeBody(@NotNull Java8Parser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericInterfaceMethodDeclaration(@NotNull Java8Parser.GenericInterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassBodyDeclaration(@NotNull Java8Parser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBlock(@NotNull Java8Parser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumBodyDeclarations(@NotNull Java8Parser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForUpdate(@NotNull Java8Parser.ForUpdateContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnhancedForControl(@NotNull Java8Parser.EnhancedForControlContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationConstantRest(@NotNull Java8Parser.AnnotationConstantRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExplicitGenericInvocation(@NotNull Java8Parser.ExplicitGenericInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNonWildcardTypeArgumentsOrDiamond(@NotNull Java8Parser.NonWildcardTypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpressionList(@NotNull Java8Parser.ExpressionListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeElementRest(@NotNull Java8Parser.AnnotationTypeElementRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassOrInterfaceType(@NotNull Java8Parser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeBound(@NotNull Java8Parser.TypeBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclaratorId(@NotNull Java8Parser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPrimary(@NotNull Java8Parser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassCreatorRest(@NotNull Java8Parser.ClassCreatorRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceBodyDeclaration(@NotNull Java8Parser.InterfaceBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArguments(@NotNull Java8Parser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationName(@NotNull Java8Parser.AnnotationNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFinallyBlock(@NotNull Java8Parser.FinallyBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameters(@NotNull Java8Parser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLastFormalParameter(@NotNull Java8Parser.LastFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructorBody(@NotNull Java8Parser.ConstructorBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLiteral(@NotNull Java8Parser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationMethodOrConstantRest(@NotNull Java8Parser.AnnotationMethodOrConstantRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCatchClause(@NotNull Java8Parser.CatchClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclarator(@NotNull Java8Parser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeList(@NotNull Java8Parser.TypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumConstants(@NotNull Java8Parser.EnumConstantsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassBody(@NotNull Java8Parser.ClassBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCreatedName(@NotNull Java8Parser.CreatedNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumDeclaration(@NotNull Java8Parser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameter(@NotNull Java8Parser.FormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParExpression(@NotNull Java8Parser.ParExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotation(@NotNull Java8Parser.AnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableInitializer(@NotNull Java8Parser.VariableInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValueArrayInitializer(@NotNull Java8Parser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCreator(@NotNull Java8Parser.CreatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayCreatorRest(@NotNull Java8Parser.ArrayCreatorRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpression(@NotNull Java8Parser.ExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstantExpression(@NotNull Java8Parser.ConstantExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitQualifiedNameList(@NotNull Java8Parser.QualifiedNameListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructorDeclaration(@NotNull Java8Parser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForControl(@NotNull Java8Parser.ForControlContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSuperSuffix(@NotNull Java8Parser.SuperSuffixContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclarators(@NotNull Java8Parser.VariableDeclaratorsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCatchType(@NotNull Java8Parser.CatchTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassOrInterfaceModifier(@NotNull Java8Parser.ClassOrInterfaceModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumConstantName(@NotNull Java8Parser.EnumConstantNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitModifier(@NotNull Java8Parser.ModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInnerCreator(@NotNull Java8Parser.InnerCreatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExplicitGenericInvocationSuffix(@NotNull Java8Parser.ExplicitGenericInvocationSuffixContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableModifier(@NotNull Java8Parser.VariableModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValuePair(@NotNull Java8Parser.ElementValuePairContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayInitializer(@NotNull Java8Parser.ArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValue(@NotNull Java8Parser.ElementValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstDeclaration(@NotNull Java8Parser.ConstDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResource(@NotNull Java8Parser.ResourceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitQualifiedName(@NotNull Java8Parser.QualifiedNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResourceSpecification(@NotNull Java8Parser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameterList(@NotNull Java8Parser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeDeclaration(@NotNull Java8Parser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCompilationUnit(@NotNull Java8Parser.CompilationUnitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationMethodRest(@NotNull Java8Parser.AnnotationMethodRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSwitchBlockStatementGroup(@NotNull Java8Parser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameter(@NotNull Java8Parser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceBody(@NotNull Java8Parser.InterfaceBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodDeclaration(@NotNull Java8Parser.MethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodBody(@NotNull Java8Parser.MethodBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgument(@NotNull Java8Parser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeDeclaration(@NotNull Java8Parser.TypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericConstructorDeclaration(@NotNull Java8Parser.GenericConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassDeclaration(@NotNull Java8Parser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumConstant(@NotNull Java8Parser.EnumConstantContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStatement(@NotNull Java8Parser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitImportDeclaration(@NotNull Java8Parser.ImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPrimitiveType(@NotNull Java8Parser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceDeclaration(@NotNull Java8Parser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLocalVariableDeclarationStatement(@NotNull Java8Parser.LocalVariableDeclarationStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBlockStatement(@NotNull Java8Parser.BlockStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFieldDeclaration(@NotNull Java8Parser.FieldDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstantDeclarator(@NotNull Java8Parser.ConstantDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResources(@NotNull Java8Parser.ResourcesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStatementExpression(@NotNull Java8Parser.StatementExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceMethodDeclaration(@NotNull Java8Parser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPackageDeclaration(@NotNull Java8Parser.PackageDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValuePairs(@NotNull Java8Parser.ElementValuePairsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLocalVariableDeclaration(@NotNull Java8Parser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNonWildcardTypeArguments(@NotNull Java8Parser.NonWildcardTypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceMemberDeclaration(@NotNull Java8Parser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSwitchLabel(@NotNull Java8Parser.SwitchLabelContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForInit(@NotNull Java8Parser.ForInitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameters(@NotNull Java8Parser.FormalParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArguments(@NotNull Java8Parser.ArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericMethodDeclaration(@NotNull Java8Parser.GenericMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgumentsOrDiamond(@NotNull Java8Parser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/Java8Lexer.java b/src/de/dhbwstuttgart/antlr/Java8Lexer.java new file mode 100644 index 00000000..8af17245 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8Lexer.java @@ -0,0 +1,517 @@ +package de.dhbwstuttgart.antlr; + +// Generated from Java8.g4 by ANTLR 4.4 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, 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 = { + "'\\u0000'", "'\\u0001'", "'\\u0002'", "'\\u0003'", "'\\u0004'", "'\\u0005'", + "'\\u0006'", "'\\u0007'", "'\b'", "'\t'", "'\n'", "'\\u000B'", "'\f'", + "'\r'", "'\\u000E'", "'\\u000F'", "'\\u0010'", "'\\u0011'", "'\\u0012'", + "'\\u0013'", "'\\u0014'", "'\\u0015'", "'\\u0016'", "'\\u0017'", "'\\u0018'", + "'\\u0019'", "'\\u001A'", "'\\u001B'", "'\\u001C'", "'\\u001D'", "'\\u001E'", + "'\\u001F'", "' '", "'!'", "'\"'", "'#'", "'$'", "'%'", "'&'", "'''", + "'('", "')'", "'*'", "'+'", "','", "'-'", "'.'", "'/'", "'0'", "'1'", + "'2'", "'3'", "'4'", "'5'", "'6'", "'7'", "'8'", "'9'", "':'", "';'", + "'<'", "'='", "'>'", "'?'", "'@'", "'A'", "'B'", "'C'", "'D'", "'E'", + "'F'", "'G'", "'H'", "'I'", "'J'", "'K'", "'L'", "'M'", "'N'", "'O'", + "'P'", "'Q'", "'R'", "'S'", "'T'", "'U'", "'V'", "'W'", "'X'", "'Y'", + "'Z'", "'['", "'\\'", "']'", "'^'", "'_'", "'`'", "'a'", "'b'", "'c'", + "'d'", "'e'", "'f'", "'g'", "'h'", "'i'" + }; + 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 Java8Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Java8.g4"; } + + @Override + public String[] getTokenNames() { return tokenNames; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 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\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\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\2\u0095\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+ + "\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+ + "\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60"+ + "_\61a\62c\63e\64g\65i\2k\2m\2o\2q\2s\2u\2w\2y\2{\2}\2\177\2\u0081\2\u0083"+ + "\2\u0085\2\u0087\2\u0089\2\u008b\2\u008d\2\u008f\2\u0091\2\u0093\2\u0095"+ + "\2\u0097\66\u0099\2\u009b\2\u009d\2\u009f\2\u00a1\2\u00a3\2\u00a5\2\u00a7"+ + "\2\u00a9\2\u00ab\2\u00ad\67\u00af8\u00b1\2\u00b39\u00b5\2\u00b7\2\u00b9"+ + "\2\u00bb\2\u00bd\2\u00bf\2\u00c1:\u00c3;\u00c5<\u00c7=\u00c9>\u00cb?\u00cd"+ + "@\u00cfA\u00d1B\u00d3C\u00d5D\u00d7E\u00d9F\u00dbG\u00ddH\u00dfI\u00e1"+ + "J\u00e3K\u00e5L\u00e7M\u00e9N\u00ebO\u00edP\u00efQ\u00f1R\u00f3S\u00f5"+ + "T\u00f7U\u00f9V\u00fbW\u00fdX\u00ffY\u0101Z\u0103[\u0105\\\u0107]\u0109"+ + "^\u010b_\u010d`\u010fa\u0111b\u0113c\u0115d\u0117e\u0119f\u011b\2\u011d"+ + "\2\u011fg\u0121h\u0123i\u0125j\u0127k\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\2FFHHffhh\4\2R"+ + "Rrr\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\2"+ + "C\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\2Y\3\2\2\2\2[\3\2\2"+ + "\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2"+ + "\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\7c\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\7"+ + "c\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\7"+ + "f\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\7g\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\7"+ + "r\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\u021dL\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\u0247V\3\2\2\2\u0248\u0249"+ + "\7v\2\2\u0249\u024a\7j\2\2\u024a\u024b\7k\2\2\u024b\u024c\7u\2\2\u024c"+ + "X\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\u02a9v\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\u0085"+ + "C\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\u0083"+ + "B\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\u009bN\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\u00a3R\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\u008b"+ + "F\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\u0083"+ + "B\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\2\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\2\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\3\b\2\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/Java8Lexer.tokens b/src/de/dhbwstuttgart/antlr/Java8Lexer.tokens new file mode 100644 index 00000000..3f62bddf --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8Lexer.tokens @@ -0,0 +1,201 @@ +THROW=44 +STATIC=38 +INTERFACE=28 +AND_ASSIGN=93 +BREAK=4 +BYTE=5 +ELSE=15 +IF=22 +ENUM=16 +SUB=82 +BANG=69 +LPAREN=57 +DOT=65 +CASE=6 +AT=101 +LINE_COMMENT=105 +StringLiteral=55 +ELLIPSIS=102 +LBRACK=61 +PUBLIC=35 +THROWS=45 +NullLiteral=56 +RSHIFT_ASSIGN=98 +LBRACE=59 +GOTO=23 +SUB_ASSIGN=90 +SEMI=63 +CHAR=8 +ASSIGN=66 +COMMENT=104 +IMPORT=25 +BITOR=86 +CATCH=7 +MUL_ASSIGN=91 +DOUBLE=14 +PROTECTED=34 +LONG=29 +COMMA=64 +BITAND=85 +PRIVATE=33 +CONTINUE=11 +DIV=84 +FloatingPointLiteral=52 +LE=74 +CharacterLiteral=54 +VOLATILE=49 +EXTENDS=17 +INSTANCEOF=26 +NEW=31 +ADD=81 +LT=68 +CLASS=9 +DO=13 +FINALLY=19 +Identifier=100 +CONST=10 +PACKAGE=32 +OR_ASSIGN=94 +TRY=47 +IntegerLiteral=51 +SYNCHRONIZED=42 +MUL=83 +FOR=21 +FINAL=18 +RPAREN=58 +CARET=87 +URSHIFT_ASSIGN=99 +BOOLEAN=3 +NOTEQUAL=76 +RBRACK=62 +RBRACE=60 +AND=77 +THIS=43 +SWITCH=41 +VOID=48 +TRANSIENT=46 +INC=79 +FLOAT=20 +NATIVE=30 +DIV_ASSIGN=92 +BooleanLiteral=53 +ABSTRACT=1 +STRICTFP=39 +INT=27 +QUESTION=71 +RETURN=36 +LSHIFT_ASSIGN=97 +ADD_ASSIGN=89 +WS=103 +GE=75 +SUPER=40 +OR=78 +DEC=80 +MOD=88 +XOR_ASSIGN=95 +ASSERT=2 +EQUAL=73 +IMPLEMENTS=24 +COLON=72 +GT=67 +SHORT=37 +MOD_ASSIGN=96 +WHILE=50 +TILDE=70 +DEFAULT=12 +'import'=25 +'-'=82 +')'=58 +'super'=40 +'else'=15 +'%'=88 +'!'=69 +'>'=67 +'public'=35 +'=='=73 +'--'=80 +'|'=86 +'['=61 +':'=72 +'...'=102 +'throw'=44 +'case'=6 +'.'=65 +'this'=43 +'*'=83 +'switch'=41 +'synchronized'=42 +'&'=85 +'double'=14 +'break'=4 +'short'=37 +'<='=74 +'enum'=16 +'try'=47 +'?'=71 +'if'=22 +'extends'=17 +'goto'=23 +'}'=60 +'instanceof'=26 +';'=63 +'||'=78 +'>>='=98 +'class'=9 +'return'=36 +'&='=93 +'catch'=7 +'native'=30 +'continue'=11 +'strictfp'=39 +'/'=84 +'*='=91 +'+'=81 +'final'=18 +'protected'=34 +'static'=38 +'@'=101 +'transient'=46 +'~'=70 +'assert'=2 +']'=62 +'<'=68 +'++'=79 +'>>>='=99 +'>='=75 +'long'=29 +'boolean'=3 +'const'=10 +'abstract'=1 +'implements'=24 +'volatile'=49 +'throws'=45 +'/='=92 +','=64 +'-='=90 +'do'=13 +'package'=32 +'('=57 +'null'=56 +'int'=27 +'|='=94 +'for'=21 +'^'=87 +'<<='=97 +'='=66 +'byte'=5 +'&&'=77 +'^='=95 +'void'=48 +'while'=50 +'{'=59 +'float'=20 +'!='=76 +'new'=31 +'char'=8 +'finally'=19 +'interface'=28 +'%='=96 +'private'=33 +'+='=89 +'default'=12 diff --git a/src/de/dhbwstuttgart/antlr/Java8Parser.java b/src/de/dhbwstuttgart/antlr/Java8Parser.java new file mode 100644 index 00000000..96aee9a3 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8Parser.java @@ -0,0 +1,7394 @@ +package de.dhbwstuttgart.antlr; + +// Generated from Java8.g4 by ANTLR 4.4 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Java8Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, + WHILE=50, IntegerLiteral=51, FloatingPointLiteral=52, BooleanLiteral=53, + CharacterLiteral=54, StringLiteral=55, NullLiteral=56, LPAREN=57, RPAREN=58, + LBRACE=59, RBRACE=60, LBRACK=61, RBRACK=62, SEMI=63, COMMA=64, DOT=65, + ASSIGN=66, GT=67, LT=68, BANG=69, TILDE=70, QUESTION=71, COLON=72, EQUAL=73, + LE=74, GE=75, NOTEQUAL=76, AND=77, OR=78, INC=79, DEC=80, ADD=81, SUB=82, + MUL=83, DIV=84, BITAND=85, BITOR=86, CARET=87, MOD=88, 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 = { + "", "'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 "Java8.g4"; } + + @Override + public String[] getTokenNames() { return tokenNames; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public Java8Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + public static class CompilationUnitContext extends ParserRuleContext { + public TypeDeclarationContext typeDeclaration(int i) { + return getRuleContext(TypeDeclarationContext.class,i); + } + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class,i); + } + public List importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + public TerminalNode EOF() { return getToken(Java8Parser.EOF, 0); } + public PackageDeclarationContext packageDeclaration() { + return getRuleContext(PackageDeclarationContext.class,0); + } + public List typeDeclaration() { + return getRuleContexts(TypeDeclarationContext.class); + } + public CompilationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compilationUnit; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class,0); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { + return getRuleContext(ClassOrInterfaceModifierContext.class,i); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public List classOrInterfaceModifier() { + return getRuleContexts(ClassOrInterfaceModifierContext.class); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(Java8Parser.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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 type() { + return getRuleContexts(TypeContext.class); + } + public TypeBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeBound; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 EnumBodyDeclarationsContext enumBodyDeclarations() { + return getRuleContext(EnumBodyDeclarationsContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public TerminalNode ENUM() { return getToken(Java8Parser.ENUM, 0); } + public EnumConstantsContext enumConstants() { + return getRuleContext(EnumConstantsContext.class,0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class,i); + } + public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumBodyDeclarations; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public InterfaceBodyContext interfaceBody() { + return getRuleContext(InterfaceBodyContext.class,0); + } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 type() { + return getRuleContexts(TypeContext.class); + } + public TypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeList; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class,i); + } + public ClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBody; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List interfaceBodyDeclaration() { + return getRuleContexts(InterfaceBodyDeclarationContext.class); + } + public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { + return getRuleContext(InterfaceBodyDeclarationContext.class,i); + } + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBody; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List modifier() { + return getRuleContexts(ModifierContext.class); + } + public MemberDeclarationContext memberDeclaration() { + return getRuleContext(MemberDeclarationContext.class,0); + } + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class,i); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 GenericMethodDeclarationContext genericMethodDeclaration() { + return getRuleContext(GenericMethodDeclarationContext.class,0); + } + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public GenericConstructorDeclarationContext genericConstructorDeclaration() { + return getRuleContext(GenericConstructorDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public FieldDeclarationContext fieldDeclaration() { + return getRuleContext(FieldDeclarationContext.class,0); + } + public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericMethodDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ConstructorBodyContext constructorBody() { + return getRuleContext(ConstructorBodyContext.class,0); + } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List modifier() { + return getRuleContexts(ModifierContext.class); + } + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class,i); + } + public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { + return getRuleContext(InterfaceMemberDeclarationContext.class,0); + } + public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { + return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public ConstDeclarationContext constDeclaration() { + return getRuleContext(ConstDeclarationContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ConstantDeclaratorContext constantDeclarator(int i) { + return getRuleContext(ConstantDeclaratorContext.class,i); + } + public List constantDeclarator() { + return getRuleContexts(ConstantDeclaratorContext.class); + } + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(Java8Parser.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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List variableDeclarator() { + return getRuleContexts(VariableDeclaratorContext.class); + } + public VariableDeclaratorContext variableDeclarator(int i) { + return getRuleContext(VariableDeclaratorContext.class,i); + } + public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarators; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarator; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(Java8Parser.Identifier, 0); } + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializer; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayInitializer; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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(Java8Parser.Identifier, 0); } + public EnumConstantNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstantName; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 List typeArguments() { + return getRuleContexts(TypeArgumentsContext.class); + } + public List Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public TypeArgumentsContext typeArguments(int i) { + return getRuleContext(TypeArgumentsContext.class,i); + } + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class,i); + } + public QualifiedNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedNameList; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameter; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lastFormalParameter; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public QualifiedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedName; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 StringLiteral() { return getToken(Java8Parser.StringLiteral, 0); } + public TerminalNode IntegerLiteral() { return getToken(Java8Parser.IntegerLiteral, 0); } + public TerminalNode FloatingPointLiteral() { return getToken(Java8Parser.FloatingPointLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(Java8Parser.BooleanLiteral, 0); } + public TerminalNode CharacterLiteral() { return getToken(Java8Parser.CharacterLiteral, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ElementValuePairsContext elementValuePairs() { + return getRuleContext(ElementValuePairsContext.class,0); + } + public AnnotationNameContext annotationName() { + return getRuleContext(AnnotationNameContext.class,0); + } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotation; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ElementValuePairContext elementValuePair(int i) { + return getRuleContext(ElementValuePairContext.class,i); + } + public List elementValuePair() { + return getRuleContexts(ElementValuePairContext.class); + } + public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePairs; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public ElementValuePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePair; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 elementValue() { + return getRuleContexts(ElementValueContext.class); + } + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public AnnotationTypeBodyContext annotationTypeBody() { + return getRuleContext(AnnotationTypeBodyContext.class,0); + } + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { + return getRuleContext(AnnotationMethodOrConstantRestContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 AnnotationMethodRestContext annotationMethodRest() { + return getRuleContext(AnnotationMethodRestContext.class,0); + } + public AnnotationConstantRestContext annotationConstantRest() { + return getRuleContext(AnnotationConstantRestContext.class,0); + } + public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationMethodRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TypeDeclarationContext typeDeclaration() { + return getRuleContext(TypeDeclarationContext.class,0); + } + public StatementContext statement() { + return getRuleContext(StatementContext.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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class,0); + } + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public StatementExpressionContext statementExpression() { + return getRuleContext(StatementExpressionContext.class,0); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public List switchBlockStatementGroup() { + return getRuleContexts(SwitchBlockStatementGroupContext.class); + } + public ParExpressionContext parExpression() { + return getRuleContext(ParExpressionContext.class,0); + } + public List catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public FinallyBlockContext finallyBlock() { + return getRuleContext(FinallyBlockContext.class,0); + } + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return getRuleContext(SwitchBlockStatementGroupContext.class,i); + } + public ForControlContext forControl() { + return getRuleContext(ForControlContext.class,0); + } + public TerminalNode ASSERT() { return getToken(Java8Parser.ASSERT, 0); } + public ResourceSpecificationContext resourceSpecification() { + return getRuleContext(ResourceSpecificationContext.class,0); + } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 CatchTypeContext catchType() { + return getRuleContext(CatchTypeContext.class,0); + } + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class,i); + } + public CatchTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchType; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ResourceContext resource(int i) { + return getRuleContext(ResourceContext.class,i); + } + public List resource() { + return getRuleContexts(ResourceContext.class); + } + public ResourcesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resources; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + 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 VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ResourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resource; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class,i); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 ForUpdateContext forUpdate() { + return getRuleContext(ForUpdateContext.class,0); + } + 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 ForControlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forControl; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInit; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionList; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public ExplicitGenericInvocationContext explicitGenericInvocation() { + return getRuleContext(ExplicitGenericInvocationContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public InnerCreatorContext innerCreator() { + return getRuleContext(InnerCreatorContext.class,0); + } + public SuperSuffixContext superSuffix() { + return getRuleContext(SuperSuffixContext.class,0); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public CreatorContext creator() { + return getRuleContext(CreatorContext.class,0); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 174; + enterRecursionRule(_localctx, 174, RULE_expression, _p); + 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(1147); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,128,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(1145); + switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { + case 1: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1062); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + 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); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1065); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + 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); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1068); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + 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); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1079); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + 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); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1082); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + 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); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1085); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(1086); match(BITAND); + setState(1087); expression(8); + } + break; + case 7: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1088); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(1089); match(CARET); + setState(1090); expression(7); + } + break; + case 8: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1091); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(1092); match(BITOR); + setState(1093); expression(6); + } + break; + case 9: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1094); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(1095); match(AND); + setState(1096); expression(5); + } + break; + case 10: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1097); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(1098); match(OR); + setState(1099); expression(4); + } + break; + case 11: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1100); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1101); match(QUESTION); + setState(1102); expression(0); + setState(1103); match(COLON); + setState(1104); expression(3); + } + break; + case 12: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1106); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(1107); + _la = _input.LA(1); + if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ASSIGN - 66)) | (1L << (ADD_ASSIGN - 66)) | (1L << (SUB_ASSIGN - 66)) | (1L << (MUL_ASSIGN - 66)) | (1L << (DIV_ASSIGN - 66)) | (1L << (AND_ASSIGN - 66)) | (1L << (OR_ASSIGN - 66)) | (1L << (XOR_ASSIGN - 66)) | (1L << (MOD_ASSIGN - 66)) | (1L << (LSHIFT_ASSIGN - 66)) | (1L << (RSHIFT_ASSIGN - 66)) | (1L << (URSHIFT_ASSIGN - 66)))) != 0)) ) { + _errHandler.recoverInline(this); + } + consume(); + setState(1108); expression(2); + } + break; + case 13: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1109); + if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(1110); match(DOT); + setState(1111); match(Identifier); + } + break; + case 14: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1112); + if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(1113); match(DOT); + setState(1114); match(THIS); + } + break; + case 15: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1115); + if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); + setState(1116); match(DOT); + setState(1117); match(NEW); + setState(1119); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1118); nonWildcardTypeArguments(); + } + } + + setState(1121); innerCreator(); + } + break; + case 16: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1122); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(1123); match(DOT); + setState(1124); match(SUPER); + setState(1125); superSuffix(); + } + break; + case 17: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1126); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(1127); match(DOT); + setState(1128); explicitGenericInvocation(); + } + break; + case 18: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1129); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(1130); match(LBRACK); + setState(1131); expression(0); + setState(1132); match(RBRACK); + } + break; + case 19: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1134); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(1135); match(LPAREN); + setState(1137); + _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(1136); expressionList(); + } + } + + setState(1139); match(RPAREN); + } + break; + case 20: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1140); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(1141); + _la = _input.LA(1); + if ( !(_la==INC || _la==DEC) ) { + _errHandler.recoverInline(this); + } + consume(); + } + break; + case 21: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1142); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(1143); match(INSTANCEOF); + setState(1144); type(); + } + break; + } + } + } + setState(1149); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,128,_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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { + return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); + } + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TypeContext type() { + return getRuleContext(TypeContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1171); + switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1150); match(LPAREN); + setState(1151); expression(0); + setState(1152); match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1154); match(THIS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1155); match(SUPER); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1156); literal(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1157); match(Identifier); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1158); type(); + setState(1159); match(DOT); + setState(1160); match(CLASS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1162); match(VOID); + setState(1163); match(DOT); + setState(1164); match(CLASS); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1165); nonWildcardTypeArguments(); + setState(1169); + switch (_input.LA(1)) { + case SUPER: + case Identifier: + { + setState(1166); explicitGenericInvocationSuffix(); + } + break; + case THIS: + { + setState(1167); match(THIS); + setState(1168); 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 ArrayCreatorRestContext arrayCreatorRest() { + return getRuleContext(ArrayCreatorRestContext.class,0); + } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1182); + switch (_input.LA(1)) { + case LT: + enterOuterAlt(_localctx, 1); + { + setState(1173); nonWildcardTypeArguments(); + setState(1174); createdName(); + setState(1175); classCreatorRest(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1177); createdName(); + setState(1180); + switch (_input.LA(1)) { + case LBRACK: + { + setState(1178); arrayCreatorRest(); + } + break; + case LPAREN: + { + setState(1179); classCreatorRest(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CreatedNameContext extends ParserRuleContext { + public List Identifier() { return getTokens(Java8Parser.Identifier); } + public TerminalNode Identifier(int i) { + return getToken(Java8Parser.Identifier, i); + } + public List typeArgumentsOrDiamond() { + return getRuleContexts(TypeArgumentsOrDiamondContext.class); + } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) { + return getRuleContext(TypeArgumentsOrDiamondContext.class,i); + } + public CreatedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdName; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1199); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1184); match(Identifier); + setState(1186); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1185); typeArgumentsOrDiamond(); + } + } + + setState(1195); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(1188); match(DOT); + setState(1189); match(Identifier); + setState(1191); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1190); typeArgumentsOrDiamond(); + } + } + + } + } + setState(1197); + _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(1198); primitiveType(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InnerCreatorContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public ClassCreatorRestContext classCreatorRest() { + return getRuleContext(ClassCreatorRestContext.class,0); + } + public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() { + return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0); + } + public InnerCreatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_innerCreator; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1201); match(Identifier); + setState(1203); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1202); nonWildcardTypeArgumentsOrDiamond(); + } + } + + setState(1205); classCreatorRest(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayCreatorRestContext extends ParserRuleContext { + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayCreatorRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1207); match(LBRACK); + setState(1235); + switch (_input.LA(1)) { + case RBRACK: + { + setState(1208); match(RBRACK); + setState(1213); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1209); match(LBRACK); + setState(1210); match(RBRACK); + } + } + setState(1215); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1216); 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(1217); expression(0); + setState(1218); match(RBRACK); + setState(1225); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,139,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1219); match(LBRACK); + setState(1220); expression(0); + setState(1221); match(RBRACK); + } + } + } + setState(1227); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,139,_ctx); + } + setState(1232); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,140,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1228); match(LBRACK); + setState(1229); match(RBRACK); + } + } + } + setState(1234); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,140,_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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1237); arguments(); + setState(1239); + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { + case 1: + { + setState(1238); 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1241); nonWildcardTypeArguments(); + setState(1242); 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1244); match(LT); + setState(1245); typeList(); + setState(1246); 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1251); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1248); match(LT); + setState(1249); match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1250); 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1256); + switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1253); match(LT); + setState(1254); match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1255); 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(Java8Parser.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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1264); + switch (_input.LA(1)) { + case LPAREN: + enterOuterAlt(_localctx, 1); + { + setState(1258); arguments(); + } + break; + case DOT: + enterOuterAlt(_localctx, 2); + { + setState(1259); match(DOT); + setState(1260); match(Identifier); + setState(1262); + switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + case 1: + { + setState(1261); 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 TerminalNode Identifier() { return getToken(Java8Parser.Identifier, 0); } + public SuperSuffixContext superSuffix() { + return getRuleContext(SuperSuffixContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1270); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(1266); match(SUPER); + setState(1267); superSuffix(); + } + break; + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1268); match(Identifier); + setState(1269); 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 T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof Java8Visitor ) return ((Java8Visitor)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(1272); match(LPAREN); + setState(1274); + _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(1273); expressionList(); + } + } + + setState(1276); 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 precpred(_ctx, 13); + case 1: return precpred(_ctx, 12); + case 2: return precpred(_ctx, 11); + case 3: return precpred(_ctx, 10); + case 4: return precpred(_ctx, 8); + case 5: return precpred(_ctx, 7); + case 6: return precpred(_ctx, 6); + case 7: return precpred(_ctx, 5); + case 8: return precpred(_ctx, 4); + case 9: return precpred(_ctx, 3); + case 10: return precpred(_ctx, 2); + case 11: return precpred(_ctx, 1); + case 12: return precpred(_ctx, 25); + case 13: return precpred(_ctx, 24); + case 14: return precpred(_ctx, 23); + case 15: return precpred(_ctx, 22); + case 16: return precpred(_ctx, 21); + case 17: return precpred(_ctx, 20); + case 18: return precpred(_ctx, 19); + case 19: return precpred(_ctx, 16); + case 20: return precpred(_ctx, 9); + } + return true; + } + + public static final String _serializedATN = + "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3k\u0501\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\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u0462\nY"+ + "\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u0474\nY\3Y\3Y\3Y"+ + "\3Y\3Y\3Y\7Y\u047c\nY\fY\16Y\u047f\13Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3"+ + "Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u0494\nZ\5Z\u0496\nZ\3[\3[\3[\3[\3[\3[\3"+ + "[\5[\u049f\n[\5[\u04a1\n[\3\\\3\\\5\\\u04a5\n\\\3\\\3\\\3\\\5\\\u04aa"+ + "\n\\\7\\\u04ac\n\\\f\\\16\\\u04af\13\\\3\\\5\\\u04b2\n\\\3]\3]\5]\u04b6"+ + "\n]\3]\3]\3^\3^\3^\3^\7^\u04be\n^\f^\16^\u04c1\13^\3^\3^\3^\3^\3^\3^\3"+ + "^\7^\u04ca\n^\f^\16^\u04cd\13^\3^\3^\7^\u04d1\n^\f^\16^\u04d4\13^\5^\u04d6"+ + "\n^\3_\3_\5_\u04da\n_\3`\3`\3`\3a\3a\3a\3a\3b\3b\3b\5b\u04e6\nb\3c\3c"+ + "\3c\5c\u04eb\nc\3d\3d\3d\3d\5d\u04f1\nd\5d\u04f3\nd\3e\3e\3e\3e\5e\u04f9"+ + "\ne\3f\3f\5f\u04fd\nf\3f\3f\3f\2\3\u00b0g\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\17\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\4\2DD[e\3\2QR\u0573\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\2d\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\u0495\3\2\2\2\u00b4\u04a0\3\2"+ + "\2\2\u00b6\u04b1\3\2\2\2\u00b8\u04b3\3\2\2\2\u00ba\u04b9\3\2\2\2\u00bc"+ + "\u04d7\3\2\2\2\u00be\u04db\3\2\2\2\u00c0\u04de\3\2\2\2\u00c2\u04e5\3\2"+ + "\2\2\u00c4\u04ea\3\2\2\2\u00c6\u04f2\3\2\2\2\u00c8\u04f8\3\2\2\2\u00ca"+ + "\u04fa\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\u0262"+ + "S\3\2\2\2\u0263\u0264\7F\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\u027c"+ + "Y\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\u02a7c\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\u02b0"+ + "g\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\u02bdk\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\5r:\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\7A\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\u00a8U\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\u0094K\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\u0086D\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\u00b0Y\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\23\u041e"+ + "\u0427\3\2\2\2\u041f\u0420\t\7\2\2\u0420\u0427\5\u00b0Y\21\u0421\u0422"+ + "\t\b\2\2\u0422\u0427\5\u00b0Y\20\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\u047d\3\2"+ + "\2\2\u0428\u0429\f\17\2\2\u0429\u042a\t\t\2\2\u042a\u047c\5\u00b0Y\20"+ + "\u042b\u042c\f\16\2\2\u042c\u042d\t\n\2\2\u042d\u047c\5\u00b0Y\17\u042e"+ + "\u0436\f\r\2\2\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\u047c\5\u00b0Y\16\u0439\u043a\f\f\2\2\u043a\u043b"+ + "\t\13\2\2\u043b\u047c\5\u00b0Y\r\u043c\u043d\f\n\2\2\u043d\u043e\t\f\2"+ + "\2\u043e\u047c\5\u00b0Y\13\u043f\u0440\f\t\2\2\u0440\u0441\7W\2\2\u0441"+ + "\u047c\5\u00b0Y\n\u0442\u0443\f\b\2\2\u0443\u0444\7Y\2\2\u0444\u047c\5"+ + "\u00b0Y\t\u0445\u0446\f\7\2\2\u0446\u0447\7X\2\2\u0447\u047c\5\u00b0Y"+ + "\b\u0448\u0449\f\6\2\2\u0449\u044a\7O\2\2\u044a\u047c\5\u00b0Y\7\u044b"+ + "\u044c\f\5\2\2\u044c\u044d\7P\2\2\u044d\u047c\5\u00b0Y\6\u044e\u044f\f"+ + "\4\2\2\u044f\u0450\7I\2\2\u0450\u0451\5\u00b0Y\2\u0451\u0452\7J\2\2\u0452"+ + "\u0453\5\u00b0Y\5\u0453\u047c\3\2\2\2\u0454\u0455\f\3\2\2\u0455\u0456"+ + "\t\r\2\2\u0456\u047c\5\u00b0Y\4\u0457\u0458\f\33\2\2\u0458\u0459\7C\2"+ + "\2\u0459\u047c\7f\2\2\u045a\u045b\f\32\2\2\u045b\u045c\7C\2\2\u045c\u047c"+ + "\7-\2\2\u045d\u045e\f\31\2\2\u045e\u045f\7C\2\2\u045f\u0461\7!\2\2\u0460"+ + "\u0462\5\u00c0a\2\u0461\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463"+ + "\3\2\2\2\u0463\u047c\5\u00b8]\2\u0464\u0465\f\30\2\2\u0465\u0466\7C\2"+ + "\2\u0466\u0467\7*\2\2\u0467\u047c\5\u00c6d\2\u0468\u0469\f\27\2\2\u0469"+ + "\u046a\7C\2\2\u046a\u047c\5\u00be`\2\u046b\u046c\f\26\2\2\u046c\u046d"+ + "\7?\2\2\u046d\u046e\5\u00b0Y\2\u046e\u046f\7@\2\2\u046f\u047c\3\2\2\2"+ + "\u0470\u0471\f\25\2\2\u0471\u0473\7;\2\2\u0472\u0474\5\u00aaV\2\u0473"+ + "\u0472\3\2\2\2\u0473\u0474\3\2\2\2\u0474\u0475\3\2\2\2\u0475\u047c\7<"+ + "\2\2\u0476\u0477\f\22\2\2\u0477\u047c\t\16\2\2\u0478\u0479\f\13\2\2\u0479"+ + "\u047a\7\34\2\2\u047a\u047c\5N(\2\u047b\u0428\3\2\2\2\u047b\u042b\3\2"+ + "\2\2\u047b\u042e\3\2\2\2\u047b\u0439\3\2\2\2\u047b\u043c\3\2\2\2\u047b"+ + "\u043f\3\2\2\2\u047b\u0442\3\2\2\2\u047b\u0445\3\2\2\2\u047b\u0448\3\2"+ + "\2\2\u047b\u044b\3\2\2\2\u047b\u044e\3\2\2\2\u047b\u0454\3\2\2\2\u047b"+ + "\u0457\3\2\2\2\u047b\u045a\3\2\2\2\u047b\u045d\3\2\2\2\u047b\u0464\3\2"+ + "\2\2\u047b\u0468\3\2\2\2\u047b\u046b\3\2\2\2\u047b\u0470\3\2\2\2\u047b"+ + "\u0476\3\2\2\2\u047b\u0478\3\2\2\2\u047c\u047f\3\2\2\2\u047d\u047b\3\2"+ + "\2\2\u047d\u047e\3\2\2\2\u047e\u00b1\3\2\2\2\u047f\u047d\3\2\2\2\u0480"+ + "\u0481\7;\2\2\u0481\u0482\5\u00b0Y\2\u0482\u0483\7<\2\2\u0483\u0496\3"+ + "\2\2\2\u0484\u0496\7-\2\2\u0485\u0496\7*\2\2\u0486\u0496\5h\65\2\u0487"+ + "\u0496\7f\2\2\u0488\u0489\5N(\2\u0489\u048a\7C\2\2\u048a\u048b\7\13\2"+ + "\2\u048b\u0496\3\2\2\2\u048c\u048d\7\62\2\2\u048d\u048e\7C\2\2\u048e\u0496"+ + "\7\13\2\2\u048f\u0493\5\u00c0a\2\u0490\u0494\5\u00c8e\2\u0491\u0492\7"+ + "-\2\2\u0492\u0494\5\u00caf\2\u0493\u0490\3\2\2\2\u0493\u0491\3\2\2\2\u0494"+ + "\u0496\3\2\2\2\u0495\u0480\3\2\2\2\u0495\u0484\3\2\2\2\u0495\u0485\3\2"+ + "\2\2\u0495\u0486\3\2\2\2\u0495\u0487\3\2\2\2\u0495\u0488\3\2\2\2\u0495"+ + "\u048c\3\2\2\2\u0495\u048f\3\2\2\2\u0496\u00b3\3\2\2\2\u0497\u0498\5\u00c0"+ + "a\2\u0498\u0499\5\u00b6\\\2\u0499\u049a\5\u00bc_\2\u049a\u04a1\3\2\2\2"+ + "\u049b\u049e\5\u00b6\\\2\u049c\u049f\5\u00ba^\2\u049d\u049f\5\u00bc_\2"+ + "\u049e\u049c\3\2\2\2\u049e\u049d\3\2\2\2\u049f\u04a1\3\2\2\2\u04a0\u0497"+ + "\3\2\2\2\u04a0\u049b\3\2\2\2\u04a1\u00b5\3\2\2\2\u04a2\u04a4\7f\2\2\u04a3"+ + "\u04a5\5\u00c2b\2\u04a4\u04a3\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04ad"+ + "\3\2\2\2\u04a6\u04a7\7C\2\2\u04a7\u04a9\7f\2\2\u04a8\u04aa\5\u00c2b\2"+ + "\u04a9\u04a8\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ac\3\2\2\2\u04ab\u04a6"+ + "\3\2\2\2\u04ac\u04af\3\2\2\2\u04ad\u04ab\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae"+ + "\u04b2\3\2\2\2\u04af\u04ad\3\2\2\2\u04b0\u04b2\5R*\2\u04b1\u04a2\3\2\2"+ + "\2\u04b1\u04b0\3\2\2\2\u04b2\u00b7\3\2\2\2\u04b3\u04b5\7f\2\2\u04b4\u04b6"+ + "\5\u00c4c\2\u04b5\u04b4\3\2\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b7\3\2\2"+ + "\2\u04b7\u04b8\5\u00bc_\2\u04b8\u00b9\3\2\2\2\u04b9\u04d5\7?\2\2\u04ba"+ + "\u04bf\7@\2\2\u04bb\u04bc\7?\2\2\u04bc\u04be\7@\2\2\u04bd\u04bb\3\2\2"+ + "\2\u04be\u04c1\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c2"+ + "\3\2\2\2\u04c1\u04bf\3\2\2\2\u04c2\u04d6\5J&\2\u04c3\u04c4\5\u00b0Y\2"+ + "\u04c4\u04cb\7@\2\2\u04c5\u04c6\7?\2\2\u04c6\u04c7\5\u00b0Y\2\u04c7\u04c8"+ + "\7@\2\2\u04c8\u04ca\3\2\2\2\u04c9\u04c5\3\2\2\2\u04ca\u04cd\3\2\2\2\u04cb"+ + "\u04c9\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04d2\3\2\2\2\u04cd\u04cb\3\2"+ + "\2\2\u04ce\u04cf\7?\2\2\u04cf\u04d1\7@\2\2\u04d0\u04ce\3\2\2\2\u04d1\u04d4"+ + "\3\2\2\2\u04d2\u04d0\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3\u04d6\3\2\2\2\u04d4"+ + "\u04d2\3\2\2\2\u04d5\u04ba\3\2\2\2\u04d5\u04c3\3\2\2\2\u04d6\u00bb\3\2"+ + "\2\2\u04d7\u04d9\5\u00caf\2\u04d8\u04da\5$\23\2\u04d9\u04d8\3\2\2\2\u04d9"+ + "\u04da\3\2\2\2\u04da\u00bd\3\2\2\2\u04db\u04dc\5\u00c0a\2\u04dc\u04dd"+ + "\5\u00c8e\2\u04dd\u00bf\3\2\2\2\u04de\u04df\7F\2\2\u04df\u04e0\5\"\22"+ + "\2\u04e0\u04e1\7E\2\2\u04e1\u00c1\3\2\2\2\u04e2\u04e3\7F\2\2\u04e3\u04e6"+ + "\7E\2\2\u04e4\u04e6\5T+\2\u04e5\u04e2\3\2\2\2\u04e5\u04e4\3\2\2\2\u04e6"+ + "\u00c3\3\2\2\2\u04e7\u04e8\7F\2\2\u04e8\u04eb\7E\2\2\u04e9\u04eb\5\u00c0"+ + "a\2\u04ea\u04e7\3\2\2\2\u04ea\u04e9\3\2\2\2\u04eb\u00c5\3\2\2\2\u04ec"+ + "\u04f3\5\u00caf\2\u04ed\u04ee\7C\2\2\u04ee\u04f0\7f\2\2\u04ef\u04f1\5"+ + "\u00caf\2\u04f0\u04ef\3\2\2\2\u04f0\u04f1\3\2\2\2\u04f1\u04f3\3\2\2\2"+ + "\u04f2\u04ec\3\2\2\2\u04f2\u04ed\3\2\2\2\u04f3\u00c7\3\2\2\2\u04f4\u04f5"+ + "\7*\2\2\u04f5\u04f9\5\u00c6d\2\u04f6\u04f7\7f\2\2\u04f7\u04f9\5\u00ca"+ + "f\2\u04f8\u04f4\3\2\2\2\u04f8\u04f6\3\2\2\2\u04f9\u00c9\3\2\2\2\u04fa"+ + "\u04fc\7;\2\2\u04fb\u04fd\5\u00aaV\2\u04fc\u04fb\3\2\2\2\u04fc\u04fd\3"+ + "\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u04ff\7<\2\2\u04ff\u00cb\3\2\2\2\u0097"+ + "\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\u0461\u0473\u047b\u047d\u0493\u0495\u049e"+ + "\u04a0\u04a4\u04a9\u04ad\u04b1\u04b5\u04bf\u04cb\u04d2\u04d5\u04d9\u04e5"+ + "\u04ea\u04f0\u04f2\u04f8\u04fc"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/Java8Visitor.java b/src/de/dhbwstuttgart/antlr/Java8Visitor.java new file mode 100644 index 00000000..c5453625 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Java8Visitor.java @@ -0,0 +1,621 @@ +package de.dhbwstuttgart.antlr; + +// Generated from Java8.g4 by ANTLR 4.4 +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 Java8Parser}. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface Java8Visitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link Java8Parser#memberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberDeclaration(@NotNull Java8Parser.MemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#defaultValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDefaultValue(@NotNull Java8Parser.DefaultValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementDeclaration(@NotNull Java8Parser.AnnotationTypeElementDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#type}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitType(@NotNull Java8Parser.TypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeBody(@NotNull Java8Parser.AnnotationTypeBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#genericInterfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericInterfaceMethodDeclaration(@NotNull Java8Parser.GenericInterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBodyDeclaration(@NotNull Java8Parser.ClassBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#block}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(@NotNull Java8Parser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumBodyDeclarations}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBodyDeclarations(@NotNull Java8Parser.EnumBodyDeclarationsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forUpdate}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForUpdate(@NotNull Java8Parser.ForUpdateContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enhancedForControl}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForControl(@NotNull Java8Parser.EnhancedForControlContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationConstantRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationConstantRest(@NotNull Java8Parser.AnnotationConstantRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#explicitGenericInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitGenericInvocation(@NotNull Java8Parser.ExplicitGenericInvocationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#nonWildcardTypeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNonWildcardTypeArgumentsOrDiamond(@NotNull Java8Parser.NonWildcardTypeArgumentsOrDiamondContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expressionList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionList(@NotNull Java8Parser.ExpressionListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeElementRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementRest(@NotNull Java8Parser.AnnotationTypeElementRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceType(@NotNull Java8Parser.ClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeBound(@NotNull Java8Parser.TypeBoundContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclaratorId}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorId(@NotNull Java8Parser.VariableDeclaratorIdContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimary(@NotNull Java8Parser.PrimaryContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classCreatorRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassCreatorRest(@NotNull Java8Parser.ClassCreatorRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBodyDeclaration(@NotNull Java8Parser.InterfaceBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(@NotNull Java8Parser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationName(@NotNull Java8Parser.AnnotationNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#finallyBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinallyBlock(@NotNull Java8Parser.FinallyBlockContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(@NotNull Java8Parser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#lastFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLastFormalParameter(@NotNull Java8Parser.LastFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorBody(@NotNull Java8Parser.ConstructorBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#literal}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(@NotNull Java8Parser.LiteralContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationMethodOrConstantRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationMethodOrConstantRest(@NotNull Java8Parser.AnnotationMethodOrConstantRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchClause(@NotNull Java8Parser.CatchClauseContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarator(@NotNull Java8Parser.VariableDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeList(@NotNull Java8Parser.TypeListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstants}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstants(@NotNull Java8Parser.EnumConstantsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBody(@NotNull Java8Parser.ClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#createdName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCreatedName(@NotNull Java8Parser.CreatedNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumDeclaration(@NotNull Java8Parser.EnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameter(@NotNull Java8Parser.FormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#parExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParExpression(@NotNull Java8Parser.ParExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotation(@NotNull Java8Parser.AnnotationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializer(@NotNull Java8Parser.VariableInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValueArrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueArrayInitializer(@NotNull Java8Parser.ElementValueArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#creator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCreator(@NotNull Java8Parser.CreatorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayCreatorRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayCreatorRest(@NotNull Java8Parser.ArrayCreatorRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#expression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(@NotNull Java8Parser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantExpression(@NotNull Java8Parser.ConstantExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#qualifiedNameList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiedNameList(@NotNull Java8Parser.QualifiedNameListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclaration(@NotNull Java8Parser.ConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forControl}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForControl(@NotNull Java8Parser.ForControlContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#superSuffix}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperSuffix(@NotNull Java8Parser.SuperSuffixContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableDeclarators}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarators(@NotNull Java8Parser.VariableDeclaratorsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#catchType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchType(@NotNull Java8Parser.CatchTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classOrInterfaceModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceModifier(@NotNull Java8Parser.ClassOrInterfaceModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstantName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstantName(@NotNull Java8Parser.EnumConstantNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#modifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitModifier(@NotNull Java8Parser.ModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#innerCreator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInnerCreator(@NotNull Java8Parser.InnerCreatorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#explicitGenericInvocationSuffix}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitGenericInvocationSuffix(@NotNull Java8Parser.ExplicitGenericInvocationSuffixContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#variableModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableModifier(@NotNull Java8Parser.VariableModifierContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePair}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePair(@NotNull Java8Parser.ElementValuePairContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayInitializer(@NotNull Java8Parser.ArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValue(@NotNull Java8Parser.ElementValueContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstDeclaration(@NotNull Java8Parser.ConstDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resource}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResource(@NotNull Java8Parser.ResourceContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#qualifiedName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiedName(@NotNull Java8Parser.QualifiedNameContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resourceSpecification}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceSpecification(@NotNull Java8Parser.ResourceSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterList(@NotNull Java8Parser.FormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationTypeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeDeclaration(@NotNull Java8Parser.AnnotationTypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#compilationUnit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompilationUnit(@NotNull Java8Parser.CompilationUnitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#annotationMethodRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationMethodRest(@NotNull Java8Parser.AnnotationMethodRestContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchBlockStatementGroup}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlockStatementGroup(@NotNull Java8Parser.SwitchBlockStatementGroupContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(@NotNull Java8Parser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBody(@NotNull Java8Parser.InterfaceBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclaration(@NotNull Java8Parser.MethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#methodBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodBody(@NotNull Java8Parser.MethodBodyContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgument(@NotNull Java8Parser.TypeArgumentContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeDeclaration(@NotNull Java8Parser.TypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#genericConstructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericConstructorDeclaration(@NotNull Java8Parser.GenericConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#classDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(@NotNull Java8Parser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#enumConstant}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstant(@NotNull Java8Parser.EnumConstantContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(@NotNull Java8Parser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#importDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportDeclaration(@NotNull Java8Parser.ImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#primitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimitiveType(@NotNull Java8Parser.PrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceDeclaration(@NotNull Java8Parser.InterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclarationStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclarationStatement(@NotNull Java8Parser.LocalVariableDeclarationStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#blockStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatement(@NotNull Java8Parser.BlockStatementContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#fieldDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldDeclaration(@NotNull Java8Parser.FieldDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#constantDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantDeclarator(@NotNull Java8Parser.ConstantDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#resources}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResources(@NotNull Java8Parser.ResourcesContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#statementExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementExpression(@NotNull Java8Parser.StatementExpressionContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodDeclaration(@NotNull Java8Parser.InterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#packageDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageDeclaration(@NotNull Java8Parser.PackageDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#elementValuePairs}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePairs(@NotNull Java8Parser.ElementValuePairsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#localVariableDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclaration(@NotNull Java8Parser.LocalVariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#nonWildcardTypeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNonWildcardTypeArguments(@NotNull Java8Parser.NonWildcardTypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#interfaceMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMemberDeclaration(@NotNull Java8Parser.InterfaceMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#switchLabel}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabel(@NotNull Java8Parser.SwitchLabelContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#forInit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInit(@NotNull Java8Parser.ForInitContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#formalParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameters(@NotNull Java8Parser.FormalParametersContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#arguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArguments(@NotNull Java8Parser.ArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#genericMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericMethodDeclaration(@NotNull Java8Parser.GenericMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link Java8Parser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentsOrDiamond(@NotNull Java8Parser.TypeArgumentsOrDiamondContext ctx); +} \ No newline at end of file diff --git a/src/de/dhbwstuttgart/antlr/Test.java b/src/de/dhbwstuttgart/antlr/Test.java new file mode 100644 index 00000000..71295440 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/Test.java @@ -0,0 +1,52 @@ +package de.dhbwstuttgart.antlr; + +import java.util.Vector; + +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.tree.*; + +import de.dhbwstuttgart.antlr.Java8Parser.ClassDeclarationContext; +import de.dhbwstuttgart.antlr.Java8Parser.CompilationUnitContext; +import de.dhbwstuttgart.antlr.Java8Parser.TypeDeclarationContext; +import de.dhbwstuttgart.syntaxtree.SourceFile; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; +import de.dhbwstuttgart.syntaxtree.Class; + +public class Test { + public static void main(String[] args) throws Exception { + ANTLRInputStream input = new ANTLRInputStream(System.in); + Java8Lexer lexer = new Java8Lexer(input); + CommonTokenStream tokens = new CommonTokenStream(lexer); + Java8Parser parser = new Java8Parser(tokens); + ParseTree tree = parser.compilationUnit(); // begin parsing at init rule + System.out.println(tree.toStringTree(parser)); // print LISP-style tree + // Create a generic parse tree walker that can trigger callbacks + ParseTreeWalker walker = new ParseTreeWalker(); + } +} + +class EvalVisitor extends Java8BaseVisitor { + + @Override + public SyntaxTreeNode visitCompilationUnit(CompilationUnitContext ctx) { + Vector classDefinitions = new Vector<>(); + for(TypeDeclarationContext tDecl : ctx.typeDeclaration()){ + Class cl = (Class) visit(tDecl); + classDefinitions.add(cl); + } + + return new SourceFile(); + } + + @Override + public Class visitTypeDeclaration(TypeDeclarationContext ctx) { + Class ret = (Class) visit(ctx.classDeclaration()); + return ret; + } + + @Override + public Class visitClassDeclaration(ClassDeclarationContext ctx) { + return null; + } + +} diff --git a/src/de/dhbwstuttgart/antlr/makefile b/src/de/dhbwstuttgart/antlr/makefile new file mode 100644 index 00000000..0adefcb8 --- /dev/null +++ b/src/de/dhbwstuttgart/antlr/makefile @@ -0,0 +1,3 @@ +all: + java -jar ./antlr-4.4-complete.jar -no-listener -visitor Java8.g4 + diff --git a/src/de/dhbwstuttgart/core/AClassOrInterface.java b/src/de/dhbwstuttgart/core/AClassOrInterface.java index 93323e79..16a6f16f 100755 --- a/src/de/dhbwstuttgart/core/AClassOrInterface.java +++ b/src/de/dhbwstuttgart/core/AClassOrInterface.java @@ -14,8 +14,10 @@ import org.apache.log4j.Logger; + import de.dhbwstuttgart.myexception.JVMCodeException; import de.dhbwstuttgart.parser.JavaClassName; +import de.dhbwstuttgart.syntaxtree.Interface; import de.dhbwstuttgart.syntaxtree.misc.UsedId; import de.dhbwstuttgart.syntaxtree.modifier.Modifiers; @@ -35,8 +37,8 @@ public interface AClassOrInterface { public JavaClassName getName(); - public Vector getSuperInterfaces(); - public void setSuperInterfaces(Vector vector); + public Vector getSuperInterfaces(); + public void setSuperInterfaces(Vector vector); /* // ino.attribute.inferencelog.21189.decldescription type=javadoc diff --git a/src/de/dhbwstuttgart/syntaxtree/Class.java b/src/de/dhbwstuttgart/syntaxtree/Class.java index 275666dd..60163eff 100755 --- a/src/de/dhbwstuttgart/syntaxtree/Class.java +++ b/src/de/dhbwstuttgart/syntaxtree/Class.java @@ -51,7 +51,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit protected Modifiers modifiers; protected String name; - private Vector superif = new Vector(); + private Vector superif = new Vector(); public UsedId getPackageName() { @@ -88,11 +88,13 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit } return ret; } - public Vector getSuperInterfaces() + + public Vector getSuperInterfaces() { return superif; } - public void setSuperInterfaces(Vector superif) + + public void setSuperInterfaces(Vector superif) { this.superif = superif; } @@ -142,6 +144,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit private Vector fielddecl = new Vector(); private GenericDeclarationList genericClassParameters; private int offset; + private Class superClass; // ino.method.Class.23041.definition @@ -154,9 +157,16 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit superclassid=null; } this.offset = offset; + if(!name.equals("Object"))//Alle Klassen außer Object erben von Object: + this.superClass = new Class("Object", -1); } // ino.end + public Class(String name, Class superClass, int offset){ + this(name,offset); + this.superClass = superClass; + } + // ino.method.Class.23044.definition public Class(String name, Modifiers mod, int offset) // ino.end @@ -179,7 +189,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit // ino.end // ino.method.Class.23047.definition public Class(String name, Modifiers mod, ClassBody cb, Vector ct, Vector usedIdsToCheck, - UsedId superclass, Vector superif, Vector paralist, int offset) + UsedId superclass, Vector superif, Vector paralist, int offset) // ino.end // ino.method.Class.23047.body { @@ -1072,7 +1082,7 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit parameter.add(((GenericTypeVar)param).getTypePlaceHolder());//(TypePlaceholder.fresh()); //Hier ist kein ReplacementListener notwendig. Der Typ soll nie eingesetzt werden. Der TPH wird nur gebraucht, damit das Unifizieren funktioniert. } */ - return new RefType(this.getName().toString(), this.get_ParaList(), 0); + return new RefType(this.getName().toString(), this.get_ParaList(),this, 0); } @@ -1134,10 +1144,11 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit if(t instanceof GenericTypeVar)this.genericClassParameters.add((GenericTypeVar)t); else this.genericClassParameters.add(new GenericTypeVar(t.get_Name(),this,-1)); } + /* for(GenericTypeVar gtv : this.getGenericParameter()){ gtv.setParentClass(this);; } - + */ //TODO: Umwandlung zu RefTypes funktioniert noch nicht richtig. (siehe LambdaTest2) //Als RefType geparste Generische Variablen umwandeln: this.wandleRefTypeAttributes2GenericAttributes(); @@ -1153,8 +1164,8 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit Vector ret = new Vector(); for(Field f : this.getFields()){ ret.add(f); - ret.addAll(this.getGenericParameter()); } + ret.addAll(this.getGenericParameter()); return ret; } @@ -1207,6 +1218,12 @@ public class Class extends SyntaxTreeNode implements AClassOrInterface, IItemWit } } - + /** + * Die Super Klasse dieser Klasse. + * @return null für Klasse Object + */ + public Class getSuperClass(){ + return this.superClass; + } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/Field.java b/src/de/dhbwstuttgart/syntaxtree/Field.java index baefaddd..51766f7a 100644 --- a/src/de/dhbwstuttgart/syntaxtree/Field.java +++ b/src/de/dhbwstuttgart/syntaxtree/Field.java @@ -158,6 +158,7 @@ public abstract class Field extends SyntaxTreeNode implements TypeInsertable, Ty public Vector getChildren() { Vector ret = new Vector<>(); if(this.getType()!=null)ret.add(this.getType()); + ret.addAll(this.getGenericParameter()); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java index ebf61dd9..3fb4cf61 100644 --- a/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java +++ b/src/de/dhbwstuttgart/syntaxtree/FieldDeclaration.java @@ -101,7 +101,6 @@ public class FieldDeclaration extends Field{ public void parserPostProcessing(SyntaxTreeNode parent){ super.parserPostProcessing(parent); if(this.getType() == null)this.setType(TypePlaceholder.fresh(this)); - } @Override diff --git a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java index 69ce984a..241e3cd5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/SourceFile.java +++ b/src/de/dhbwstuttgart/syntaxtree/SourceFile.java @@ -248,7 +248,7 @@ public class SourceFile */ // ino.end // ino.method.createPairFromClassAndSuperclass.21400.definition - private Pair createPairFromClassAndSuperclass(JavaClassName className, JavaClassName superclassName, Vector classParaOrg, Vector superclassParaOrg) + private Pair createPairFromClassAndSuperclass(Class baseClass, Class superclass, Vector classParaOrg, Vector superclassParaOrg) // ino.end // ino.method.createPairFromClassAndSuperclass.21400.body { @@ -259,10 +259,13 @@ public class SourceFile if(superclassParaOrg!=null && superclassParaOrg.size()==0){ superclassParaOrg=null; } + /* Pair P = new Pair( new RefType( className.toString(), classParaOrg,-1), new RefType( superclassName.toString(), superclassParaOrg,-1) ); + */ + Pair P = new Pair(baseClass.getType(), superclass.getType()); //PL 04-12-29 freshe Variablen ANFANG RefType r1 = (RefType)P.getTA1Copy(); RefType r2 = (RefType)P.getTA2Copy(); @@ -305,17 +308,16 @@ public class SourceFile { Class tempKlasse = KlassenVektor.elementAt(i); inferencelog.debug("Verarbeite "+tempKlasse.getName()); - + //TODO: SuperKlasse erstellen, dies sollte am besten beim Konstruktoraufruf von Class geschehen. Diese kann dann mit getSuperClass abgefragt werden. if( tempKlasse.superclassid != null ) { // Klasse hat Superklasse - Pair P=createPairFromClassAndSuperclass(tempKlasse.getName(),tempKlasse.get_Superclass_Name(),tempKlasse.get_ParaList(),tempKlasse.superclassid.get_ParaList()); + Pair P=createPairFromClassAndSuperclass(tempKlasse,tempKlasse.getSuperClass(),tempKlasse.get_ParaList(),tempKlasse.superclassid.get_ParaList()); vFC.add( P ); } if(tempKlasse.getSuperInterfaces()!=null){ - Iterator interfaceIterator=tempKlasse.getSuperInterfaces().iterator(); + Iterator interfaceIterator=tempKlasse.getSuperInterfaces().iterator(); while(interfaceIterator.hasNext()){ - UsedId intf=interfaceIterator.next(); - JavaClassName interfaceName=intf.getQualifiedName(); - Pair P=createPairFromClassAndSuperclass(tempKlasse.getName(),interfaceName,tempKlasse.get_ParaList(),intf.get_ParaList()); + Interface intf=interfaceIterator.next(); + Pair P=createPairFromClassAndSuperclass(tempKlasse,intf,tempKlasse.get_ParaList(),intf.get_ParaList()); vFC.add( P ); } @@ -324,11 +326,10 @@ public class SourceFile for(int i=0; i interfaceIterator=intf.getSuperInterfaces().iterator(); + Iterator interfaceIterator=intf.getSuperInterfaces().iterator(); while(interfaceIterator.hasNext()){ - UsedId superintf=interfaceIterator.next(); - JavaClassName superinterfaceName=superintf.getQualifiedName(); - Pair P=createPairFromClassAndSuperclass(intf.getName(),superinterfaceName,intf.getParaList(), superintf.get_ParaList()); + Interface superintf=interfaceIterator.next(); + Pair P=createPairFromClassAndSuperclass(intf,superintf,intf.getParaList(), superintf.get_ParaList()); vFC.add( P ); } @@ -1168,7 +1169,7 @@ public class SourceFile for(int j=0;j getOperatorTypes() { Hashtable types = new Hashtable(); - types.put(new RefType("java.lang.Integer",-1),new RefType("java.lang.Integer",-1)); - types.put(new RefType("java.lang.Double",-1),new RefType("java.lang.Double",-1)); - types.put(new RefType("java.lang.Float",-1), new RefType("java.lang.Float",-1)); - types.put(new RefType("java.lang.Long",-1), new RefType("java.lang.Long",-1)); - types.put(new RefType("java.lang.String",-1), new RefType("java.lang.String",-1)); + types.put(new RefType("java.lang.Integer",this,-1),new RefType("java.lang.Integer",this,-1)); + types.put(new RefType("java.lang.Double",this,-1),new RefType("java.lang.Double",this,-1)); + types.put(new RefType("java.lang.Float",this,-1), new RefType("java.lang.Float",this,-1)); + types.put(new RefType("java.lang.Long",this,-1), new RefType("java.lang.Long",this,-1)); + types.put(new RefType("java.lang.String",this,-1), new RefType("java.lang.String",this,-1)); return types; } @@ -62,11 +62,11 @@ public abstract class AddOp extends Operator @Override public HashMap getReturnTypes(TypeAssumptions ass) { HashMap ret = new HashMap(); - ret.put(ass.getTypeFor(new RefType("java.lang.Integer",-1), this), ass.getTypeFor(new RefType("java.lang.Integer",-1),this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Double",-1), this), ass.getTypeFor(new RefType("java.lang.Double",-1),this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Float",-1), this), ass.getTypeFor(new RefType("java.lang.Float",-1),this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Long",-1), this), ass.getTypeFor(new RefType("java.lang.Long",-1),this)); - ret.put(ass.getTypeFor(new RefType("java.lang.String",-1),this), ass.getTypeFor(new RefType("java.lang.String",-1),this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Integer",this,-1), this), ass.getTypeFor(new RefType("java.lang.Integer",this,-1),this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Double",this,-1), this), ass.getTypeFor(new RefType("java.lang.Double",this,-1),this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Float",this,-1), this), ass.getTypeFor(new RefType("java.lang.Float",this,-1),this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Long",this,-1), this), ass.getTypeFor(new RefType("java.lang.Long",this,-1),this)); + ret.put(ass.getTypeFor(new RefType("java.lang.String",this,-1),this), ass.getTypeFor(new RefType("java.lang.String",this,-1),this)); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java index 511cc9b7..ce80cd9b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java +++ b/src/de/dhbwstuttgart/syntaxtree/operator/LogOp.java @@ -224,7 +224,7 @@ public abstract class LogOp extends Operator protected Hashtable getOperatorTypes() { Hashtable types = new Hashtable(); - types.put(new RefType("java.lang.Boolean",-1), new RefType("java.lang.Boolean",-1)); + types.put(new RefType("java.lang.Boolean",this,-1), new RefType("java.lang.Boolean",this,-1)); return types; } @@ -232,7 +232,7 @@ public abstract class LogOp extends Operator @Override public HashMap getReturnTypes(TypeAssumptions ass) { HashMap ret = new HashMap<>(); - ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",-1), this), ass.getTypeFor(new RefType("java.lang.Boolean",-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this), ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this)); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java index f28819ad..e3b37f08 100755 --- a/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java +++ b/src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java @@ -43,10 +43,10 @@ public abstract class MulOp extends Operator @Override public HashMap getReturnTypes(TypeAssumptions ass) { HashMap ret = new HashMap<>(); - ret.put(ass.getTypeFor(new RefType("java.lang.Integer",-1), this), ass.getTypeFor(new RefType("java.lang.Integer",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Double",-1), this), ass.getTypeFor(new RefType("java.lang.Double",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Float",-1), this), ass.getTypeFor(new RefType("java.lang.Float",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Long",-1), this), ass.getTypeFor(new RefType("java.lang.Long",-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Integer",this,-1), this), ass.getTypeFor(new RefType("java.lang.Integer",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Double",this,-1), this), ass.getTypeFor(new RefType("java.lang.Double",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Float",this,-1), this), ass.getTypeFor(new RefType("java.lang.Float",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Long",this,-1), this), ass.getTypeFor(new RefType("java.lang.Long",this,-1), this)); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java b/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java index 0c75a359..c0718774 100755 --- a/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java +++ b/src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java @@ -43,10 +43,10 @@ public abstract class RelOp extends Operator protected Hashtable getOperatorTypes() { Hashtable types = new Hashtable(); - types.put(new RefType("java.lang.Integer",-1), new RefType("java.lang.Boolean",-1)); - types.put(new RefType("java.lang.Double",-1), new RefType("java.lang.Boolean",-1)); - types.put(new RefType("java.lang.Float",-1), new RefType("java.lang.Boolean",-1)); - types.put(new RefType("java.lang.Long",-1), new RefType("java.lang.Boolean",-1)); + types.put(new RefType("java.lang.Integer",this,-1), new RefType("java.lang.Boolean",this,-1)); + types.put(new RefType("java.lang.Double",this,-1), new RefType("java.lang.Boolean",this,-1)); + types.put(new RefType("java.lang.Float",this,-1), new RefType("java.lang.Boolean",this,-1)); + types.put(new RefType("java.lang.Long",this,-1), new RefType("java.lang.Boolean",this,-1)); return types; } @@ -54,10 +54,10 @@ public abstract class RelOp extends Operator @Override public HashMap getReturnTypes(TypeAssumptions ass) { HashMap ret = new HashMap<>(); - ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",-1), this), ass.getTypeFor(new RefType("java.lang.Integer",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",-1), this), ass.getTypeFor(new RefType("java.lang.Double",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",-1), this), ass.getTypeFor(new RefType("java.lang.Float",-1), this)); - ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",-1), this), ass.getTypeFor(new RefType("java.lang.Long",-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this), ass.getTypeFor(new RefType("java.lang.Integer",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this), ass.getTypeFor(new RefType("java.lang.Double",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this), ass.getTypeFor(new RefType("java.lang.Float",this,-1), this)); + ret.put(ass.getTypeFor(new RefType("java.lang.Boolean",this,-1), this), ass.getTypeFor(new RefType("java.lang.Long",this,-1), this)); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java b/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java index e10cded5..04bffdb1 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Assign.java @@ -24,7 +24,6 @@ import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.Pair; import de.dhbwstuttgart.typeinference.ResultSet; @@ -203,7 +202,7 @@ public class Assign extends Expr @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){ ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen - this.setType(new Void(0)); //Typ des Statments auf Void setzen. + this.setType(new Void(this,0)); //Typ des Statments auf Void setzen. return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java index 5ae6bba8..87a16aa6 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Block.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Block.java @@ -23,7 +23,6 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintType; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.SingleConstraint; @@ -169,7 +168,7 @@ public class Block extends Statement @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); - if(statements.size()==0)this.setType(new Void(0)); + if(statements.size()==0)this.setType(new Void(this,0)); /* this.setTypeVariable(TypePlaceholder.fresh(this)); */ for(Statement stmt : statements){ typinferenceLog.debug("Prozessing statement: "+stmt); @@ -199,7 +198,7 @@ public class Block extends Statement } } }else{ - this.setType(new Void(0)); + this.setType(new Void(this,0)); } return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java index 39c4b6fa..7516e1f2 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/BoolLiteral.java @@ -47,7 +47,7 @@ public class BoolLiteral extends Literal super(-1,-1); // #JB# 20.04.2005 // ########################################################### - this.setType(new BooleanType()); + this.setType(new BooleanType(this)); //this.setType(new Type("boolean")); // ########################################################### } @@ -126,7 +126,7 @@ public class BoolLiteral extends Literal @Override public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { - this.type = assumptions.getTypeFor(new RefType("java.lang.Boolean",-1), this).getType(); + this.type = assumptions.getTypeFor(new RefType("java.lang.Boolean",this,-1), this).getType(); return new ConstraintsSet(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java index b8163af1..a8b3e8f6 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/CharLiteral.java @@ -46,7 +46,7 @@ public class CharLiteral extends Literal super(-1,-1); // #JB# 20.04.2005 // ########################################################### - this.setType(new CharacterType()); + this.setType(new CharacterType(this)); //this.setType(new Type("char")); // ########################################################### } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java index 97fc7406..aedce593 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/DoubleLiteral.java @@ -52,7 +52,7 @@ public class DoubleLiteral extends Literal { super(-1,-1); - this.setType(new DoubleType()); + this.setType(new DoubleType(this)); } // ino.end @@ -164,7 +164,7 @@ public class DoubleLiteral extends Literal @Override public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { - this.setType(assumptions.getTypeFor(new RefType("Double",this.getOffset()), this).getType()); + this.setType(assumptions.getTypeFor(new RefType("Double",this,this.getOffset()), this).getType()); return new ConstraintsSet(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java index 80bd8526..b1e1bb2b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/FloatLiteral.java @@ -45,7 +45,7 @@ public class FloatLiteral extends Literal { super(-1,-1); - this.setType(new FloatType()); + this.setType(new FloatType(this)); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java index fe0a1436..e57cd48f 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/IfStmt.java @@ -28,7 +28,6 @@ import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.Pair; import de.dhbwstuttgart.typeinference.ResultSet; @@ -259,10 +258,10 @@ public class IfStmt extends Statement ret.add(this.else_block.TYPEStmt(assumptions)); if(!(else_block.getType() instanceof Void))ret.add(new SingleConstraint(else_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this))); } - ret.add(new SingleConstraint(expr.getType().TYPE(assumptions, this),assumptions.getTypeFor(new RefType("Boolean",0), this))); //(expressionDesIfStmt)<.boolean + ret.add(new SingleConstraint(expr.getType().TYPE(assumptions, this),assumptions.getTypeFor(new RefType("Boolean",this,0), this))); //(expressionDesIfStmt)<.boolean if(!(then_block.getType() instanceof Void))ret.add(new SingleConstraint(then_block.getType().TYPE(assumptions, this),this.getType().TYPE(assumptions, this))); if(then_block.getType() instanceof Void && - (else_block == null || else_block.getType() instanceof Void))this.setType(new Void(this.getOffset())); + (else_block == null || else_block.getType() instanceof Void))this.setType(new Void(this,this.getOffset())); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java index c78108ba..28fa843b 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/InstVar.java @@ -22,7 +22,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.OderConstraint; import de.dhbwstuttgart.typeinference.Pair; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java b/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java index 2178ba46..79276d89 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/InstanceOf.java @@ -56,7 +56,7 @@ public class InstanceOf extends BinaryExpr super(offset,variableLength); // #JB# 20.04.2005 // ########################################################### - this.setType(new BooleanType()); + this.setType(new BooleanType(this)); //this.setType(new Type("boolean")); // ########################################################### } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java index c06c6d67..212cc0eb 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/IntLiteral.java @@ -48,7 +48,7 @@ public class IntLiteral extends Literal super(-1,-1); // #JB# 20.04.2005 // ########################################################### - this.setType(new IntegerType()); + this.setType(new IntegerType(this)); //this.setType(new Type("int")); // ########################################################### } @@ -161,7 +161,7 @@ public class IntLiteral extends Literal public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); //this.setType(new IntegerType()); - this.set_Type(assumptions.getTypeFor(new RefType("java.lang.Integer",-1), this).getType()); + this.set_Type(assumptions.getTypeFor(new RefType("java.lang.Integer",this,-1), this).getType()); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java b/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java index b65fad8e..f20a6161 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LambdaExpression.java @@ -20,7 +20,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.FunN; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java index 4f03ddae..1fb623b3 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LocalOrFieldVar.java @@ -22,7 +22,6 @@ import de.dhbwstuttgart.syntaxtree.type.RefType; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.SingleConstraint; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java b/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java index 0f4ff5b1..3da735a1 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LocalVarDecl.java @@ -24,7 +24,6 @@ import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.SingleConstraint; @@ -385,7 +384,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable assumptions.addAssumption(new LocalVarAssumption(this, this.getType())); //Bevor der Typ auf Void gesetzt wird. ret.add(new SingleConstraint(this.getType().TYPE(assumptions, this), this.getType().TYPE(assumptions, this))); //assumptions.remove(null); // falls Variable mit diesem Namen bereits vorhanden. - this.setReturnType(new Void(0)); //Return typ einer Variablendeklaration ist Void + this.setReturnType(new Void(this,0)); //Return typ einer Variablendeklaration ist Void return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java index ed134118..b4e0da4e 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/LongLiteral.java @@ -51,7 +51,7 @@ public class LongLiteral extends Literal { super(-1,-1); - this.setType(new LongType()); + this.setType(new LongType(this)); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java index ff1f891e..a2c418d0 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java @@ -209,7 +209,7 @@ public class MethodCall extends Expr @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){ ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen - this.setType(new Void(0)); //Typ des Statments auf Void setzen, da als alleinstehendes Statement + this.setType(new Void(this,0)); //Typ des Statments auf Void setzen, da als alleinstehendes Statement return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java b/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java index 4269bc31..8270ab74 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/NewClass.java @@ -25,7 +25,6 @@ import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.syntaxtree.type.Void; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.FunN; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.Overloading; @@ -108,7 +107,7 @@ public class NewClass extends Expr parserlog.debug("Vergleiche "+usedid+" mit "+next); if(usedid.equals(next)) { - this.set_Type(new Type(next,getOffset())); + this.set_Type(new Type(next,this,getOffset())); break; } else next = null; @@ -225,7 +224,7 @@ public class NewClass extends Expr // ret.add(arg.TYPEExpr(assumptions)); //} - this.setType(assumptions.getTypeFor(new RefType(this.get_Name(),0), this).getType()); + this.setType(assumptions.getTypeFor(new RefType(this.get_Name(),this,0), this).getType()); /* @@ -249,7 +248,7 @@ public class NewClass extends Expr @Override public ConstraintsSet TYPEStmt(TypeAssumptions assumptions){ ConstraintsSet ret = this.TYPEExpr(assumptions); //TypeExpr aufrufen - this.setType(new Void(0)); //Typ des Statments auf Void setzen. + this.setType(new Void(this,0)); //Typ des Statments auf Void setzen. return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java index f08cae56..0b7a2a55 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/NotExpr.java @@ -145,7 +145,7 @@ public class NotExpr extends UnaryExpr public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); OderConstraint constraint = new OderConstraint(); - constraint.addConstraint(this.getType().TYPE(assumptions, this), assumptions.getTypeFor(new RefType("Boolean",-1),this)); + constraint.addConstraint(this.getType().TYPE(assumptions, this), assumptions.getTypeFor(new RefType("Boolean",this,-1),this)); ret.add(constraint); return ret; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Null.java b/src/de/dhbwstuttgart/syntaxtree/statement/Null.java index 53e73917..66bc356c 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Null.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Null.java @@ -42,7 +42,7 @@ public class Null extends Literal // ino.method.Null.25926.body { super(-1,-1); - this.setType(new Type("__NULL__",getOffset())); + this.setType(new Type("__NULL__",this,getOffset())); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Return.java b/src/de/dhbwstuttgart/syntaxtree/statement/Return.java index 9e606d6a..407133fd 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Return.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Return.java @@ -19,7 +19,6 @@ import de.dhbwstuttgart.syntaxtree.type.GenericTypeVar; import de.dhbwstuttgart.syntaxtree.type.Type; import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder; import de.dhbwstuttgart.typeinference.ConstraintsSet; -import de.dhbwstuttgart.typeinference.FreshTypeVariable; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import de.dhbwstuttgart.typeinference.SingleConstraint; diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java b/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java index c93de1a9..b4b9b8ae 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/Statement.java @@ -128,7 +128,7 @@ public abstract class Statement extends SyntaxTreeNode implements IItemWithOffse } public Type getReturnType(){ - return new de.dhbwstuttgart.syntaxtree.type.Void(-1); + return new de.dhbwstuttgart.syntaxtree.type.Void(this,-1); } } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java b/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java index 94875585..56fbe6ac 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/StringLiteral.java @@ -49,7 +49,7 @@ public class StringLiteral extends Literal super(-1,-1); // #JB# 20.04.2005 // ########################################################### - this.setType(new RefType("java.lang.String",getOffset())); + this.setType(new RefType("java.lang.String",this,getOffset())); //this.setType(new Type("String")); // ########################################################### } @@ -121,7 +121,7 @@ public class StringLiteral extends Literal @Override public ConstraintsSet TYPEExpr(TypeAssumptions assumptions) { - this.set_Type(assumptions.getTypeFor(new RefType("String",0), this).getType()); + this.set_Type(assumptions.getTypeFor(new RefType("String",this,0), this).getType()); return new ConstraintsSet(); } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.java b/src/de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.java index 9b73b842..19a2ff5d 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/UnaryExpr.java @@ -40,9 +40,9 @@ public abstract class UnaryExpr extends Expr private Vector getNumericTypes(){ Vector ret = new Vector<>(); - ret.add(new RefType("Integer",-1)); - ret.add(new RefType("Long",-1)); - ret.add(new RefType("Double",-1)); + ret.add(new RefType("Integer",this,-1)); + ret.add(new RefType("Long",this,-1)); + ret.add(new RefType("Double",this,-1)); return ret ; } diff --git a/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java b/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java index 4a4bf895..9cef4194 100755 --- a/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java +++ b/src/de/dhbwstuttgart/syntaxtree/statement/WhileStmt.java @@ -165,7 +165,7 @@ public class WhileStmt extends Statement public ConstraintsSet TYPEStmt(TypeAssumptions assumptions) { ConstraintsSet ret = new ConstraintsSet(); ret.add(expr.TYPEExpr(assumptions)); - SingleConstraint exprMustBeBool = new SingleConstraint(expr.getType().TYPE(assumptions, this), assumptions.getTypeFor(new RefType("Boolean", 0), this)); // while(expr){}; expr <. boolean + SingleConstraint exprMustBeBool = new SingleConstraint(expr.getType().TYPE(assumptions, this), assumptions.getTypeFor(new RefType("Boolean",this, 0), this)); // while(expr){}; expr <. boolean ret.add(exprMustBeBool); ret.add(this.loop_block.TYPEStmt(assumptions)); this.setType(loop_block.getType()); diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BaseType.java b/src/de/dhbwstuttgart/syntaxtree/type/BaseType.java index 3730ca91..3c4899fc 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BaseType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BaseType.java @@ -21,20 +21,20 @@ public abstract class BaseType extends Type private boolean IsArray = false; // ino.method.BaseType.26439.definition - public BaseType(int offset) + public BaseType(SyntaxTreeNode parent, int offset) // ino.end // ino.method.BaseType.26439.body { - super(offset); + super(parent, offset); } // ino.end // ino.method.BaseType.26442.definition - public BaseType(String name,int offset) + public BaseType(String name,SyntaxTreeNode parent,int offset) // ino.end // ino.method.BaseType.26442.body { - super(name, offset); + super(name,parent, offset); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BooleanType.java b/src/de/dhbwstuttgart/syntaxtree/type/BooleanType.java index 2b8dce52..cd912907 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BooleanType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BooleanType.java @@ -1,6 +1,7 @@ // ino.module.BooleanType.8668.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class BooleanType extends BaseType // ino.class.BooleanType.26451.body { // ino.method.BooleanType.26455.definition - public BooleanType() + public BooleanType(SyntaxTreeNode parent) // ino.end // ino.method.BooleanType.26455.body { - super("boolean",-1); + super("boolean",parent, -1); } // ino.end @@ -51,7 +52,7 @@ public class BooleanType extends BaseType // ino.end // ino.method.clone.26461.body { - return new BooleanType(); + return new BooleanType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java index aad481a7..d75715df 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/BoundedGenericTypeVar.java @@ -7,6 +7,7 @@ package de.dhbwstuttgart.syntaxtree.type; import java.util.Vector; import de.dhbwstuttgart.syntaxtree.Class; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.ConstraintType; import de.dhbwstuttgart.typeinference.ConstraintsSet; import de.dhbwstuttgart.typeinference.SingleConstraint; @@ -55,7 +56,7 @@ public class BoundedGenericTypeVar extends GenericTypeVar */ // ino.method.BoundedGenericTypeVar.29409.definition - public BoundedGenericTypeVar(String s, Vector bounds, Class parentClass, int offset, int endOffset) + public BoundedGenericTypeVar(String s, Vector bounds, SyntaxTreeNode parentClass, int offset, int endOffset) // ino.end // ino.method.BoundedGenericTypeVar.29409.body { @@ -147,5 +148,12 @@ public class BoundedGenericTypeVar extends GenericTypeVar } // ino.end + @Override + public Vector getChildren() { + Vector ret = super.getChildren(); + ret.addAll(this.bounds); + return ret; + } + } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/CharacterType.java b/src/de/dhbwstuttgart/syntaxtree/type/CharacterType.java index 0b7d61be..7f36e038 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/CharacterType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/CharacterType.java @@ -1,6 +1,7 @@ // ino.module.CharacterType.8670.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class CharacterType extends BaseType // ino.class.CharacterType.26492.body { // ino.method.CharacterType.26496.definition - public CharacterType() + public CharacterType(SyntaxTreeNode parent) // ino.end // ino.method.CharacterType.26496.body { - super("char",-1); + super("char",parent,-1); } // ino.end @@ -51,7 +52,7 @@ public class CharacterType extends BaseType // ino.end // ino.method.clone.26502.body { - return new CharacterType(); + return new CharacterType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/DoubleType.java b/src/de/dhbwstuttgart/syntaxtree/type/DoubleType.java index 975afd92..83e2c803 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/DoubleType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/DoubleType.java @@ -1,6 +1,7 @@ // ino.module.IntegerType.8672.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class DoubleType extends BaseType // ino.class.IntegerType.26527.body { // ino.method.IntegerType.26531.definition - public DoubleType() + public DoubleType(SyntaxTreeNode parent) // ino.end // ino.method.IntegerType.26531.body { - super("double",-1); + super("double",parent,-1); } // ino.end @@ -51,7 +52,7 @@ public class DoubleType extends BaseType // ino.end // ino.method.clone.26537.body { - return new DoubleType(); + return new DoubleType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java index b409a8d6..ed154e20 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -22,7 +23,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer, */ public ExtendsWildcardType (int offset, Type extendsType) { - super(offset); + super(extendsType.getParent(), offset); this.extendsType = extendsType; } @@ -81,7 +82,7 @@ public class ExtendsWildcardType extends WildcardType implements ITypeContainer, */ public FreshExtendsWildcardType GetFreshWildcardType() { - return new FreshExtendsWildcardType(this.extendsType,-1); + return new FreshExtendsWildcardType(this.extendsType,this.getParent(),-1); } /** diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FloatType.java b/src/de/dhbwstuttgart/syntaxtree/type/FloatType.java index fa5e7a9c..32cfc5df 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FloatType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FloatType.java @@ -1,6 +1,7 @@ // ino.module.IntegerType.8672.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class FloatType extends BaseType // ino.class.IntegerType.26527.body { // ino.method.IntegerType.26531.definition - public FloatType() + public FloatType(SyntaxTreeNode parent) // ino.end // ino.method.IntegerType.26531.body { - super("float",-1); + super("float", parent,-1); } // ino.end @@ -51,7 +52,7 @@ public class FloatType extends BaseType // ino.end // ino.method.clone.26537.body { - return new FloatType(); + return new FloatType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FreshExtendsWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/FreshExtendsWildcardType.java index 2dec8d7b..eda214ec 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FreshExtendsWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FreshExtendsWildcardType.java @@ -1,5 +1,7 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; + public class FreshExtendsWildcardType extends FreshWildcardType implements IMatchable { private Type extendsBoundType; @@ -8,9 +10,9 @@ public class FreshExtendsWildcardType extends FreshWildcardType implements IMatc * Author: Arne Lüdtke
* Standard Konstruktor für eine FreshExtendsWildcard */ - public FreshExtendsWildcardType(Type extendsBound ,int offset) + public FreshExtendsWildcardType(Type extendsBound,SyntaxTreeNode parent ,int offset) { - super(offset); + super(parent,offset); this.extendsBoundType = extendsBound; } @@ -18,9 +20,9 @@ public class FreshExtendsWildcardType extends FreshWildcardType implements IMatc * Author: Arne Lüdtke
* Privater Konstruktor für clone */ - private FreshExtendsWildcardType(Type extendsBound ,int offset, String name) + private FreshExtendsWildcardType(Type extendsBound ,SyntaxTreeNode parent,int offset, String name) { - super(offset,name); + super(parent,offset,name); this.extendsBoundType = extendsBound; } @@ -44,7 +46,7 @@ public class FreshExtendsWildcardType extends FreshWildcardType implements IMatc */ public FreshExtendsWildcardType clone() { - return new FreshExtendsWildcardType(this.extendsBoundType.clone(),getOffset(),this.name.toString()); + return new FreshExtendsWildcardType(this.extendsBoundType.clone(),this.getParent(),getOffset(),this.name.toString()); } /** diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FreshSuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/FreshSuperWildcardType.java index f8086c29..411cd1a8 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FreshSuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FreshSuperWildcardType.java @@ -1,5 +1,7 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; + public class FreshSuperWildcardType extends FreshWildcardType implements IMatchable { private Type superBoundType; @@ -8,9 +10,9 @@ public class FreshSuperWildcardType extends FreshWildcardType implements IMatcha * Author: Arne Lüdtke
* Standard Konstruktor für eine FreshSuperWildcard */ - public FreshSuperWildcardType(Type superBound ,int offset) + public FreshSuperWildcardType(Type superBound ,SyntaxTreeNode parent, int offset) { - super(offset); + super(parent,offset); this.superBoundType = superBound; } @@ -18,9 +20,9 @@ public class FreshSuperWildcardType extends FreshWildcardType implements IMatcha * Author: Arne Lüdtke
* Privater Konstruktor für clone */ - private FreshSuperWildcardType(Type superBound,int offset, String name) + private FreshSuperWildcardType(Type superBound,SyntaxTreeNode parent,int offset, String name) { - super(offset,name); + super(parent,offset,name); this.superBoundType = superBound; } @@ -44,7 +46,7 @@ public class FreshSuperWildcardType extends FreshWildcardType implements IMatcha */ public FreshSuperWildcardType clone() { - return new FreshSuperWildcardType(this.superBoundType.clone(),getOffset(),this.name.toString()); + return new FreshSuperWildcardType(this.superBoundType.clone(),this.getParent(),getOffset(),this.name.toString()); } /** diff --git a/src/de/dhbwstuttgart/syntaxtree/type/FreshWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/FreshWildcardType.java index d3bd6f3f..364681db 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/FreshWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/FreshWildcardType.java @@ -3,6 +3,7 @@ package de.dhbwstuttgart.syntaxtree.type; import java.util.Vector; import de.dhbwstuttgart.parser.JavaClassName; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import sun.reflect.generics.reflectiveObjects.NotImplementedException; @@ -16,9 +17,9 @@ public class FreshWildcardType extends Type { * Author: Arne Lüdtke
* Standard Konstruktor für eine FreshWildcard */ - public FreshWildcardType(int offset) + public FreshWildcardType(SyntaxTreeNode parent, int offset) { - super(offset); + super(parent, offset); this.name = makeNewName(); } @@ -27,9 +28,9 @@ public class FreshWildcardType extends Type { * Protected Konstruktor für clone. * Protected, da vererbte Klassen ihn verwenden müssen. */ - protected FreshWildcardType(int offset, String name) + protected FreshWildcardType(SyntaxTreeNode parent, int offset, String name) { - super(offset); + super(parent, offset); this.name = new JavaClassName(name); } @@ -61,7 +62,7 @@ public class FreshWildcardType extends Type { */ public FreshWildcardType clone() { - return new FreshWildcardType(getOffset(),this.name.toString()); + return new FreshWildcardType(this.getParent(),getOffset(),this.name.toString()); } /** @@ -146,7 +147,7 @@ public class FreshWildcardType extends Type { */ public WildcardType get_WildcardType() { - return new WildcardType(this.getOffset()); + return new WildcardType(this.getParent(),this.getOffset()); } /** * Author: Arne Lüdtke
diff --git a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java index c153ebd3..405f84b5 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/GenericTypeVar.java @@ -36,7 +36,6 @@ public class GenericTypeVar extends Type //Type genericTypeVar; //Vector extendVars = new Vector(); protected Pair genericConstraint; - private Class parent; /** * Eine Registry f�r alle Generic-Instanzen, die vor der Bytecode-Generierung durch * Ihre Superklasse ersetzt werden m�ssen. Siehe "Type Erasure" in Sun Spezifikation. @@ -63,13 +62,12 @@ public class GenericTypeVar extends Type */ // ino.method.GenericTypeVar.26509.definition - public GenericTypeVar(String s, Class parentClass, int offset) + public GenericTypeVar(String s, SyntaxTreeNode parentClass, int offset) // ino.end // ino.method.GenericTypeVar.26509.body { - super(offset); + super(parentClass,offset); this.name = new JavaClassName(s); - this.parent = parentClass; } // ino.end @@ -218,18 +216,6 @@ public class GenericTypeVar extends Type public int getEndOffset() { return this.getOffset() + this.name.toString().length(); } - - public void setParentClass(Class parent){ - //TODO: Die Methode sollte mit neuem Parser raus und dafür nur noch im Konstruktor gesetzt werden. - this.parent = parent; - } - - public Class getParentClass() { - if(this.parent == null) - throw new DebugException("GenericTypeVar ohne Elternelement"); - return this.parent; - } - } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/IntegerType.java b/src/de/dhbwstuttgart/syntaxtree/type/IntegerType.java index 1bd61acf..e94dc34e 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/IntegerType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/IntegerType.java @@ -1,6 +1,7 @@ // ino.module.IntegerType.8672.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class IntegerType extends BaseType // ino.class.IntegerType.26527.body { // ino.method.IntegerType.26531.definition - public IntegerType() + public IntegerType(SyntaxTreeNode parent) // ino.end // ino.method.IntegerType.26531.body { - super("int",-1); + super("int",parent,-1); } // ino.end @@ -51,7 +52,7 @@ public class IntegerType extends BaseType // ino.end // ino.method.clone.26537.body { - return new IntegerType(); + return new IntegerType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/LongType.java b/src/de/dhbwstuttgart/syntaxtree/type/LongType.java index 53612cb3..a465dcd8 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/LongType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/LongType.java @@ -1,6 +1,7 @@ // ino.module.IntegerType.8672.package package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -11,11 +12,11 @@ public class LongType extends BaseType // ino.class.IntegerType.26527.body { // ino.method.IntegerType.26531.definition - public LongType() + public LongType(SyntaxTreeNode parent) // ino.end // ino.method.IntegerType.26531.body { - super("long",-1); + super("long", parent,-1); } // ino.end @@ -51,7 +52,7 @@ public class LongType extends BaseType // ino.end // ino.method.clone.26537.body { - return new LongType(); + return new LongType(this.getParent()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java index a25994b4..801eb60f 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/RefType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/RefType.java @@ -66,20 +66,20 @@ public class RefType extends Type implements IMatchable // ino.method.RefType.26634.definition - public RefType(int offset) + public RefType(SyntaxTreeNode parent, int offset) // ino.end // ino.method.RefType.26634.body { - super(offset); + super(parent,offset); } // ino.end // ino.method.RefType.26637.definition - public RefType(String fullyQualifiedName, int offset) + public RefType(String fullyQualifiedName,SyntaxTreeNode parent, int offset) // ino.end // ino.method.RefType.26637.body { - super(offset); + super(parent,offset); this.setName(fullyQualifiedName); } // ino.end @@ -93,22 +93,22 @@ public class RefType extends Type implements IMatchable } // ino.method.RefType.26640.definition - public RefType(String fullyQualifiedName, Vector parameter, int offset) + public RefType(String fullyQualifiedName, Vector parameter,SyntaxTreeNode parent, int offset) // ino.end // ino.method.RefType.26640.body { - super(offset); + super(parent,offset); this.setName(fullyQualifiedName); if(parameter != null && parameter.size()>0)this.set_ParaList(parameter); } // ino.end // ino.method.RefType.26643.definition - public RefType( RefType R, int offset ) + public RefType( RefType R, SyntaxTreeNode parent,int offset ) // ino.end // ino.method.RefType.26643.body { - super(offset); + super(parent,offset); // otth: Copy-Konstruktor this.setName(R.getTypeName()); this.set_ParaList(R.getParaList()); @@ -120,8 +120,8 @@ public class RefType extends Type implements IMatchable * Dabei wird der Name und der Offset des baseType's übernommen. * @param baseType */ - public RefType( Type baseType ){ - super(baseType.getOffset()); + public RefType( Type baseType){ + super(baseType.getParent(),baseType.getOffset()); this.setName(baseType.name.toString()); //this.parameter = null; } @@ -596,7 +596,7 @@ public class RefType extends Type implements IMatchable { clonepara.addElement(((Type)para.elementAt(i)).clone()); } - RefType newRefType=new RefType(this.getTypeName(), clonepara,getOffset()); + RefType newRefType=new RefType(this.getTypeName(), clonepara,this.getParent(),getOffset()); newRefType.setPrimitiveFlag(this.getPrimitiveFlag()); return newRefType; } diff --git a/src/de/dhbwstuttgart/syntaxtree/type/ReturnType.java b/src/de/dhbwstuttgart/syntaxtree/type/ReturnType.java index 0d93f65f..9426f88f 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/ReturnType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/ReturnType.java @@ -15,7 +15,7 @@ public class ReturnType extends Type // ino.end // ino.method.ReturnType.26707.body { - super(offset); + super(null,offset); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java index cae2538d..289154cc 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; @@ -21,7 +22,7 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I */ public SuperWildcardType(int offset, Type superType) { - super(offset); + super(superType.getParent(),offset); this.superType = superType; } @@ -79,7 +80,7 @@ public class SuperWildcardType extends WildcardType implements ITypeContainer, I */ public FreshSuperWildcardType GetFreshWildcardType() { - return new FreshSuperWildcardType(this.superType,-1); + return new FreshSuperWildcardType(this.superType,this.getParent(),-1); } /** diff --git a/src/de/dhbwstuttgart/syntaxtree/type/Type.java b/src/de/dhbwstuttgart/syntaxtree/type/Type.java index b4ff5290..13f22fd7 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/Type.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/Type.java @@ -36,20 +36,21 @@ public class Type extends SyntaxTreeNode implements IItemWithOffset // ino.end // ino.method.Type.26729.definition - public Type(String s, int offset) + public Type(String s, SyntaxTreeNode parent, int offset) // ino.end // ino.method.Type.26729.body { - this(offset); + this(parent, offset); this.name = new JavaClassName(s); } // ino.end // ino.method.Type.26732.definition - public Type(int offset) + public Type(SyntaxTreeNode parent,int offset) // ino.end // ino.method.Type.26732.body { + this.parent = parent; this.offset=offset; } // ino.end @@ -199,7 +200,7 @@ public class Type extends SyntaxTreeNode implements IItemWithOffset // ino.end // ino.method.clone.26768.body { - return new Type(this.getName().toString(),getOffset()); + return new Type(this.getName().toString(), this.getParent(),getOffset()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java index 2e65d172..b8b20c44 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java @@ -53,9 +53,8 @@ public class TypePlaceholder extends Type // ino.end // ino.method.TypePlaceholder.26794.body { - super(-1); + super(parent, -1); this.name = new JavaClassName(typeName); - this.parent = parent; } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/Void.java b/src/de/dhbwstuttgart/syntaxtree/type/Void.java index 54d73277..2ef1cd1c 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/Void.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/Void.java @@ -15,11 +15,11 @@ public class Void extends RefType // ino.class.Void.26857.body { // ino.method.Void.26861.definition - public Void(int offset) + public Void(SyntaxTreeNode parent,int offset) // ino.end // ino.method.Void.26861.body { - super(offset); + super(parent,offset); super.setName("void"); } // ino.end @@ -66,7 +66,7 @@ public class Void extends RefType // ino.end // ino.method.clone.26867.body { - return new Void(getOffset()); + return new Void(this.getParent(),getOffset()); } // ino.end diff --git a/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java b/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java index 6d653a33..0a28db06 100755 --- a/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java +++ b/src/de/dhbwstuttgart/syntaxtree/type/WildcardType.java @@ -1,5 +1,6 @@ package de.dhbwstuttgart.syntaxtree.type; +import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode; import de.dhbwstuttgart.typeinference.JavaCodeResult; import de.dhbwstuttgart.typeinference.ResultSet; import sun.reflect.generics.reflectiveObjects.NotImplementedException; @@ -17,9 +18,9 @@ public class WildcardType extends Type{ * Author: Arne Lüdtke
* Standard Konstruktor für eine Wildcard */ - public WildcardType(int offset) + public WildcardType(SyntaxTreeNode parent, int offset) { - super(offset); + super(parent, offset); } /** @@ -37,7 +38,7 @@ public class WildcardType extends Type{ */ public WildcardType clone() { - return new WildcardType(getOffset()); + return new WildcardType(this.getParent(), getOffset()); } /** @@ -65,7 +66,7 @@ public class WildcardType extends Type{ */ public FreshWildcardType GetFreshWildcardType() { - return new FreshWildcardType(-1); + return new FreshWildcardType(this.getParent(),-1); } /** diff --git a/src/de/dhbwstuttgart/typeinference/FreshTypeVariable.java b/src/de/dhbwstuttgart/typeinference/FreshTypeVariable.java deleted file mode 100755 index 1d3394fc..00000000 --- a/src/de/dhbwstuttgart/typeinference/FreshTypeVariable.java +++ /dev/null @@ -1,38 +0,0 @@ -package de.dhbwstuttgart.typeinference; - -import de.dhbwstuttgart.syntaxtree.type.Type; -import sun.reflect.generics.reflectiveObjects.NotImplementedException; - -public class FreshTypeVariable extends Type{ - - private String hint = ""; - - public FreshTypeVariable(int offset) { - super(offset); - } - - /** - * Aufruf für Debug-Zwecke. - * @param hint - Eine Message die von der toString - Methode ausgegeben wird. - */ - public FreshTypeVariable(String hint){ - this(0); - this.hint = hint; - } - - public FreshTypeVariable(){ - this(0); - } - - @Override - public String toString(){ - if(hint.length()>0)return hint+" : a"; - return "FreshTypeVariable"; - } - - @Override - - public JavaCodeResult printJavaCode(ResultSet resultSet) { - throw new NotImplementedException(); - } -} diff --git a/src/de/dhbwstuttgart/typeinference/Pair.java b/src/de/dhbwstuttgart/typeinference/Pair.java index e76fdba2..b3126aa4 100755 --- a/src/de/dhbwstuttgart/typeinference/Pair.java +++ b/src/de/dhbwstuttgart/typeinference/Pair.java @@ -273,8 +273,8 @@ public class Pair hilfsvector3.addElement(p.TA1); hilfsvector4.addElement(p.TA2); //return (((RefType)TA1).is_Equiv((RefType)p.TA1, ht) && ((RefType)TA2).is_Equiv((RefType)p.TA2, ht)); - return (new RefType("dummy", hilfsvector3,-1)).is_Equiv(new RefType("dummy", hilfsvector1,-1), ht) && - (new RefType("dummy", hilfsvector4,-1)).is_Equiv(new RefType("dummy", hilfsvector2,-1), ht); + return (new RefType("dummy", hilfsvector3,null,-1)).is_Equiv(new RefType("dummy", hilfsvector1,null,-1), ht) && + (new RefType("dummy", hilfsvector4,null,-1)).is_Equiv(new RefType("dummy", hilfsvector2,null,-1), ht); } // ino.end