# $ANTLR 3.1.3 Mar 18, 2009 10:09:25 Java.g 2012-01-29 13:54:04

import re

import sys

from antlr3 import *

from antlr3.compat import set, frozenset

from antlr3.tree import *

def version_str_to_tuple(version_str):

"""Convert a version string into a tuple of integers."""

# Extract numeric parts of the version string

numbers = re.findall(r'\d+', version_str)

# Convert numeric strings to integers and return as a tuple

return tuple(map(int, numbers))

# for convenience in actions

HIDDEN = BaseRecognizer.HIDDEN

# token types

PACKAGE=84

EXPONENT=173

STAR=49

WHILE=103

MOD=32

MOD_ASSIGN=33

CASE=58

CHAR=60

NEW=82

DO=64

GENERIC_TYPE_PARAM_LIST=138

CLASS_INSTANCE_INITIALIZER=121

ARRAY_ELEMENT_ACCESS=115

FOR_CONDITION=129

NOT=34

VAR_DECLARATION=160

ANNOTATION_METHOD_DECL=109

EOF=-1

DIV_ASSIGN=14

LOGICAL_AND=26

BREAK=56

UNARY_PLUS=159

BIT_SHIFT_RIGHT_ASSIGN=9

TYPE=157

RPAREN=43

INC=21

FINAL=70

IMPORT=78

STRING_LITERAL=170

FOR_UPDATE=132

FLOATING_POINT_LITERAL=168

CAST_EXPR=118

NOT_EQUAL=35

VOID_METHOD_DECL=163

THIS=95

RETURN=88

DOUBLE=65

ENUM_TOP_LEVEL_SCOPE=125

VOID=101

SUPER=92

COMMENT=181

ANNOTATION_INIT_KEY_LIST=107

JAVA_ID_START=178

FLOAT_TYPE_SUFFIX=174

PRE_DEC=149

RBRACK=41

IMPLEMENTS_CLAUSE=140

SWITCH_BLOCK_LABEL_LIST=154

LINE_COMMENT=182

PRIVATE=85

STATIC=90

BLOCK_SCOPE=117

ANNOTATION_INIT_DEFAULT_KEY=106

SWITCH=93

NULL=83

VAR_DECLARATOR=161

MINUS_ASSIGN=31

ELSE=66

STRICTFP=91

CHARACTER_LITERAL=169

PRE_INC=150

ANNOTATION_LIST=108

ELLIPSIS=17

NATIVE=81

OCTAL_ESCAPE=177

UNARY_MINUS=158

THROWS=97

LCURLY=23

INT=79

FORMAL_PARAM_VARARG_DECL=135

METHOD_CALL=144

ASSERT=54

TRY=100

INTERFACE_TOP_LEVEL_SCOPE=139

SHIFT_LEFT=45

WS=180

SHIFT_RIGHT=47

FORMAL_PARAM_STD_DECL=134

LOCAL_MODIFIER_LIST=142

OR=36

LESS_THAN=25

SHIFT_RIGHT_ASSIGN=48

EXTENDS_BOUND_LIST=127

JAVA_SOURCE=143

CATCH=59

FALSE=69

INTEGER_TYPE_SUFFIX=172

DECIMAL_LITERAL=167

THROW=96

FOR_INIT=131

DEC=12

PROTECTED=86

CLASS=61

LBRACK=22

BIT_SHIFT_RIGHT=8

THROWS_CLAUSE=156

GREATER_OR_EQUAL=19

FOR=73

THIS_CONSTRUCTOR_CALL=155

LOGICAL_NOT=27

JAVADOC_COMMENT=183

FLOAT=72

ABSTRACT=53

AND=4

POST_DEC=147

AND_ASSIGN=5

STATIC_ARRAY_CREATOR=152

MODIFIER_LIST=145

ANNOTATION_SCOPE=110

LPAREN=29

IF=74

AT=7

ESCAPE_SEQUENCE=175

CONSTRUCTOR_DECL=124

LABELED_STATEMENT=141

UNICODE_ESCAPE=176

EXPR=126

SYNCHRONIZED=94

BOOLEAN=55

CLASS_TOP_LEVEL_SCOPE=123

IMPLEMENTS=75

CONTINUE=62

COMMA=11

TRANSIENT=98

EQUAL=18

XOR_ASSIGN=52

LOGICAL_OR=28

IDENT=164

QUALIFIED_TYPE_IDENT=151

ARGUMENT_LIST=112

PLUS=38

HEX_LITERAL=165

ANNOTATION_INIT_BLOCK=105

DOT=15

SHIFT_LEFT_ASSIGN=46

FORMAL_PARAM_LIST=133

GENERIC_TYPE_ARG_LIST=137

ANNOTATION_TOP_LEVEL_SCOPE=111

DOTSTAR=16

BYTE=57

XOR=51

JAVA_ID_PART=179

GREATER_THAN=20

VOLATILE=102

PARENTESIZED_EXPR=146

CLASS_STATIC_INITIALIZER=122

ARRAY_DECLARATOR_LIST=114

