# $ANTLR 3.5.2 Java.g 2019-03-19 17:13:02

import sys

from antlr3 import *

from antlr3.compat import set, frozenset

from antlr3.tree import *

# for convenience in actions

HIDDEN = BaseRecognizer.HIDDEN

# token types

EOF=-1

ABSTRACT=4

AND=5

AND_ASSIGN=6

ANNOTATION_INIT_ARRAY_ELEMENT=7

ANNOTATION_INIT_BLOCK=8

ANNOTATION_INIT_DEFAULT_KEY=9

ANNOTATION_INIT_KEY_LIST=10

ANNOTATION_LIST=11

ANNOTATION_METHOD_DECL=12

ANNOTATION_SCOPE=13

ANNOTATION_TOP_LEVEL_SCOPE=14

ARGUMENT_LIST=15

ARRAY_DECLARATOR=16

ARRAY_DECLARATOR_LIST=17

ARRAY_ELEMENT_ACCESS=18

ARRAY_INITIALIZER=19

ASSERT=20

ASSIGN=21

AT=22

BIT_SHIFT_RIGHT=23

BIT_SHIFT_RIGHT_ASSIGN=24

BLOCK_SCOPE=25

BOOLEAN=26

BREAK=27

BYTE=28

CASE=29

CAST_EXPR=30

CATCH=31

CATCH_CLAUSE_LIST=32

CHAR=33

CHARACTER_LITERAL=34

CLASS=35

CLASS_CONSTRUCTOR_CALL=36

CLASS_INSTANCE_INITIALIZER=37

CLASS_STATIC_INITIALIZER=38

CLASS_TOP_LEVEL_SCOPE=39

COLON=40

COMMA=41

COMMENT=42

CONSTRUCTOR_DECL=43

CONTINUE=44

DEC=45

DECIMAL_LITERAL=46

DEFAULT=47

DIV=48

DIV_ASSIGN=49

DO=50

DOT=51

DOTSTAR=52

DOUBLE=53

ELLIPSIS=54

ELSE=55

ENUM=56

ENUM_TOP_LEVEL_SCOPE=57

EQUAL=58

ESCAPE_SEQUENCE=59

EXPONENT=60

EXPR=61

EXTENDS=62

EXTENDS_BOUND_LIST=63

EXTENDS_CLAUSE=64

FALSE=65

FINAL=66

FINALLY=67

FLOAT=68

FLOATING_POINT_LITERAL=69

FLOAT_TYPE_SUFFIX=70

FOR=71

FORMAL_PARAM_LIST=72

FORMAL_PARAM_STD_DECL=73

FORMAL_PARAM_VARARG_DECL=74

FOR_CONDITION=75

FOR_EACH=76

FOR_INIT=77

FOR_UPDATE=78

FUNCTION_METHOD_DECL=79

GENERIC_TYPE_ARG_LIST=80

GENERIC_TYPE_PARAM_LIST=81

GREATER_OR_EQUAL=82

GREATER_THAN=83

HEX_DIGIT=84

HEX_LITERAL=85

IDENT=86

IF=87

IMPLEMENTS=88

IMPLEMENTS_CLAUSE=89

IMPORT=90

INC=91

INSTANCEOF=92

INT=93

INTEGER_TYPE_SUFFIX=94

INTERFACE=95

INTERFACE_TOP_LEVEL_SCOPE=96

JAVADOC_COMMENT=97

JAVA_ID_PART=98

JAVA_ID_START=99

JAVA_SOURCE=100

LABELED_STATEMENT=101

LBRACK=102

LCURLY=103

LESS_OR_EQUAL=104

LESS_THAN=105

LINE_COMMENT=106

LOCAL_MODIFIER_LIST=107

LOGICAL_AND=108

LOGICAL_NOT=109

LOGICAL_OR=110

LONG=111

LPAREN=112

METHOD_CALL=113

MINUS=114

