# $ANTLR 3.1.3 Mar 18, 2009 10:09:25 Java.g 2012-01-29 13:54:05 import sys from antlr3 import * from antlr3.compat import set, frozenset # 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:50:15: '>>' pass self.match(">>") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SHIFT_RIGHT" # $ANTLR start "SHIFT_RIGHT_ASSIGN" def mSHIFT_RIGHT_ASSIGN(self, ): try: _type = SHIFT_RIGHT_ASSIGN _channel = DEFAULT_CHANNEL # Java.g:51:20: ( '>>=' ) # Java.g:51:22: '>>=' pass self.match(">>=") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SHIFT_RIGHT_ASSIGN" # $ANTLR start "STAR" def mSTAR(self, ): try: _type = STAR _channel = DEFAULT_CHANNEL # Java.g:52:6: ( '*' ) # Java.g:52:8: '*' pass self.match(42) self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "STAR" # $ANTLR start "STAR_ASSIGN" def mSTAR_ASSIGN(self, ): try: _type = STAR_ASSIGN _channel = DEFAULT_CHANNEL # Java.g:53:13: ( '*=' ) # Java.g:53:15: '*=' pass self.match("*=") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "STAR_ASSIGN" # $ANTLR start "XOR" def mXOR(self, ): try: _type = XOR _channel = DEFAULT_CHANNEL # Java.g:54:5: ( '^' ) # Java.g:54:7: '^' pass self.match(94) self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "XOR" # $ANTLR start "XOR_ASSIGN" def mXOR_ASSIGN(self, ): try: _type = XOR_ASSIGN _channel = DEFAULT_CHANNEL # Java.g:55:12: ( '^=' ) # Java.g:55:14: '^=' pass self.match("^=") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "XOR_ASSIGN" # $ANTLR start "ABSTRACT" def mABSTRACT(self, ): try: _type = ABSTRACT _channel = DEFAULT_CHANNEL # Java.g:56:10: ( 'abstract' ) # Java.g:56:12: 'abstract' pass self.match("abstract") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "ABSTRACT" # $ANTLR start "ASSERT" def mASSERT(self, ): try: _type = ASSERT _channel = DEFAULT_CHANNEL # Java.g:57:8: ( 'assert' ) # Java.g:57:10: 'assert' pass self.match("assert") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "ASSERT" # $ANTLR start "BOOLEAN" def mBOOLEAN(self, ): try: _type = BOOLEAN _channel = DEFAULT_CHANNEL # Java.g:58:9: ( 'boolean' ) # Java.g:58: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:59:7: ( 'break' ) # Java.g:59: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:60:6: ( 'byte' ) # Java.g:60: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:61:6: ( 'case' ) # Java.g:61: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:62:7: ( 'catch' ) # Java.g:62: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:63:6: ( 'char' ) # Java.g:63: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:64:7: ( 'class' ) # Java.g:64:9: 'class' pass self.match("class") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "CLASS" # $ANTLR start "CONTINUE" def mCONTINUE(self, ): try: _type = CONTINUE _channel = DEFAULT_CHANNEL # Java.g:65:10: ( 'continue' ) # Java.g:65:12: 'continue' pass self.match("continue") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "CONTINUE" # $ANTLR start "DEFAULT" def mDEFAULT(self, ): try: _type = DEFAULT _channel = DEFAULT_CHANNEL # Java.g:66:9: ( 'default' ) # Java.g:66:11: 'default' pass self.match("default") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "DEFAULT" # $ANTLR start "DO" def mDO(self, ): try: _type = DO _channel = DEFAULT_CHANNEL # Java.g:67:4: ( 'do' ) # Java.g:67:6: 'do' pass self.match("do") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "DO" # $ANTLR start "DOUBLE" def mDOUBLE(self, ): try: _type = DOUBLE _channel = DEFAULT_CHANNEL # Java.g:68:8: ( 'double' ) # Java.g:68:10: 'double' pass self.match("double") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "DOUBLE" # $ANTLR start "ELSE" def mELSE(self, ): try: _type = ELSE _channel = DEFAULT_CHANNEL # Java.g:69:6: ( 'else' ) # Java.g:69: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:70:6: ( 'enum' ) # Java.g:70:8: 'enum' pass self.match("enum") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "ENUM" # $ANTLR start "EXTENDS" def mEXTENDS(self, ): try: _type = EXTENDS _channel = DEFAULT_CHANNEL # Java.g:71:9: ( 'extends' ) # Java.g:71: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:72:7: ( 'false' ) # Java.g:72: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:73:7: ( 'final' ) # Java.g:73: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:74:9: ( 'finally' ) # Java.g:74: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, ): try: _type = FLOAT _channel = DEFAULT_CHANNEL # Java.g:75:7: ( 'float' ) # Java.g:75:9: 'float' pass self.match("float") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "FLOAT" # $ANTLR start "FOR" def mFOR(self, ): try: _type = FOR _channel = DEFAULT_CHANNEL # Java.g:76:5: ( 'for' ) # Java.g:76:7: 'for' pass self.match("for") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "FOR" # $ANTLR start "IF" def mIF(self, ): try: _type = IF _channel = DEFAULT_CHANNEL # Java.g:77:4: ( 'if' ) # Java.g:77:6: 'if' pass self.match("if") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "IF" # $ANTLR start "IMPLEMENTS" def mIMPLEMENTS(self, ): try: _type = IMPLEMENTS _channel = DEFAULT_CHANNEL # Java.g:78:12: ( 'implements' ) # Java.g:78:14: 'implements' pass self.match("implements") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "IMPLEMENTS" # $ANTLR start "INSTANCEOF" def mINSTANCEOF(self, ): try: _type = INSTANCEOF _channel = DEFAULT_CHANNEL # Java.g:79:12: ( 'instanceof' ) # Java.g:79:14: 'instanceof' pass self.match("instanceof") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "INSTANCEOF" # $ANTLR start "INTERFACE" def mINTERFACE(self, ): try: _type = INTERFACE _channel = DEFAULT_CHANNEL # Java.g:80:11: ( 'interface' ) # Java.g:80:13: 'interface' pass self.match("interface") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "INTERFACE" # $ANTLR start "IMPORT" def mIMPORT(self, ): try: _type = IMPORT _channel = DEFAULT_CHANNEL # Java.g:81:8: ( 'import' ) # Java.g:81:10: 'import' pass self.match("import") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "IMPORT" # $ANTLR start "INT" def mINT(self, ): try: _type = INT _channel = DEFAULT_CHANNEL # Java.g:82:5: ( 'int' ) # Java.g:82:7: 'int' pass self.match("int") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "INT" # $ANTLR start "LONG" def mLONG(self, ): try: _type = LONG _channel = DEFAULT_CHANNEL # Java.g:83:6: ( 'long' ) # Java.g:83:8: 'long' pass self.match("long") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "LONG" # $ANTLR start "NATIVE" def mNATIVE(self, ): try: _type = NATIVE _channel = DEFAULT_CHANNEL # Java.g:84:8: ( 'native' ) # Java.g:84:10: 'native' pass self.match("native") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "NATIVE" # $ANTLR start "NEW" def mNEW(self, ): try: _type = NEW _channel = DEFAULT_CHANNEL # Java.g:85:5: ( 'new' ) # Java.g:85:7: 'new' pass self.match("new") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "NEW" # $ANTLR start "NULL" def mNULL(self, ): try: _type = NULL _channel = DEFAULT_CHANNEL # Java.g:86:6: ( 'null' ) # Java.g:86:8: 'null' pass self.match("null") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "NULL" # $ANTLR start "PACKAGE" def mPACKAGE(self, ): try: _type = PACKAGE _channel = DEFAULT_CHANNEL # Java.g:87:9: ( 'package' ) # Java.g:87:11: 'package' pass self.match("package") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "PACKAGE" # $ANTLR start "PRIVATE" def mPRIVATE(self, ): try: _type = PRIVATE _channel = DEFAULT_CHANNEL # Java.g:88:9: ( 'private' ) # Java.g:88:11: 'private' pass self.match("private") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "PRIVATE" # $ANTLR start "PROTECTED" def mPROTECTED(self, ): try: _type = PROTECTED _channel = DEFAULT_CHANNEL # Java.g:89:11: ( 'protected' ) # Java.g:89:13: 'protected' pass self.match("protected") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "PROTECTED" # $ANTLR start "PUBLIC" def mPUBLIC(self, ): try: _type = PUBLIC _channel = DEFAULT_CHANNEL # Java.g:90:8: ( 'public' ) # Java.g:90:10: 'public' pass self.match("public") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "PUBLIC" # $ANTLR start "RETURN" def mRETURN(self, ): try: _type = RETURN _channel = DEFAULT_CHANNEL # Java.g:91:8: ( 'return' ) # Java.g:91:10: 'return' pass self.match("return") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "RETURN" # $ANTLR start "SHORT" def mSHORT(self, ): try: _type = SHORT _channel = DEFAULT_CHANNEL # Java.g:92:7: ( 'short' ) # Java.g:92:9: 'short' pass self.match("short") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SHORT" # $ANTLR start "STATIC" def mSTATIC(self, ): try: _type = STATIC _channel = DEFAULT_CHANNEL # Java.g:93:8: ( 'static' ) # Java.g:93:10: 'static' pass self.match("static") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "STATIC" # $ANTLR start "STRICTFP" def mSTRICTFP(self, ): try: _type = STRICTFP _channel = DEFAULT_CHANNEL # Java.g:94:10: ( 'strictfp' ) # Java.g:94:12: 'strictfp' pass self.match("strictfp") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "STRICTFP" # $ANTLR start "SUPER" def mSUPER(self, ): try: _type = SUPER _channel = DEFAULT_CHANNEL # Java.g:95:7: ( 'super' ) # Java.g:95:9: 'super' pass self.match("super") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SUPER" # $ANTLR start "SWITCH" def mSWITCH(self, ): try: _type = SWITCH _channel = DEFAULT_CHANNEL # Java.g:96:8: ( 'switch' ) # Java.g:96:10: 'switch' pass self.match("switch") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SWITCH" # $ANTLR start "SYNCHRONIZED" def mSYNCHRONIZED(self, ): try: _type = SYNCHRONIZED _channel = DEFAULT_CHANNEL # Java.g:97:14: ( 'synchronized' ) # Java.g:97:16: 'synchronized' pass self.match("synchronized") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "SYNCHRONIZED" # $ANTLR start "THIS" def mTHIS(self, ): try: _type = THIS _channel = DEFAULT_CHANNEL # Java.g:98:6: ( 'this' ) # Java.g:98:8: 'this' pass self.match("this") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "THIS" # $ANTLR start "THROW" def mTHROW(self, ): try: _type = THROW _channel = DEFAULT_CHANNEL # Java.g:99:7: ( 'throw' ) # Java.g:99:9: 'throw' pass self.match("throw") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "THROW" # $ANTLR start "THROWS" def mTHROWS(self, ): try: _type = THROWS _channel = DEFAULT_CHANNEL # Java.g:100:8: ( 'throws' ) # Java.g:100:10: 'throws' pass self.match("throws") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "THROWS" # $ANTLR start "TRANSIENT" def mTRANSIENT(self, ): try: _type = TRANSIENT _channel = DEFAULT_CHANNEL # Java.g:101:11: ( 'transient' ) # Java.g:101:13: 'transient' pass self.match("transient") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "TRANSIENT" # $ANTLR start "TRUE" def mTRUE(self, ): try: _type = TRUE _channel = DEFAULT_CHANNEL # Java.g:102:6: ( 'true' ) # Java.g:102:8: 'true' pass self.match("true") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "TRUE" # $ANTLR start "TRY" def mTRY(self, ): try: _type = TRY _channel = DEFAULT_CHANNEL # Java.g:103:5: ( 'try' ) # Java.g:103:7: 'try' pass self.match("try") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "TRY" # $ANTLR start "VOID" def mVOID(self, ): try: _type = VOID _channel = DEFAULT_CHANNEL # Java.g:104:6: ( 'void' ) # Java.g:104:8: 'void' pass self.match("void") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "VOID" # $ANTLR start "VOLATILE" def mVOLATILE(self, ): try: _type = VOLATILE _channel = DEFAULT_CHANNEL # Java.g:105:10: ( 'volatile' ) # Java.g:105:12: 'volatile' pass self.match("volatile") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "VOLATILE" # $ANTLR start "WHILE" def mWHILE(self, ): try: _type = WHILE _channel = DEFAULT_CHANNEL # Java.g:106:7: ( 'while' ) # Java.g:106:9: 'while' pass self.match("while") self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "WHILE" # $ANTLR start "HEX_LITERAL" def mHEX_LITERAL(self, ): try: _type = HEX_LITERAL _channel = DEFAULT_CHANNEL # Java.g:985:13: ( '0' ( 'x' | 'X' ) ( HEX_DIGIT )+ ( INTEGER_TYPE_SUFFIX )? ) # Java.g:985:15: '0' ( 'x' | 'X' ) ( HEX_DIGIT )+ ( INTEGER_TYPE_SUFFIX )? pass self.match(48) if self.input.LA(1) == 88 or self.input.LA(1) == 120: self.input.consume() else: mse = MismatchedSetException(None, self.input) self.recover(mse) raise mse # Java.g:985:29: ( HEX_DIGIT )+ cnt1 = 0 while True: #loop1 alt1 = 2 LA1_0 = self.input.LA(1) if ((48 = 1: break #loop1 eee = EarlyExitException(1, self.input) raise eee cnt1 += 1 # Java.g:985:40: ( INTEGER_TYPE_SUFFIX )? alt2 = 2 LA2_0 = self.input.LA(1) if (LA2_0 == 76 or LA2_0 == 108) : alt2 = 1 if alt2 == 1: # Java.g:985:40: INTEGER_TYPE_SUFFIX pass self.mINTEGER_TYPE_SUFFIX() self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "HEX_LITERAL" # $ANTLR start "DECIMAL_LITERAL" def mDECIMAL_LITERAL(self, ): try: _type = DECIMAL_LITERAL _channel = DEFAULT_CHANNEL # Java.g:987:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( INTEGER_TYPE_SUFFIX )? ) # Java.g:987:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( INTEGER_TYPE_SUFFIX )? pass # Java.g:987:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) alt4 = 2 LA4_0 = self.input.LA(1) if (LA4_0 == 48) : alt4 = 1 elif ((49 = 1: break #loop6 eee = EarlyExitException(6, self.input) raise eee cnt6 += 1 # Java.g:989:33: ( INTEGER_TYPE_SUFFIX )? alt7 = 2 LA7_0 = self.input.LA(1) if (LA7_0 == 76 or LA7_0 == 108) : alt7 = 1 if alt7 == 1: # Java.g:989:33: INTEGER_TYPE_SUFFIX pass self.mINTEGER_TYPE_SUFFIX() self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "OCTAL_LITERAL" # $ANTLR start "HEX_DIGIT" def mHEX_DIGIT(self, ): try: # Java.g:992:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ) # Java.g:992:13: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) pass if (48 = 1: break #loop8 eee = EarlyExitException(8, self.input) raise eee cnt8 += 1 # Java.g:999:9: ( DOT ( '0' .. '9' )* ( EXPONENT )? ( FLOAT_TYPE_SUFFIX )? | EXPONENT ( FLOAT_TYPE_SUFFIX )? | FLOAT_TYPE_SUFFIX ) alt13 = 3 LA13 = self.input.LA(1) if LA13 == 46: alt13 = 1 elif LA13 == 69 or LA13 == 101: alt13 = 2 elif LA13 == 68 or LA13 == 70 or LA13 == 100 or LA13 == 102: alt13 = 3 else: nvae = NoViableAltException("", 13, 0, self.input) raise nvae if alt13 == 1: # Java.g:1000:13: DOT ( '0' .. '9' )* ( EXPONENT )? ( FLOAT_TYPE_SUFFIX )? pass self.mDOT() # Java.g:1000:17: ( '0' .. '9' )* while True: #loop9 alt9 = 2 LA9_0 = self.input.LA(1) if ((48 = 1: break #loop14 eee = EarlyExitException(14, self.input) raise eee cnt14 += 1 # Java.g:1004:25: ( EXPONENT )? alt15 = 2 LA15_0 = self.input.LA(1) if (LA15_0 == 69 or LA15_0 == 101) : alt15 = 1 if alt15 == 1: # Java.g:1004:25: EXPONENT pass self.mEXPONENT() # Java.g:1004:35: ( FLOAT_TYPE_SUFFIX )? alt16 = 2 LA16_0 = self.input.LA(1) if (LA16_0 == 68 or LA16_0 == 70 or LA16_0 == 100 or LA16_0 == 102) : alt16 = 1 if alt16 == 1: # Java.g:1004:35: FLOAT_TYPE_SUFFIX pass self.mFLOAT_TYPE_SUFFIX() self._state.type = _type self._state.channel = _channel finally: pass # $ANTLR end "FLOATING_POINT_LITERAL" # $ANTLR start "EXPONENT" def mEXPONENT(self, ): try: # Java.g:1008:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ) # Java.g:1008:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ pass if self.input.LA(1) == 69 or self.input.LA(1) == 101: self.input.consume() else: mse = MismatchedSetException(None, self.input) self.recover(mse) raise mse # Java.g:1008:22: ( '+' | '-' )? alt18 = 2 LA18_0 = self.input.LA(1) if (LA18_0 == 43 or LA18_0 == 45) : alt18 = 1 if alt18 == 1: # Java.g: pass if self.input.LA(1) == 43 or self.input.LA(1) == 45: self.input.consume() else: mse = MismatchedSetException(None, self.input) self.recover(mse) raise mse # Java.g:1008:33: ( '0' .. '9' )+ cnt19 = 0 while True: #loop19 alt19 = 2 LA19_0 = self.input.LA(1) if ((48 = 1: break #loop19 eee = EarlyExitException(19, self.input) raise eee cnt19 += 1 finally: pass # $ANTLR end "EXPONENT" # $ANTLR start "FLOAT_TYPE_SUFFIX" def mFLOAT_TYPE_SUFFIX(self, ): try: # Java.g:1011:19: ( ( 'f' | 'F' | 'd' | 'D' ) ) # Java.g:1011:21: ( 'f' | 'F' | 'd' | 'D' ) pass if self.input.LA(1) == 68 or self.input.LA(1) == 70 or self.input.LA(1) == 100 or self.input.LA(1) == 102: self.input.consume() else: mse = MismatchedSetException(None, self.input) self.recover(mse) raise mse finally: pass # $ANTLR end "FLOAT_TYPE_SUFFIX" # $ANTLR start "CHARACTER_LITERAL" def mCHARACTER_LITERAL(self, ): try: _type = CHARACTER_LITERAL _channel = DEFAULT_CHANNEL # Java.g:1014:5: ( '\\'' ( ESCAPE_SEQUENCE | ~ ( '\\'' | '\\\\' ) ) '\\'' ) # Java.g:1014:9: '\\'' ( ESCAPE_SEQUENCE | ~ ( '\\'' | '\\\\' ) ) '\\'' pass self.match(39) # Java.g:1014:14: ( ESCAPE_SEQUENCE | ~ ( '\\'' | '\\\\' ) ) alt20 = 2 LA20_0 = self.input.LA(1) if (LA20_0 == 92) : alt20 = 1 elif ((0 = 0: return s nvae = NoViableAltException(self_.getDescription(), 29, _s, input) self_.error(nvae) raise nvae def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr): from antlr3.main import LexerMain main = LexerMain(JavaLexer) main.stdin = stdin main.stdout = stdout main.stderr = stderr main.execute(argv) if __name__ == '__main__': main(sys.argv)