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

import sys

from antlr3 import *

from antlr3.compat import set, frozenset

# 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

class JavaLexer(Lexer):

grammarFileName = "Java.g"

api_version = 1

def __init__(self, input=None, state=None):

if state is None:

state = RecognizerSharedState()

super(JavaLexer, self).__init__(input, state)

self.delegates = []

self.dfa29 = self.DFA29(

self, 29,

eot = self.DFA29_eot,

eof = self.DFA29_eof,

min = self.DFA29_min,

max = self.DFA29_max,

accept = self.DFA29_accept,

special = self.DFA29_special,

transition = self.DFA29_transition

)

# $ANTLR start "ABSTRACT"

def mABSTRACT(self, ):

try:

_type = ABSTRACT

_channel = DEFAULT_CHANNEL

# Java.g:7:10: ( 'abstract' )

# Java.g:7:12: 'abstract'

pass

self.match("abstract")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ABSTRACT"

# $ANTLR start "AND"

def mAND(self, ):

try:

_type = AND

_channel = DEFAULT_CHANNEL

# Java.g:8:5: ( '&' )

# Java.g:8:7: '&'

pass

self.match(38)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "AND"

# $ANTLR start "AND_ASSIGN"

def mAND_ASSIGN(self, ):

try:

_type = AND_ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:9:12: ( '&=' )

# Java.g:9:14: '&='

pass

