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

import re

import sys

from antlr3 import *

from antlr3.compat import set, frozenset

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

BREAK=56

LOGICAL_AND=26

BIT_SHIFT_RIGHT_ASSIGN=9

UNARY_PLUS=159

TYPE=157

FINAL=70

INC=21

RPAREN=43

IMPORT=78

STRING_LITERAL=170

FOR_UPDATE=132

FLOATING_POINT_LITERAL=168

CAST_EXPR=118

NOT_EQUAL=35

VOID_METHOD_DECL=163

RETURN=88

THIS=95

DOUBLE=65

VOID=101

ENUM_TOP_LEVEL_SCOPE=125

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

PROTECTED=86

DEC=12

CLASS=61

LBRACK=22

BIT_SHIFT_RIGHT=8

THROWS_CLAUSE=156

GREATER_OR_EQUAL=19

FOR=73

LOGICAL_NOT=27

THIS_CONSTRUCTOR_CALL=155

FLOAT=72

JAVADOC_COMMENT=183

ABSTRACT=53

AND=4

POST_DEC=147

AND_ASSIGN=5

ANNOTATION_SCOPE=110

MODIFIER_LIST=145

STATIC_ARRAY_CREATOR=152

LPAREN=29

IF=74

AT=7

CONSTRUCTOR_DECL=124

ESCAPE_SEQUENCE=175

LABELED_STATEMENT=141

UNICODE_ESCAPE=176

BOOLEAN=55

SYNCHRONIZED=94

EXPR=126

CLASS_TOP_LEVEL_SCOPE=123

IMPLEMENTS=75

CONTINUE=62

COMMA=11

TRANSIENT=98

XOR_ASSIGN=52

EQUAL=18

LOGICAL_OR=28

ARGUMENT_LIST=112

QUALIFIED_TYPE_IDENT=151

IDENT=164

PLUS=38

ANNOTATION_INIT_BLOCK=105

HEX_LITERAL=165

DOT=15

SHIFT_LEFT_ASSIGN=46

FORMAL_PARAM_LIST=133

GENERIC_TYPE_ARG_LIST=137

DOTSTAR=16

ANNOTATION_TOP_LEVEL_SCOPE=111

BYTE=57

XOR=51

JAVA_ID_PART=179

GREATER_THAN=20

VOLATILE=102

PARENTESIZED_EXPR=146

LESS_OR_EQUAL=24

ARRAY_DECLARATOR_LIST=114

CLASS_STATIC_INITIALIZER=122

DEFAULT=63

OCTAL_LITERAL=166

HEX_DIGIT=171

SHORT=89

INSTANCEOF=76

MINUS=30

SEMI=44

TRUE=99

EXTENDS_CLAUSE=128

STAR_ASSIGN=50

VAR_DECLARATOR_LIST=162

COLON=10

ARRAY_DECLARATOR=113

OR_ASSIGN=37

ENUM=67

QUESTION=40

FINALLY=71

RCURLY=42

ASSIGN=6

PLUS_ASSIGN=39

ANNOTATION_INIT_ARRAY_ELEMENT=104

FUNCTION_METHOD_DECL=136

INTERFACE=77

DIV=13

POST_INC=148

LONG=80

CLASS_CONSTRUCTOR_CALL=120

PUBLIC=87

EXTENDS=68

FOR_EACH=130

ARRAY_INITIALIZER=116

CATCH_CLAUSE_LIST=119

SUPER_CONSTRUCTOR_CALL=153

class JavaLexer(Lexer):

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"

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

if state is None:

state = RecognizerSharedState()

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

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 "AND"

def mAND(self, ):

try:

_type = AND

_channel = DEFAULT_CHANNEL

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

# Java.g:7: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:8:12: ( '&=' )

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

pass