MINUS_ASSIGN=115

MOD=116

MODIFIER_LIST=117

MOD_ASSIGN=118

NATIVE=119

NEW=120

NOT=121

NOT_EQUAL=122

NULL=123

OCTAL_ESCAPE=124

OCTAL_LITERAL=125

OR=126

OR_ASSIGN=127

PACKAGE=128

PARENTESIZED_EXPR=129

PLUS=130

PLUS_ASSIGN=131

POST_DEC=132

POST_INC=133

PRE_DEC=134

PRE_INC=135

PRIVATE=136

PROTECTED=137

PUBLIC=138

QUALIFIED_TYPE_IDENT=139

QUESTION=140

RBRACK=141

RCURLY=142

RETURN=143

RPAREN=144

SEMI=145

SHIFT_LEFT=146

SHIFT_LEFT_ASSIGN=147

SHIFT_RIGHT=148

SHIFT_RIGHT_ASSIGN=149

SHORT=150

STAR=151

STAR_ASSIGN=152

STATIC=153

STATIC_ARRAY_CREATOR=154

STRICTFP=155

STRING_LITERAL=156

SUPER=157

SUPER_CONSTRUCTOR_CALL=158

SWITCH=159

SWITCH_BLOCK_LABEL_LIST=160

SYNCHRONIZED=161

THIS=162

THIS_CONSTRUCTOR_CALL=163

THROW=164

THROWS=165

THROWS_CLAUSE=166

TRANSIENT=167

TRUE=168

TRY=169

TYPE=170

UNARY_MINUS=171

UNARY_PLUS=172

UNICODE_ESCAPE=173

VAR_DECLARATION=174

VAR_DECLARATOR=175

VAR_DECLARATOR_LIST=176

VOID=177

VOID_METHOD_DECL=178

VOLATILE=179

WHILE=180

WS=181

XOR=182

XOR_ASSIGN=183

# token names