self.match("&=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "AND_ASSIGN"

# $ANTLR start "ASSERT"

def mASSERT(self, ):

try:

_type = ASSERT

_channel = DEFAULT_CHANNEL

# Java.g:10:8: ( 'assert' )

# Java.g:10:10: 'assert'

pass

self.match("assert")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ASSERT"

# $ANTLR start "ASSIGN"

def mASSIGN(self, ):

try:

_type = ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:11:8: ( '=' )

# Java.g:11:10: '='

pass

self.match(61)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ASSIGN"

# $ANTLR start "AT"

def mAT(self, ):

try:

_type = AT

_channel = DEFAULT_CHANNEL

# Java.g:12:4: ( '@' )

# Java.g:12:6: '@'

pass

self.match(64)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "AT"

# $ANTLR start "BIT_SHIFT_RIGHT"

def mBIT_SHIFT_RIGHT(self, ):

try:

_type = BIT_SHIFT_RIGHT

_channel = DEFAULT_CHANNEL

# Java.g:13:17: ( '>>>' )

# Java.g:13:19: '>>>'

pass

self.match(">>>")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BIT_SHIFT_RIGHT"

# $ANTLR start "BIT_SHIFT_RIGHT_ASSIGN"

def mBIT_SHIFT_RIGHT_ASSIGN(self, ):

try:

_type = BIT_SHIFT_RIGHT_ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:14:24: ( '>>>=' )

# Java.g:14:26: '>>>='

pass

self.match(">>>=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BIT_SHIFT_RIGHT_ASSIGN"

# $ANTLR start "BOOLEAN"

def mBOOLEAN(self, ):

try:

_type = BOOLEAN

_channel = DEFAULT_CHANNEL

# Java.g:15:9: ( 'boolean' )

# Java.g:15:11: 'boolean'

pass

self.match("boolean")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BOOLEAN"

# $ANTLR start "BREAK"

def mBREAK(self, ):

try:

_type = BREAK

_channel = DEFAULT_CHANNEL

# Java.g:16:7: ( 'break' )

# Java.g:16:9: 'break'

pass

self.match("break")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BREAK"

# $ANTLR start "BYTE"

def mBYTE(self, ):

try:

_type = BYTE

_channel = DEFAULT_CHANNEL

# Java.g:17:6: ( 'byte' )

# Java.g:17:8: 'byte'

pass

self.match("byte")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BYTE"

# $ANTLR start "CASE"

def mCASE(self, ):

try:

_type = CASE

_channel = DEFAULT_CHANNEL

# Java.g:18:6: ( 'case' )

# Java.g:18:8: 'case'

pass

self.match("case")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "CASE"

# $ANTLR start "CATCH"

def mCATCH(self, ):

try:

_type = CATCH

_channel = DEFAULT_CHANNEL

# Java.g:19:7: ( 'catch' )

# Java.g:19:9: 'catch'

pass

self.match("catch")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "CATCH"

# $ANTLR start "CHAR"

def mCHAR(self, ):

try:

_type = CHAR

_channel = DEFAULT_CHANNEL

# Java.g:20:6: ( 'char' )

# Java.g:20:8: 'char'

pass

self.match("char")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "CHAR"

# $ANTLR start "CLASS"

def mCLASS(self, ):

try:

_type = CLASS

_channel = DEFAULT_CHANNEL

# Java.g:21:7: ( 'class' )

# Java.g:21:9: 'class'

pass

self.match("class")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "CLASS"

# $ANTLR start "COLON"

def mCOLON(self, ):

try:

_type = COLON

_channel = DEFAULT_CHANNEL

# Java.g:22:7: ( ':' )

# Java.g:22:9: ':'

pass

self.match(58)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "COLON"

# $ANTLR start "COMMA"

def mCOMMA(self, ):

try:

_type = COMMA

_channel = DEFAULT_CHANNEL

# Java.g:23:7: ( ',' )

# Java.g:23:9: ','

pass

self.match(44)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "COMMA"

# $ANTLR start "CONTINUE"

def mCONTINUE(self, ):

try:

_type = CONTINUE

_channel = DEFAULT_CHANNEL

# Java.g:24:10: ( 'continue' )

# Java.g:24:12: 'continue'

pass

self.match("continue")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "CONTINUE"

# $ANTLR start "DEC"

def mDEC(self, ):

try:

_type = DEC

_channel = DEFAULT_CHANNEL

# Java.g:25:5: ( '--' )

# Java.g:25:7: '--'

pass

self.match("--")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DEC"

# $ANTLR start "DEFAULT"

def mDEFAULT(self, ):

try:

_type = DEFAULT

_channel = DEFAULT_CHANNEL

# Java.g:26:9: ( 'default' )

# Java.g:26:11: 'default'

pass

self.match("default")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DEFAULT"

# $ANTLR start "DIV"

def mDIV(self, ):

try:

_type = DIV

_channel = DEFAULT_CHANNEL

# Java.g:27:5: ( '/' )

# Java.g:27:7: '/'

pass

self.match(47)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DIV"

# $ANTLR start "DIV_ASSIGN"

def mDIV_ASSIGN(self, ):

try:

_type = DIV_ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:28:12: ( '/=' )

# Java.g:28:14: '/='

pass

self.match("/=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DIV_ASSIGN"

# $ANTLR start "DO"

def mDO(self, ):

try:

_type = DO

_channel = DEFAULT_CHANNEL

# Java.g:29:4: ( 'do' )

# Java.g:29:6: 'do'

pass

self.match("do")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DO"

# $ANTLR start "DOT"

def mDOT(self, ):

try:

_type = DOT

_channel = DEFAULT_CHANNEL

# Java.g:30:5: ( '.' )

# Java.g:30:7: '.'

pass

self.match(46)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DOT"

# $ANTLR start "DOTSTAR"

def mDOTSTAR(self, ):

try:

_type = DOTSTAR

_channel = DEFAULT_CHANNEL

# Java.g:31:9: ( '.*' )

# Java.g:31:11: '.*'

pass

self.match(".*")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DOTSTAR"

# $ANTLR start "DOUBLE"

def mDOUBLE(self, ):

try:

_type = DOUBLE

_channel = DEFAULT_CHANNEL

# Java.g:32:8: ( 'double' )

# Java.g:32:10: 'double'

pass

self.match("double")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DOUBLE"

# $ANTLR start "ELLIPSIS"

def mELLIPSIS(self, ):

try:

_type = ELLIPSIS

_channel = DEFAULT_CHANNEL

# Java.g:33:10: ( '...' )

# Java.g:33:12: '...'

pass

self.match("...")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ELLIPSIS"

# $ANTLR start "ELSE"

def mELSE(self, ):

try:

_type = ELSE

_channel = DEFAULT_CHANNEL

# Java.g:34:6: ( 'else' )

# Java.g:34:8: 'else'

pass

self.match("else")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ELSE"

# $ANTLR start "ENUM"

def mENUM(self, ):

try:

_type = ENUM

_channel = DEFAULT_CHANNEL

# Java.g:35:6: ( 'enum' )

# Java.g:35:8: 'enum'

pass

self.match("enum")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ENUM"

# $ANTLR start "EQUAL"

def mEQUAL(self, ):

try:

_type = EQUAL

_channel = DEFAULT_CHANNEL

# Java.g:36:7: ( '==' )

# Java.g:36:9: '=='

pass

self.match("==")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "EQUAL"

# $ANTLR start "EXTENDS"

def mEXTENDS(self, ):

try:

_type = EXTENDS

_channel = DEFAULT_CHANNEL

# Java.g:37:9: ( 'extends' )

# Java.g:37:11: 'extends'

pass

self.match("extends")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "EXTENDS"

# $ANTLR start "FALSE"

def mFALSE(self, ):

try:

_type = FALSE

_channel = DEFAULT_CHANNEL

# Java.g:38:7: ( 'false' )

# Java.g:38:9: 'false'

pass

self.match("false")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "FALSE"

# $ANTLR start "FINAL"

def mFINAL(self, ):

try:

_type = FINAL

_channel = DEFAULT_CHANNEL

# Java.g:39:7: ( 'final' )

# Java.g:39:9: 'final'

pass

self.match("final")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "FINAL"

# $ANTLR start "FINALLY"

def mFINALLY(self, ):

try:

_type = FINALLY

_channel = DEFAULT_CHANNEL

# Java.g:40:9: ( 'finally' )

# Java.g:40:11: 'finally'

pass

self.match("finally")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "FINALLY"

# $ANTLR start "FLOAT"

def mFLOAT(self, ):