self.match("&=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "AND_ASSIGN"

# $ANTLR start "ASSIGN"

def mASSIGN(self, ):

try:

_type = ASSIGN

_channel = DEFAULT_CHANNEL

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

# Java.g:9: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:10:4: ( '@' )

# Java.g:10: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:11:17: ( '>>>' )

# Java.g:11: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:12:24: ( '>>>=' )

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

pass

self.match(">>>=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "BIT_SHIFT_RIGHT_ASSIGN"

# $ANTLR start "COLON"

def mCOLON(self, ):

try:

_type = COLON

_channel = DEFAULT_CHANNEL

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

# Java.g:13: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:14:7: ( ',' )

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

pass

self.match(44)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "COMMA"

# $ANTLR start "DEC"

def mDEC(self, ):

try:

_type = DEC

_channel = DEFAULT_CHANNEL

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

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

pass

self.match("--")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DEC"

# $ANTLR start "DIV"

def mDIV(self, ):

try:

_type = DIV

_channel = DEFAULT_CHANNEL

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

# Java.g:16: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:17:12: ( '/=' )

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

pass

self.match("/=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DIV_ASSIGN"

# $ANTLR start "DOT"

def mDOT(self, ):

try:

_type = DOT

_channel = DEFAULT_CHANNEL

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

# Java.g:18: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:19:9: ( '.*' )

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

pass

self.match(".*")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "DOTSTAR"

# $ANTLR start "ELLIPSIS"

def mELLIPSIS(self, ):

try:

_type = ELLIPSIS

_channel = DEFAULT_CHANNEL

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

# Java.g:20:12: '...'

pass

self.match("...")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "ELLIPSIS"

# $ANTLR start "EQUAL"

def mEQUAL(self, ):

try:

_type = EQUAL

_channel = DEFAULT_CHANNEL

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

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

pass

self.match("==")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "EQUAL"

# $ANTLR start "GREATER_OR_EQUAL"

def mGREATER_OR_EQUAL(self, ):

try:

_type = GREATER_OR_EQUAL

_channel = DEFAULT_CHANNEL

# Java.g:22:18: ( '>=' )

# Java.g:22:20: '>='

pass

self.match(">=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "GREATER_OR_EQUAL"

# $ANTLR start "GREATER_THAN"

def mGREATER_THAN(self, ):

try:

_type = GREATER_THAN

_channel = DEFAULT_CHANNEL

# Java.g:23:14: ( '>' )

# Java.g:23:16: '>'

pass

self.match(62)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "GREATER_THAN"

# $ANTLR start "INC"

def mINC(self, ):

try:

_type = INC

_channel = DEFAULT_CHANNEL

# Java.g:24:5: ( '++' )

# Java.g:24:7: '++'

pass

self.match("++")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "INC"

# $ANTLR start "LBRACK"

def mLBRACK(self, ):

try:

_type = LBRACK

_channel = DEFAULT_CHANNEL

# Java.g:25:8: ( '[' )

# Java.g:25:10: '['

pass

self.match(91)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LBRACK"

# $ANTLR start "LCURLY"

def mLCURLY(self, ):

try:

_type = LCURLY

_channel = DEFAULT_CHANNEL

# Java.g:26:8: ( '{' )

# Java.g:26:10: '{'

pass

self.match(123)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LCURLY"

# $ANTLR start "LESS_OR_EQUAL"

def mLESS_OR_EQUAL(self, ):

try:

_type = LESS_OR_EQUAL

_channel = DEFAULT_CHANNEL

# Java.g:27:15: ( '<=' )

# Java.g:27:17: '<='

pass

self.match("<=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LESS_OR_EQUAL"

# $ANTLR start "LESS_THAN"

def mLESS_THAN(self, ):

try:

_type = LESS_THAN

_channel = DEFAULT_CHANNEL

# Java.g:28:11: ( '<' )

# Java.g:28:13: '<'

pass

self.match(60)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LESS_THAN"

# $ANTLR start "LOGICAL_AND"

def mLOGICAL_AND(self, ):

try:

_type = LOGICAL_AND

_channel = DEFAULT_CHANNEL

# Java.g:29:13: ( '&&' )

# Java.g:29:15: '&&'

pass

self.match("&&")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LOGICAL_AND"

# $ANTLR start "LOGICAL_NOT"

def mLOGICAL_NOT(self, ):

try:

_type = LOGICAL_NOT

_channel = DEFAULT_CHANNEL

# Java.g:30:13: ( '!' )

# Java.g:30:15: '!'

pass

self.match(33)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LOGICAL_NOT"

# $ANTLR start "LOGICAL_OR"

def mLOGICAL_OR(self, ):

try:

_type = LOGICAL_OR

_channel = DEFAULT_CHANNEL

# Java.g:31:12: ( '||' )

# Java.g:31:14: '||'

pass

self.match("||")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LOGICAL_OR"

# $ANTLR start "LPAREN"

def mLPAREN(self, ):

try:

_type = LPAREN

_channel = DEFAULT_CHANNEL

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

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

pass

self.match(40)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "LPAREN"

# $ANTLR start "MINUS"

def mMINUS(self, ):

try:

_type = MINUS

_channel = DEFAULT_CHANNEL

# Java.g:33:7: ( '-' )

# Java.g:33:9: '-'

pass

self.match(45)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "MINUS"

# $ANTLR start "MINUS_ASSIGN"

def mMINUS_ASSIGN(self, ):

try:

_type = MINUS_ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:34:14: ( '-=' )

# Java.g:34:16: '-='

pass

self.match("-=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "MINUS_ASSIGN"

# $ANTLR start "MOD"

def mMOD(self, ):

try:

_type = MOD

_channel = DEFAULT_CHANNEL

# Java.g:35:5: ( '%' )

# Java.g:35:7: '%'

pass

self.match(37)

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "MOD"

# $ANTLR start "MOD_ASSIGN"

def mMOD_ASSIGN(self, ):

try:

_type = MOD_ASSIGN

_channel = DEFAULT_CHANNEL

# Java.g:36:12: ( '%=' )

# Java.g:36:14: '%='

pass

self.match("%=")

self._state.type = _type

self._state.channel = _channel

finally:

pass

# $ANTLR end "MOD_ASSIGN"

# $ANTLR start "NOT"

def mNOT(self, ):

try:

_type = NOT

_channel = DEFAULT_CHANNEL

# Java.g:37:5: ( '~' )

# Java.g:37:7: '~'

pass

self.match(126)

self._state.type = _type

self._state.channel = _channel

finally:

pass