tokenNames = [

"<invalid>", "<EOR>", "<DOWN>", "<UP>",

"ABSTRACT", "AND", "AND_ASSIGN", "ANNOTATION_INIT_ARRAY_ELEMENT", "ANNOTATION_INIT_BLOCK",

"ANNOTATION_INIT_DEFAULT_KEY", "ANNOTATION_INIT_KEY_LIST", "ANNOTATION_LIST",

"ANNOTATION_METHOD_DECL", "ANNOTATION_SCOPE", "ANNOTATION_TOP_LEVEL_SCOPE",

"ARGUMENT_LIST", "ARRAY_DECLARATOR", "ARRAY_DECLARATOR_LIST", "ARRAY_ELEMENT_ACCESS",

"ARRAY_INITIALIZER", "ASSERT", "ASSIGN", "AT", "BIT_SHIFT_RIGHT", "BIT_SHIFT_RIGHT_ASSIGN",

"BLOCK_SCOPE", "BOOLEAN", "BREAK", "BYTE", "CASE", "CAST_EXPR", "CATCH",

"CATCH_CLAUSE_LIST", "CHAR", "CHARACTER_LITERAL", "CLASS", "CLASS_CONSTRUCTOR_CALL",

"CLASS_INSTANCE_INITIALIZER", "CLASS_STATIC_INITIALIZER", "CLASS_TOP_LEVEL_SCOPE",

"COLON", "COMMA", "COMMENT", "CONSTRUCTOR_DECL", "CONTINUE", "DEC",

"DECIMAL_LITERAL", "DEFAULT", "DIV", "DIV_ASSIGN", "DO", "DOT", "DOTSTAR",

"DOUBLE", "ELLIPSIS", "ELSE", "ENUM", "ENUM_TOP_LEVEL_SCOPE", "EQUAL",

"ESCAPE_SEQUENCE", "EXPONENT", "EXPR", "EXTENDS", "EXTENDS_BOUND_LIST",

"EXTENDS_CLAUSE", "FALSE", "FINAL", "FINALLY", "FLOAT", "FLOATING_POINT_LITERAL",

"FLOAT_TYPE_SUFFIX", "FOR", "FORMAL_PARAM_LIST", "FORMAL_PARAM_STD_DECL",

"FORMAL_PARAM_VARARG_DECL", "FOR_CONDITION", "FOR_EACH", "FOR_INIT",

"FOR_UPDATE", "FUNCTION_METHOD_DECL", "GENERIC_TYPE_ARG_LIST", "GENERIC_TYPE_PARAM_LIST",

"GREATER_OR_EQUAL", "GREATER_THAN", "HEX_DIGIT", "HEX_LITERAL", "IDENT",

"IF", "IMPLEMENTS", "IMPLEMENTS_CLAUSE", "IMPORT", "INC", "INSTANCEOF",

"INT", "INTEGER_TYPE_SUFFIX", "INTERFACE", "INTERFACE_TOP_LEVEL_SCOPE",

"JAVADOC_COMMENT", "JAVA_ID_PART", "JAVA_ID_START", "JAVA_SOURCE", "LABELED_STATEMENT",

"LBRACK", "LCURLY", "LESS_OR_EQUAL", "LESS_THAN", "LINE_COMMENT", "LOCAL_MODIFIER_LIST",

"LOGICAL_AND", "LOGICAL_NOT", "LOGICAL_OR", "LONG", "LPAREN", "METHOD_CALL",

"MINUS", "MINUS_ASSIGN", "MOD", "MODIFIER_LIST", "MOD_ASSIGN", "NATIVE",

"NEW", "NOT", "NOT_EQUAL", "NULL", "OCTAL_ESCAPE", "OCTAL_LITERAL",

"OR", "OR_ASSIGN", "PACKAGE", "PARENTESIZED_EXPR", "PLUS", "PLUS_ASSIGN",

"POST_DEC", "POST_INC", "PRE_DEC", "PRE_INC", "PRIVATE", "PROTECTED",

"PUBLIC", "QUALIFIED_TYPE_IDENT", "QUESTION", "RBRACK", "RCURLY", "RETURN",

"RPAREN", "SEMI", "SHIFT_LEFT", "SHIFT_LEFT_ASSIGN", "SHIFT_RIGHT",

"SHIFT_RIGHT_ASSIGN", "SHORT", "STAR", "STAR_ASSIGN", "STATIC", "STATIC_ARRAY_CREATOR",

"STRICTFP", "STRING_LITERAL", "SUPER", "SUPER_CONSTRUCTOR_CALL", "SWITCH",

"SWITCH_BLOCK_LABEL_LIST", "SYNCHRONIZED", "THIS", "THIS_CONSTRUCTOR_CALL",

"THROW", "THROWS", "THROWS_CLAUSE", "TRANSIENT", "TRUE", "TRY", "TYPE",

"UNARY_MINUS", "UNARY_PLUS", "UNICODE_ESCAPE", "VAR_DECLARATION", "VAR_DECLARATOR",

"VAR_DECLARATOR_LIST", "VOID", "VOID_METHOD_DECL", "VOLATILE", "WHILE",

"WS", "XOR", "XOR_ASSIGN"

]

class JavaParser(Parser):

grammarFileName = "Java.g"

api_version = 1

tokenNames = tokenNames

def __init__(self, input, state=None, *args, **kwargs):

if state is None:

state = RecognizerSharedState()

super(JavaParser, self).__init__(input, state, *args, **kwargs)

self._state.ruleMemo = {}

self.delegates = []

self._adaptor = None

self.adaptor = CommonTreeAdaptor()

def getTreeAdaptor(self):

return self._adaptor

def setTreeAdaptor(self, adaptor):

self._adaptor = adaptor

adaptor = property(getTreeAdaptor, setTreeAdaptor)

class javaSource_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.javaSource_return, self).__init__()

self.tree = None