LESS_OR_EQUAL=24

DEFAULT=63

OCTAL_LITERAL=166

HEX_DIGIT=171

SHORT=89

INSTANCEOF=76

MINUS=30

EXTENDS_CLAUSE=128

TRUE=99

SEMI=44

STAR_ASSIGN=50

VAR_DECLARATOR_LIST=162

ARRAY_DECLARATOR=113

COLON=10

OR_ASSIGN=37

ENUM=67

QUESTION=40

FINALLY=71

RCURLY=42

PLUS_ASSIGN=39

ASSIGN=6

ANNOTATION_INIT_ARRAY_ELEMENT=104

FUNCTION_METHOD_DECL=136

INTERFACE=77

POST_INC=148

DIV=13

CLASS_CONSTRUCTOR_CALL=120

LONG=80

FOR_EACH=130

EXTENDS=68

PUBLIC=87

ARRAY_INITIALIZER=116

CATCH_CLAUSE_LIST=119

SUPER_CONSTRUCTOR_CALL=153

# token names

tokenNames = [

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

"AND", "AND_ASSIGN", "ASSIGN", "AT", "BIT_SHIFT_RIGHT", "BIT_SHIFT_RIGHT_ASSIGN",

"COLON", "COMMA", "DEC", "DIV", "DIV_ASSIGN", "DOT", "DOTSTAR", "ELLIPSIS",

"EQUAL", "GREATER_OR_EQUAL", "GREATER_THAN", "INC", "LBRACK", "LCURLY",

"LESS_OR_EQUAL", "LESS_THAN", "LOGICAL_AND", "LOGICAL_NOT", "LOGICAL_OR",

"LPAREN", "MINUS", "MINUS_ASSIGN", "MOD", "MOD_ASSIGN", "NOT", "NOT_EQUAL",

"OR", "OR_ASSIGN", "PLUS", "PLUS_ASSIGN", "QUESTION", "RBRACK", "RCURLY",

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

"SHIFT_RIGHT_ASSIGN", "STAR", "STAR_ASSIGN", "XOR", "XOR_ASSIGN", "ABSTRACT",

"ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS",

"CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", "FALSE",

"FINAL", "FINALLY", "FLOAT", "FOR", "IF", "IMPLEMENTS", "INSTANCEOF",

"INTERFACE", "IMPORT", "INT", "LONG", "NATIVE", "NEW", "NULL", "PACKAGE",

"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP",

"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT",

"TRUE", "TRY", "VOID", "VOLATILE", "WHILE", "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", "BLOCK_SCOPE", "CAST_EXPR", "CATCH_CLAUSE_LIST",

"CLASS_CONSTRUCTOR_CALL", "CLASS_INSTANCE_INITIALIZER", "CLASS_STATIC_INITIALIZER",

"CLASS_TOP_LEVEL_SCOPE", "CONSTRUCTOR_DECL", "ENUM_TOP_LEVEL_SCOPE",

"EXPR", "EXTENDS_BOUND_LIST", "EXTENDS_CLAUSE", "FOR_CONDITION", "FOR_EACH",

"FOR_INIT", "FOR_UPDATE", "FORMAL_PARAM_LIST", "FORMAL_PARAM_STD_DECL",

"FORMAL_PARAM_VARARG_DECL", "FUNCTION_METHOD_DECL", "GENERIC_TYPE_ARG_LIST",

"GENERIC_TYPE_PARAM_LIST", "INTERFACE_TOP_LEVEL_SCOPE", "IMPLEMENTS_CLAUSE",

"LABELED_STATEMENT", "LOCAL_MODIFIER_LIST", "JAVA_SOURCE", "METHOD_CALL",

"MODIFIER_LIST", "PARENTESIZED_EXPR", "POST_DEC", "POST_INC", "PRE_DEC",

"PRE_INC", "QUALIFIED_TYPE_IDENT", "STATIC_ARRAY_CREATOR", "SUPER_CONSTRUCTOR_CALL",

"SWITCH_BLOCK_LABEL_LIST", "THIS_CONSTRUCTOR_CALL", "THROWS_CLAUSE",

"TYPE", "UNARY_MINUS", "UNARY_PLUS", "VAR_DECLARATION", "VAR_DECLARATOR",

"VAR_DECLARATOR_LIST", "VOID_METHOD_DECL", "IDENT", "HEX_LITERAL", "OCTAL_LITERAL",

"DECIMAL_LITERAL", "FLOATING_POINT_LITERAL", "CHARACTER_LITERAL", "STRING_LITERAL",

"HEX_DIGIT", "INTEGER_TYPE_SUFFIX", "EXPONENT", "FLOAT_TYPE_SUFFIX",

"ESCAPE_SEQUENCE", "UNICODE_ESCAPE", "OCTAL_ESCAPE", "JAVA_ID_START",

"JAVA_ID_PART", "WS", "COMMENT", "LINE_COMMENT", "JAVADOC_COMMENT"

]

class JavaParser(Parser):

grammarFileName = "Java.g"