# $ANTLR start "javaSource"

# Java.g:222:1: javaSource : compilationUnit -> ^( JAVA_SOURCE compilationUnit ) ;

def javaSource(self, ):

retval = self.javaSource_return()

retval.start = self.input.LT(1)

javaSource_StartIndex = self.input.index()

root_0 = None

compilationUnit1 = None

stream_compilationUnit = RewriteRuleSubtreeStream(self._adaptor, "rule compilationUnit")

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 1):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:223:5: ( compilationUnit -> ^( JAVA_SOURCE compilationUnit ) )

# Java.g:223:9: compilationUnit

pass

self._state.following.append(self.FOLLOW_compilationUnit_in_javaSource4461)

compilationUnit1 = self.compilationUnit()

self._state.following.pop()

if self._state.backtracking == 0:

stream_compilationUnit.add(compilationUnit1.tree)

# AST Rewrite

# elements: compilationUnit

# token labels:

# rule labels: retval

# token list labels:

# rule list labels:

# wildcard labels:

if self._state.backtracking == 0:

retval.tree = root_0

if retval is not None:

stream_retval = RewriteRuleSubtreeStream(self._adaptor, "rule retval", retval.tree)

else:

stream_retval = RewriteRuleSubtreeStream(self._adaptor, "token retval", None)

root_0 = self._adaptor.nil()

# 224:9: -> ^( JAVA_SOURCE compilationUnit )

# Java.g:224:13: ^( JAVA_SOURCE compilationUnit )

root_1 = self._adaptor.nil()

root_1 = self._adaptor.becomeRoot(

self._adaptor.createFromType(JAVA_SOURCE, "JAVA_SOURCE")

, root_1)

self._adaptor.addChild(root_1, stream_compilationUnit.nextTree())

self._adaptor.addChild(root_0, root_1)

retval.tree = root_0

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 1, javaSource_StartIndex, success)

pass

return retval

# $ANTLR end "javaSource"

class compilationUnit_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.compilationUnit_return, self).__init__()

self.tree = None

# $ANTLR start "compilationUnit"

# Java.g:227:1: compilationUnit : annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )* ;

def compilationUnit(self, ):

retval = self.compilationUnit_return()

retval.start = self.input.LT(1)

compilationUnit_StartIndex = self.input.index()

root_0 = None

annotationList2 = None

packageDeclaration3 = None

importDeclaration4 = None

typeDecls5 = None

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 2):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:228:5: ( annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )* )

# Java.g:228:9: annotationList ( packageDeclaration )? ( importDeclaration )* ( typeDecls )*

pass

root_0 = self._adaptor.nil()

self._state.following.append(self.FOLLOW_annotationList_in_compilationUnit4497)

annotationList2 = self.annotationList()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, annotationList2.tree)

# Java.g:229:9: ( packageDeclaration )?

alt1 = 2

LA1_0 = self.input.LA(1)

if (LA1_0 == PACKAGE) :

alt1 = 1

if alt1 == 1:

# Java.g:229:9: packageDeclaration

pass

self._state.following.append(self.FOLLOW_packageDeclaration_in_compilationUnit4507)

packageDeclaration3 = self.packageDeclaration()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, packageDeclaration3.tree)

# Java.g:230:9: ( importDeclaration )*

while True: #loop2

alt2 = 2

LA2_0 = self.input.LA(1)

if (LA2_0 == IMPORT) :

alt2 = 1

if alt2 == 1:

# Java.g:230:9: importDeclaration

pass

self._state.following.append(self.FOLLOW_importDeclaration_in_compilationUnit4518)

importDeclaration4 = self.importDeclaration()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, importDeclaration4.tree)

else:

break #loop2

# Java.g:231:9: ( typeDecls )*

while True: #loop3

alt3 = 2

LA3_0 = self.input.LA(1)

if (LA3_0 == ABSTRACT or LA3_0 == AT or LA3_0 == BOOLEAN or LA3_0 == BYTE or LA3_0 == CHAR or LA3_0 == CLASS or LA3_0 == DOUBLE or LA3_0 == ENUM or LA3_0 == FINAL or LA3_0 == FLOAT or LA3_0 == IDENT or LA3_0 == INT or LA3_0 == INTERFACE or LA3_0 == LESS_THAN or LA3_0 == LONG or LA3_0 == NATIVE or (PRIVATE <= LA3_0 <= PUBLIC) or LA3_0 == SEMI or LA3_0 == SHORT or LA3_0 == STATIC or LA3_0 == STRICTFP or LA3_0 == SYNCHRONIZED or LA3_0 == TRANSIENT or LA3_0 == VOID or LA3_0 == VOLATILE) :

alt3 = 1

if alt3 == 1:

# Java.g:231:9: typeDecls

pass

self._state.following.append(self.FOLLOW_typeDecls_in_compilationUnit4529)

typeDecls5 = self.typeDecls()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, typeDecls5.tree)

else:

break #loop3

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 2, compilationUnit_StartIndex, success)

pass

return retval

# $ANTLR end "compilationUnit"

class typeDecls_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.typeDecls_return, self).__init__()

self.tree = None

# $ANTLR start "typeDecls"

# Java.g:234:1: typeDecls : ( typeDeclaration | SEMI !);

def typeDecls(self, ):

retval = self.typeDecls_return()

retval.start = self.input.LT(1)

typeDecls_StartIndex = self.input.index()

root_0 = None

SEMI7 = None

typeDeclaration6 = None

SEMI7_tree = None

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 3):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:235:5: ( typeDeclaration | SEMI !)

alt4 = 2

LA4_0 = self.input.LA(1)

if (LA4_0 == ABSTRACT or LA4_0 == AT or LA4_0 == BOOLEAN or LA4_0 == BYTE or LA4_0 == CHAR or LA4_0 == CLASS or LA4_0 == DOUBLE or LA4_0 == ENUM or LA4_0 == FINAL or LA4_0 == FLOAT or LA4_0 == IDENT or LA4_0 == INT or LA4_0 == INTERFACE or LA4_0 == LESS_THAN or LA4_0 == LONG or LA4_0 == NATIVE or (PRIVATE <= LA4_0 <= PUBLIC) or LA4_0 == SHORT or LA4_0 == STATIC or LA4_0 == STRICTFP or LA4_0 == SYNCHRONIZED or LA4_0 == TRANSIENT or LA4_0 == VOID or LA4_0 == VOLATILE) :

alt4 = 1

elif (LA4_0 == SEMI) :

alt4 = 2

else:

if self._state.backtracking > 0:

raise BacktrackingFailed

nvae = NoViableAltException("", 4, 0, self.input)

raise nvae

if alt4 == 1:

# Java.g:235:9: typeDeclaration

pass

root_0 = self._adaptor.nil()

self._state.following.append(self.FOLLOW_typeDeclaration_in_typeDecls4549)

typeDeclaration6 = self.typeDeclaration()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, typeDeclaration6.tree)

elif alt4 == 2:

# Java.g:236:9: SEMI !

pass

root_0 = self._adaptor.nil()

SEMI7 = self.match(self.input, SEMI, self.FOLLOW_SEMI_in_typeDecls4559)

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 3, typeDecls_StartIndex, success)

pass

return retval

# $ANTLR end "typeDecls"

class packageDeclaration_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.packageDeclaration_return, self).__init__()

self.tree = None

# $ANTLR start "packageDeclaration"

# Java.g:239:1: packageDeclaration : PACKAGE ^ qualifiedIdentifier SEMI !;

def packageDeclaration(self, ):

retval = self.packageDeclaration_return()

retval.start = self.input.LT(1)

packageDeclaration_StartIndex = self.input.index()

root_0 = None

PACKAGE8 = None

SEMI10 = None