antlr_version = version_str_to_tuple("3.1.3 Mar 18, 2009 10:09:25")

antlr_version_str = "3.1.3 Mar 18, 2009 10:09:25"

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.dfa36 = self.DFA36(

self, 36,

eot = self.DFA36_eot,

eof = self.DFA36_eof,

min = self.DFA36_min,

max = self.DFA36_max,

accept = self.DFA36_accept,

special = self.DFA36_special,

transition = self.DFA36_transition

)

self.dfa43 = self.DFA43(

self, 43,

eot = self.DFA43_eot,

eof = self.DFA43_eof,

min = self.DFA43_min,

max = self.DFA43_max,

accept = self.DFA43_accept,

special = self.DFA43_special,

transition = self.DFA43_transition

)

self.dfa86 = self.DFA86(

self, 86,

eot = self.DFA86_eot,

eof = self.DFA86_eof,

min = self.DFA86_min,

max = self.DFA86_max,

accept = self.DFA86_accept,

special = self.DFA86_special,

transition = self.DFA86_transition

)

self.dfa88 = self.DFA88(

self, 88,

eot = self.DFA88_eot,

eof = self.DFA88_eof,

min = self.DFA88_min,

max = self.DFA88_max,

accept = self.DFA88_accept,

special = self.DFA88_special,

transition = self.DFA88_transition

)

self.dfa98 = self.DFA98(

self, 98,

eot = self.DFA98_eot,

eof = self.DFA98_eof,

min = self.DFA98_min,

max = self.DFA98_max,

accept = self.DFA98_accept,

special = self.DFA98_special,

transition = self.DFA98_transition

)

self.dfa91 = self.DFA91(

self, 91,

eot = self.DFA91_eot,

eof = self.DFA91_eof,

min = self.DFA91_min,

max = self.DFA91_max,

accept = self.DFA91_accept,

special = self.DFA91_special,

transition = self.DFA91_transition

)

self.dfa106 = self.DFA106(

self, 106,

eot = self.DFA106_eot,

eof = self.DFA106_eof,

min = self.DFA106_min,

max = self.DFA106_max,

accept = self.DFA106_accept,

special = self.DFA106_special,

transition = self.DFA106_transition

)

self.dfa130 = self.DFA130(

self, 130,

eot = self.DFA130_eot,

eof = self.DFA130_eof,

min = self.DFA130_min,

max = self.DFA130_max,

accept = self.DFA130_accept,

special = self.DFA130_special,

transition = self.DFA130_transition

)

self.dfa142 = self.DFA142(

self, 142,

eot = self.DFA142_eot,

eof = self.DFA142_eof,

min = self.DFA142_min,

max = self.DFA142_max,

accept = self.DFA142_accept,

special = self.DFA142_special,

transition = self.DFA142_transition

)

self.dfa146 = self.DFA146(

self, 146,

eot = self.DFA146_eot,

eof = self.DFA146_eof,

min = self.DFA146_min,

max = self.DFA146_max,

accept = self.DFA146_accept,

special = self.DFA146_special,

transition = self.DFA146_transition

)

self.dfa153 = self.DFA153(

self, 153,

eot = self.DFA153_eot,

eof = self.DFA153_eof,

min = self.DFA153_min,

max = self.DFA153_max,

accept = self.DFA153_accept,

special = self.DFA153_special,

transition = self.DFA153_transition

)

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, 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:0:0: 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:0:0: 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 == AT or LA3_0 == LESS_THAN or LA3_0 == SEMI or LA3_0 == ABSTRACT or LA3_0 == BOOLEAN or LA3_0 == BYTE or (CHAR <= LA3_0 <= CLASS) or LA3_0 == DOUBLE or LA3_0 == ENUM or LA3_0 == FINAL or LA3_0 == FLOAT or LA3_0 == INTERFACE or (INT <= LA3_0 <= NATIVE) or (PRIVATE <= LA3_0 <= PUBLIC) or (SHORT <= LA3_0 <= STRICTFP) or LA3_0 == SYNCHRONIZED or LA3_0 == TRANSIENT or (VOID <= LA3_0 <= VOLATILE) or LA3_0 == IDENT) :

alt3 = 1

if alt3 == 1:

# Java.g:0:0: 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, 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 == AT or LA4_0 == LESS_THAN or LA4_0 == ABSTRACT or LA4_0 == BOOLEAN or LA4_0 == BYTE or (CHAR <= LA4_0 <= CLASS) or LA4_0 == DOUBLE or LA4_0 == ENUM or LA4_0 == FINAL or LA4_0 == FLOAT or LA4_0 == INTERFACE or (INT <= LA4_0 <= NATIVE) or (PRIVATE <= LA4_0 <= PUBLIC) or (SHORT <= LA4_0 <= STRICTFP) or LA4_0 == SYNCHRONIZED or LA4_0 == TRANSIENT or (VOID <= LA4_0 <= VOLATILE) or LA4_0 == IDENT) :

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, 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, 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:0:0: 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:0:0: 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, 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)