qualifiedIdentifier9 = None

PACKAGE8_tree = None

SEMI10_tree = None

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 4):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:240:5: ( PACKAGE ^ qualifiedIdentifier SEMI !)

# Java.g:240:9: PACKAGE ^ qualifiedIdentifier SEMI !

pass

root_0 = self._adaptor.nil()

PACKAGE8 = self.match(self.input, PACKAGE, self.FOLLOW_PACKAGE_in_packageDeclaration4579)

if self._state.backtracking == 0:

PACKAGE8_tree = self._adaptor.createWithPayload(PACKAGE8)

root_0 = self._adaptor.becomeRoot(PACKAGE8_tree, root_0)

self._state.following.append(self.FOLLOW_qualifiedIdentifier_in_packageDeclaration4582)

qualifiedIdentifier9 = self.qualifiedIdentifier()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, qualifiedIdentifier9.tree)

SEMI10 = self.match(self.input, SEMI, self.FOLLOW_SEMI_in_packageDeclaration4584)

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 4, packageDeclaration_StartIndex, success)

pass

return retval

# $ANTLR end "packageDeclaration"

class importDeclaration_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.importDeclaration_return, self).__init__()

self.tree = None

# $ANTLR start "importDeclaration"

# Java.g:243:1: importDeclaration : IMPORT ^ ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI !;

def importDeclaration(self, ):

retval = self.importDeclaration_return()

retval.start = self.input.LT(1)

importDeclaration_StartIndex = self.input.index()

root_0 = None

IMPORT11 = None

STATIC12 = None

DOTSTAR14 = None

SEMI15 = None

qualifiedIdentifier13 = None

IMPORT11_tree = None

STATIC12_tree = None

DOTSTAR14_tree = None

SEMI15_tree = None

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 5):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:244:5: ( IMPORT ^ ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI !)

# Java.g:244:9: IMPORT ^ ( STATIC )? qualifiedIdentifier ( DOTSTAR )? SEMI !

pass

root_0 = self._adaptor.nil()

IMPORT11 = self.match(self.input, IMPORT, self.FOLLOW_IMPORT_in_importDeclaration4604)

if self._state.backtracking == 0:

IMPORT11_tree = self._adaptor.createWithPayload(IMPORT11)

root_0 = self._adaptor.becomeRoot(IMPORT11_tree, root_0)

# Java.g:244:17: ( STATIC )?

alt5 = 2

LA5_0 = self.input.LA(1)

if (LA5_0 == STATIC) :

alt5 = 1

if alt5 == 1:

# Java.g:244:17: STATIC

pass

STATIC12 = self.match(self.input, STATIC, self.FOLLOW_STATIC_in_importDeclaration4607)

if self._state.backtracking == 0:

STATIC12_tree = self._adaptor.createWithPayload(STATIC12)

self._adaptor.addChild(root_0, STATIC12_tree)

self._state.following.append(self.FOLLOW_qualifiedIdentifier_in_importDeclaration4610)

qualifiedIdentifier13 = self.qualifiedIdentifier()

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, qualifiedIdentifier13.tree)

# Java.g:244:45: ( DOTSTAR )?

alt6 = 2

LA6_0 = self.input.LA(1)

if (LA6_0 == DOTSTAR) :

alt6 = 1

if alt6 == 1:

# Java.g:244:45: DOTSTAR

pass

DOTSTAR14 = self.match(self.input, DOTSTAR, self.FOLLOW_DOTSTAR_in_importDeclaration4612)

if self._state.backtracking == 0:

DOTSTAR14_tree = self._adaptor.createWithPayload(DOTSTAR14)

self._adaptor.addChild(root_0, DOTSTAR14_tree)

SEMI15 = self.match(self.input, SEMI, self.FOLLOW_SEMI_in_importDeclaration4615)

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 5, importDeclaration_StartIndex, success)

pass

return retval

# $ANTLR end "importDeclaration"

class typeDeclaration_return(ParserRuleReturnScope):

def __init__(self):

super(JavaParser.typeDeclaration_return, self).__init__()

self.tree = None

# $ANTLR start "typeDeclaration"

# Java.g:247:1: typeDeclaration : modifierList ! ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] ) ;

def typeDeclaration(self, ):

retval = self.typeDeclaration_return()

retval.start = self.input.LT(1)

typeDeclaration_StartIndex = self.input.index()

root_0 = None

modifierList16 = None

classTypeDeclaration17 = None

interfaceTypeDeclaration18 = None

enumTypeDeclaration19 = None

annotationTypeDeclaration20 = None

success = False

try:

try:

if self._state.backtracking > 0 and self.alreadyParsedRule(self.input, 6):

# for cached failed rules, alreadyParsedRule will raise an exception

success = True

return retval

# Java.g:248:5: ( modifierList ! ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] ) )

# Java.g:248:9: modifierList ! ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] )

pass

root_0 = self._adaptor.nil()

self._state.following.append(self.FOLLOW_modifierList_in_typeDeclaration4635)

modifierList16 = self.modifierList()

self._state.following.pop()

# Java.g:249:9: ( classTypeDeclaration[$modifierList.tree] | interfaceTypeDeclaration[$modifierList.tree] | enumTypeDeclaration[$modifierList.tree] | annotationTypeDeclaration[$modifierList.tree] )

alt7 = 4

LA7 = self.input.LA(1)

if LA7 == CLASS:

alt7 = 1

elif LA7 == INTERFACE:

alt7 = 2

elif LA7 == ENUM:

alt7 = 3

elif LA7 == AT:

alt7 = 4

else:

if self._state.backtracking > 0:

raise BacktrackingFailed

nvae = NoViableAltException("", 7, 0, self.input)

raise nvae

if alt7 == 1:

# Java.g:249:13: classTypeDeclaration[$modifierList.tree]

pass

self._state.following.append(self.FOLLOW_classTypeDeclaration_in_typeDeclaration4650)

classTypeDeclaration17 = self.classTypeDeclaration(modifierList16.tree)

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, classTypeDeclaration17.tree)

elif alt7 == 2:

# Java.g:250:13: interfaceTypeDeclaration[$modifierList.tree]

pass

self._state.following.append(self.FOLLOW_interfaceTypeDeclaration_in_typeDeclaration4665)

interfaceTypeDeclaration18 = self.interfaceTypeDeclaration(modifierList16.tree)

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, interfaceTypeDeclaration18.tree)

elif alt7 == 3:

# Java.g:251:13: enumTypeDeclaration[$modifierList.tree]

pass

self._state.following.append(self.FOLLOW_enumTypeDeclaration_in_typeDeclaration4680)

enumTypeDeclaration19 = self.enumTypeDeclaration(modifierList16.tree)

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, enumTypeDeclaration19.tree)

elif alt7 == 4:

# Java.g:252:13: annotationTypeDeclaration[$modifierList.tree]

pass

self._state.following.append(self.FOLLOW_annotationTypeDeclaration_in_typeDeclaration4695)

annotationTypeDeclaration20 = self.annotationTypeDeclaration(modifierList16.tree)

self._state.following.pop()

if self._state.backtracking == 0:

self._adaptor.addChild(root_0, annotationTypeDeclaration20.tree)

retval.stop = self.input.LT(-1)

if self._state.backtracking == 0:

retval.tree = self._adaptor.rulePostProcessing(root_0)

self._adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop)

success = True

except RecognitionException as re:

self.reportError(re)

self.recover(self.input, re)

retval.tree = self._adaptor.errorNode(self.input, retval.start, self.input.LT(-1), re)

finally:

if self._state.backtracking > 0:

self.memoize(self.input, 6, typeDeclaration_StartIndex, success)

pass

return retval

# $ANTLR end "typeDeclaration"