00001
00002
#include "JavaLexer.hpp"
00003
#include <antlr/CharBuffer.hpp>
00004
#include <antlr/TokenStreamException.hpp>
00005
#include <antlr/TokenStreamIOException.hpp>
00006
#include <antlr/TokenStreamRecognitionException.hpp>
00007
#include <antlr/CharStreamException.hpp>
00008
#include <antlr/CharStreamIOException.hpp>
00009
#include <antlr/NoViableAltForCharException.hpp>
00010
00011
#line 1041 "java.g"
00012
00013
#include <string>
00014
00015
#line 16 "JavaLexer.cpp"
00016 JavaLexer::JavaLexer(
ANTLR_USE_NAMESPACE(std)istream& in)
00017 :
ANTLR_USE_NAMESPACE(antlr)
CharScanner(new
ANTLR_USE_NAMESPACE(antlr)
CharBuffer(in),true)
00018 {
00019
initLiterals();
00020 }
00021
00022 JavaLexer::JavaLexer(
ANTLR_USE_NAMESPACE(antlr)
InputBuffer& ib)
00023 :
ANTLR_USE_NAMESPACE(antlr)
CharScanner(ib,true)
00024 {
00025
initLiterals();
00026 }
00027
00028 JavaLexer::JavaLexer(
const ANTLR_USE_NAMESPACE(antlr)
LexerSharedInputState& state)
00029 :
ANTLR_USE_NAMESPACE(antlr)
CharScanner(state,true)
00030 {
00031
initLiterals();
00032 }
00033
00034 void JavaLexer::initLiterals()
00035 {
00036 literals[
"byte"] = 51;
00037 literals[
"public"] = 62;
00038 literals[
"case"] = 94;
00039 literals[
"short"] = 53;
00040 literals[
"break"] = 89;
00041 literals[
"while"] = 87;
00042 literals[
"new"] = 137;
00043 literals[
"instanceof"] = 122;
00044 literals[
"implements"] = 76;
00045 literals[
"synchronized"] = 68;
00046 literals[
"float"] = 55;
00047 literals[
"package"] = 44;
00048 literals[
"return"] = 91;
00049 literals[
"throw"] = 93;
00050 literals[
"null"] = 136;
00051 literals[
"threadsafe"] = 67;
00052 literals[
"protected"] = 63;
00053 literals[
"class"] = 70;
00054 literals[
"throws"] = 82;
00055 literals[
"do"] = 88;
00056 literals[
"strictfp"] = 41;
00057 literals[
"super"] = 80;
00058 literals[
"transient"] = 65;
00059 literals[
"native"] = 66;
00060 literals[
"interface"] = 72;
00061 literals[
"final"] = 39;
00062 literals[
"if"] = 84;
00063 literals[
"double"] = 57;
00064 literals[
"volatile"] = 69;
00065 literals[
"catch"] = 98;
00066 literals[
"try"] = 96;
00067 literals[
"int"] = 54;
00068 literals[
"for"] = 86;
00069 literals[
"extends"] = 71;
00070 literals[
"boolean"] = 50;
00071 literals[
"char"] = 52;
00072 literals[
"private"] = 61;
00073 literals[
"default"] = 95;
00074 literals[
"false"] = 135;
00075 literals[
"this"] = 79;
00076 literals[
"static"] = 64;
00077 literals[
"abstract"] = 40;
00078 literals[
"continue"] = 90;
00079 literals[
"finally"] = 97;
00080 literals[
"else"] = 85;
00081 literals[
"import"] = 46;
00082 literals[
"void"] = 49;
00083 literals[
"switch"] = 92;
00084 literals[
"true"] = 134;
00085 literals[
"long"] = 56;
00086 }
00087
00088 ANTLR_USE_NAMESPACE(antlr)
RefToken JavaLexer::nextToken()
00089 {
00090
ANTLR_USE_NAMESPACE(antlr)
RefToken theRetToken;
00091
for (;;) {
00092
ANTLR_USE_NAMESPACE(antlr)
RefToken theRetToken;
00093
int _ttype =
ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
00094 resetText();
00095
try {
00096
switch ( LA(1)) {
00097
case static_cast<unsigned char>(
'?'):
00098 {
00099 mQUESTION(
true);
00100 theRetToken=_returnToken;
00101
break;
00102 }
00103
case static_cast<unsigned char>(
'('):
00104 {
00105 mLPAREN(
true);
00106 theRetToken=_returnToken;
00107
break;
00108 }
00109
case static_cast<unsigned char>(
')'):
00110 {
00111 mRPAREN(
true);
00112 theRetToken=_returnToken;
00113
break;
00114 }
00115
case static_cast<unsigned char>(
'['):
00116 {
00117 mLBRACK(
true);
00118 theRetToken=_returnToken;
00119
break;
00120 }
00121
case static_cast<unsigned char>(
']'):
00122 {
00123 mRBRACK(
true);
00124 theRetToken=_returnToken;
00125
break;
00126 }
00127
case static_cast<unsigned char>(
'{'):
00128 {
00129 mLCURLY(
true);
00130 theRetToken=_returnToken;
00131
break;
00132 }
00133
case static_cast<unsigned char>(
'}'):
00134 {
00135 mRCURLY(
true);
00136 theRetToken=_returnToken;
00137
break;
00138 }
00139
case static_cast<unsigned char>(
':'):
00140 {
00141 mCOLON(
true);
00142 theRetToken=_returnToken;
00143
break;
00144 }
00145
case static_cast<unsigned char>(
','):
00146 {
00147 mCOMMA(
true);
00148 theRetToken=_returnToken;
00149
break;
00150 }
00151
case static_cast<unsigned char>(
'~'):
00152 {
00153 mBNOT(
true);
00154 theRetToken=_returnToken;
00155
break;
00156 }
00157
case static_cast<unsigned char>(
';'):
00158 {
00159 mSEMI(
true);
00160 theRetToken=_returnToken;
00161
break;
00162 }
00163
case static_cast<unsigned char>(
'\t'):
00164
case static_cast<unsigned char>(
'\n'):
00165
case static_cast<unsigned char>('\14'):
00166
case static_cast<unsigned char>(
'\r'):
00167
case static_cast<unsigned char>(
' '):
00168 {
00169 mWS(
true);
00170 theRetToken=_returnToken;
00171
break;
00172 }
00173
case static_cast<unsigned char>(
'\''):
00174 {
00175 mCHAR_LITERAL(
true);
00176 theRetToken=_returnToken;
00177
break;
00178 }
00179
case static_cast<unsigned char>(
'"'):
00180 {
00181 mSTRING_LITERAL(
true);
00182 theRetToken=_returnToken;
00183
break;
00184 }
00185
case static_cast<unsigned char>(
'$'):
00186
case static_cast<unsigned char>(
'A'):
00187
case static_cast<unsigned char>(
'B'):
00188
case static_cast<unsigned char>(
'C'):
00189
case static_cast<unsigned char>(
'D'):
00190
case static_cast<unsigned char>(
'E'):
00191
case static_cast<unsigned char>(
'F'):
00192
case static_cast<unsigned char>(
'G'):
00193
case static_cast<unsigned char>(
'H'):
00194
case static_cast<unsigned char>(
'I'):
00195
case static_cast<unsigned char>(
'J'):
00196
case static_cast<unsigned char>(
'K'):
00197
case static_cast<unsigned char>(
'L'):
00198
case static_cast<unsigned char>(
'M'):
00199
case static_cast<unsigned char>(
'N'):
00200
case static_cast<unsigned char>(
'O'):
00201
case static_cast<unsigned char>(
'P'):
00202
case static_cast<unsigned char>(
'Q'):
00203
case static_cast<unsigned char>(
'R'):
00204
case static_cast<unsigned char>(
'S'):
00205
case static_cast<unsigned char>(
'T'):
00206
case static_cast<unsigned char>(
'U'):
00207
case static_cast<unsigned char>(
'V'):
00208
case static_cast<unsigned char>(
'W'):
00209
case static_cast<unsigned char>(
'X'):
00210
case static_cast<unsigned char>(
'Y'):
00211
case static_cast<unsigned char>(
'Z'):
00212
case static_cast<unsigned char>(
'_'):
00213
case static_cast<unsigned char>(
'a'):
00214
case static_cast<unsigned char>(
'b'):
00215
case static_cast<unsigned char>(
'c'):
00216
case static_cast<unsigned char>(
'd'):
00217
case static_cast<unsigned char>(
'e'):
00218
case static_cast<unsigned char>(
'f'):
00219
case static_cast<unsigned char>(
'g'):
00220
case static_cast<unsigned char>(
'h'):
00221
case static_cast<unsigned char>(
'i'):
00222
case static_cast<unsigned char>(
'j'):
00223
case static_cast<unsigned char>(
'k'):
00224
case static_cast<unsigned char>(
'l'):
00225
case static_cast<unsigned char>(
'm'):
00226
case static_cast<unsigned char>(
'n'):
00227
case static_cast<unsigned char>(
'o'):
00228
case static_cast<unsigned char>(
'p'):
00229
case static_cast<unsigned char>(
'q'):
00230
case static_cast<unsigned char>(
'r'):
00231
case static_cast<unsigned char>(
's'):
00232
case static_cast<unsigned char>(
't'):
00233
case static_cast<unsigned char>(
'u'):
00234
case static_cast<unsigned char>(
'v'):
00235
case static_cast<unsigned char>(
'w'):
00236
case static_cast<unsigned char>(
'x'):
00237
case static_cast<unsigned char>(
'y'):
00238
case static_cast<unsigned char>(
'z'):
00239 {
00240 mIDENT(
true);
00241 theRetToken=_returnToken;
00242
break;
00243 }
00244
case static_cast<unsigned char>(
'.'):
00245
case static_cast<unsigned char>(
'0'):
00246
case static_cast<unsigned char>(
'1'):
00247
case static_cast<unsigned char>(
'2'):
00248
case static_cast<unsigned char>(
'3'):
00249
case static_cast<unsigned char>(
'4'):
00250
case static_cast<unsigned char>(
'5'):
00251
case static_cast<unsigned char>(
'6'):
00252
case static_cast<unsigned char>(
'7'):
00253
case static_cast<unsigned char>(
'8'):
00254
case static_cast<unsigned char>(
'9'):
00255 {
00256 mNUM_INT(
true);
00257 theRetToken=_returnToken;
00258
break;
00259 }
00260
default:
00261
if ((LA(1) == static_cast<unsigned char>(
'>')) && (LA(2) == static_cast<unsigned char>(
'>')) && (LA(3) == static_cast<unsigned char>(
'>')) && (LA(4) == static_cast<unsigned char>(
'='))) {
00262 mBSR_ASSIGN(
true);
00263 theRetToken=_returnToken;
00264 }
00265
else if ((LA(1) == static_cast<unsigned char>(
'>')) && (LA(2) == static_cast<unsigned char>(
'>')) && (LA(3) == static_cast<unsigned char>(
'='))) {
00266 mSR_ASSIGN(
true);
00267 theRetToken=_returnToken;
00268 }
00269
else if ((LA(1) == static_cast<unsigned char>(
'>')) && (LA(2) == static_cast<unsigned char>(
'>')) && (LA(3) == static_cast<unsigned char>(
'>')) && (
true)) {
00270 mBSR(
true);
00271 theRetToken=_returnToken;
00272 }
00273
else if ((LA(1) == static_cast<unsigned char>(
'<')) && (LA(2) == static_cast<unsigned char>(
'<')) && (LA(3) == static_cast<unsigned char>(
'='))) {
00274 mSL_ASSIGN(
true);
00275 theRetToken=_returnToken;
00276 }
00277
else if ((LA(1) == static_cast<unsigned char>(
'=')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00278 mEQUAL(
true);
00279 theRetToken=_returnToken;
00280 }
00281
else if ((LA(1) == static_cast<unsigned char>(
'!')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00282 mNOT_EQUAL(
true);
00283 theRetToken=_returnToken;
00284 }
00285
else if ((LA(1) == static_cast<unsigned char>(
'/')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00286 mDIV_ASSIGN(
true);
00287 theRetToken=_returnToken;
00288 }
00289
else if ((LA(1) == static_cast<unsigned char>(
'+')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00290 mPLUS_ASSIGN(
true);
00291 theRetToken=_returnToken;
00292 }
00293
else if ((LA(1) == static_cast<unsigned char>(
'+')) && (LA(2) == static_cast<unsigned char>(
'+'))) {
00294 mINC(
true);
00295 theRetToken=_returnToken;
00296 }
00297
else if ((LA(1) == static_cast<unsigned char>(
'-')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00298 mMINUS_ASSIGN(
true);
00299 theRetToken=_returnToken;
00300 }
00301
else if ((LA(1) == static_cast<unsigned char>(
'-')) && (LA(2) == static_cast<unsigned char>(
'-'))) {
00302 mDEC(
true);
00303 theRetToken=_returnToken;
00304 }
00305
else if ((LA(1) == static_cast<unsigned char>(
'*')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00306 mSTAR_ASSIGN(
true);
00307 theRetToken=_returnToken;
00308 }
00309
else if ((LA(1) == static_cast<unsigned char>(
'%')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00310 mMOD_ASSIGN(
true);
00311 theRetToken=_returnToken;
00312 }
00313
else if ((LA(1) == static_cast<unsigned char>(
'>')) && (LA(2) == static_cast<unsigned char>(
'>')) && (
true)) {
00314 mSR(
true);
00315 theRetToken=_returnToken;
00316 }
00317
else if ((LA(1) == static_cast<unsigned char>(
'>')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00318 mGE(
true);
00319 theRetToken=_returnToken;
00320 }
00321
else if ((LA(1) == static_cast<unsigned char>(
'<')) && (LA(2) == static_cast<unsigned char>(
'<')) && (
true)) {
00322 mSL(
true);
00323 theRetToken=_returnToken;
00324 }
00325
else if ((LA(1) == static_cast<unsigned char>(
'<')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00326 mLE(
true);
00327 theRetToken=_returnToken;
00328 }
00329
else if ((LA(1) == static_cast<unsigned char>(
'^')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00330 mBXOR_ASSIGN(
true);
00331 theRetToken=_returnToken;
00332 }
00333
else if ((LA(1) == static_cast<unsigned char>(
'|')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00334 mBOR_ASSIGN(
true);
00335 theRetToken=_returnToken;
00336 }
00337
else if ((LA(1) == static_cast<unsigned char>(
'|')) && (LA(2) == static_cast<unsigned char>(
'|'))) {
00338 mLOR(
true);
00339 theRetToken=_returnToken;
00340 }
00341
else if ((LA(1) == static_cast<unsigned char>(
'&')) && (LA(2) == static_cast<unsigned char>(
'='))) {
00342 mBAND_ASSIGN(
true);
00343 theRetToken=_returnToken;
00344 }
00345
else if ((LA(1) == static_cast<unsigned char>(
'&')) && (LA(2) == static_cast<unsigned char>(
'&'))) {
00346 mLAND(
true);
00347 theRetToken=_returnToken;
00348 }
00349
else if ((LA(1) == static_cast<unsigned char>(
'/')) && (LA(2) == static_cast<unsigned char>(
'/'))) {
00350 mSL_COMMENT(
true);
00351 theRetToken=_returnToken;
00352 }
00353
else if ((LA(1) == static_cast<unsigned char>(
'/')) && (LA(2) == static_cast<unsigned char>(
'*'))) {
00354 mML_COMMENT(
true);
00355 theRetToken=_returnToken;
00356 }
00357
else if ((LA(1) == static_cast<unsigned char>(
'=')) && (
true)) {
00358 mASSIGN(
true);
00359 theRetToken=_returnToken;
00360 }
00361
else if ((LA(1) == static_cast<unsigned char>(
'!')) && (
true)) {
00362 mLNOT(
true);
00363 theRetToken=_returnToken;
00364 }
00365
else if ((LA(1) == static_cast<unsigned char>(
'/')) && (
true)) {
00366 mDIV(
true);
00367 theRetToken=_returnToken;
00368 }
00369
else if ((LA(1) == static_cast<unsigned char>(
'+')) && (
true)) {
00370 mPLUS(
true);
00371 theRetToken=_returnToken;
00372 }
00373
else if ((LA(1) == static_cast<unsigned char>(
'-')) && (
true)) {
00374 mMINUS(
true);
00375 theRetToken=_returnToken;
00376 }
00377
else if ((LA(1) == static_cast<unsigned char>(
'*')) && (
true)) {
00378 mSTAR(
true);
00379 theRetToken=_returnToken;
00380 }
00381
else if ((LA(1) == static_cast<unsigned char>(
'%')) && (
true)) {
00382 mMOD(
true);
00383 theRetToken=_returnToken;
00384 }
00385
else if ((LA(1) == static_cast<unsigned char>(
'>')) && (
true)) {
00386 mGT(
true);
00387 theRetToken=_returnToken;
00388 }
00389
else if ((LA(1) == static_cast<unsigned char>(
'<')) && (
true)) {
00390 mLT_(
true);
00391 theRetToken=_returnToken;
00392 }
00393
else if ((LA(1) == static_cast<unsigned char>(
'^')) && (
true)) {
00394 mBXOR(
true);
00395 theRetToken=_returnToken;
00396 }
00397
else if ((LA(1) == static_cast<unsigned char>(
'|')) && (
true)) {
00398 mBOR(
true);
00399 theRetToken=_returnToken;
00400 }
00401
else if ((LA(1) == static_cast<unsigned char>(
'&')) && (
true)) {
00402 mBAND(
true);
00403 theRetToken=_returnToken;
00404 }
00405
else {
00406
if (LA(1)==EOF_CHAR)
00407 {
00408 uponEOF();
00409 _returnToken = makeToken(
ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
00410 }
00411
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00412 }
00413 }
00414
if ( !_returnToken )
00415
goto tryAgain;
00416
00417 _ttype = _returnToken->getType();
00418 _returnToken->setType(_ttype);
00419
return _returnToken;
00420 }
00421
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& e) {
00422
throw ANTLR_USE_NAMESPACE(antlr)
TokenStreamRecognitionException(e);
00423 }
00424
catch (
ANTLR_USE_NAMESPACE(antlr)
CharStreamIOException& csie) {
00425
throw ANTLR_USE_NAMESPACE(antlr)
TokenStreamIOException(csie.io);
00426 }
00427
catch (
ANTLR_USE_NAMESPACE(antlr)
CharStreamException& cse) {
00428
throw ANTLR_USE_NAMESPACE(antlr)
TokenStreamException(cse.getMessage());
00429 }
00430 tryAgain:;
00431 }
00432 }
00433
00434 void JavaLexer::mQUESTION(
bool _createToken) {
00435
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00436 _ttype = QUESTION;
00437
int _saveIndex;
00438
00439 match(static_cast<unsigned char>(
'?'));
00440
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00441 _token = makeToken(_ttype);
00442 _token->setText(
text.substr(_begin,
text.length()-_begin));
00443 }
00444 _returnToken = _token;
00445 _saveIndex=0;
00446 }
00447
00448 void JavaLexer::mLPAREN(
bool _createToken) {
00449
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00450 _ttype = LPAREN;
00451
int _saveIndex;
00452
00453 match(static_cast<unsigned char>(
'('));
00454
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00455 _token = makeToken(_ttype);
00456 _token->setText(
text.substr(_begin,
text.length()-_begin));
00457 }
00458 _returnToken = _token;
00459 _saveIndex=0;
00460 }
00461
00462 void JavaLexer::mRPAREN(
bool _createToken) {
00463
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00464 _ttype = RPAREN;
00465
int _saveIndex;
00466
00467 match(static_cast<unsigned char>(
')'));
00468
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00469 _token = makeToken(_ttype);
00470 _token->setText(
text.substr(_begin,
text.length()-_begin));
00471 }
00472 _returnToken = _token;
00473 _saveIndex=0;
00474 }
00475
00476 void JavaLexer::mLBRACK(
bool _createToken) {
00477
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00478 _ttype = LBRACK;
00479
int _saveIndex;
00480
00481 match(static_cast<unsigned char>(
'['));
00482
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00483 _token = makeToken(_ttype);
00484 _token->setText(
text.substr(_begin,
text.length()-_begin));
00485 }
00486 _returnToken = _token;
00487 _saveIndex=0;
00488 }
00489
00490 void JavaLexer::mRBRACK(
bool _createToken) {
00491
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00492 _ttype = RBRACK;
00493
int _saveIndex;
00494
00495 match(static_cast<unsigned char>(
']'));
00496
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00497 _token = makeToken(_ttype);
00498 _token->setText(
text.substr(_begin,
text.length()-_begin));
00499 }
00500 _returnToken = _token;
00501 _saveIndex=0;
00502 }
00503
00504 void JavaLexer::mLCURLY(
bool _createToken) {
00505
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00506 _ttype = LCURLY;
00507
int _saveIndex;
00508
00509 match(static_cast<unsigned char>(
'{'));
00510
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00511 _token = makeToken(_ttype);
00512 _token->setText(
text.substr(_begin,
text.length()-_begin));
00513 }
00514 _returnToken = _token;
00515 _saveIndex=0;
00516 }
00517
00518 void JavaLexer::mRCURLY(
bool _createToken) {
00519
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00520 _ttype = RCURLY;
00521
int _saveIndex;
00522
00523 match(static_cast<unsigned char>(
'}'));
00524
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00525 _token = makeToken(_ttype);
00526 _token->setText(
text.substr(_begin,
text.length()-_begin));
00527 }
00528 _returnToken = _token;
00529 _saveIndex=0;
00530 }
00531
00532 void JavaLexer::mCOLON(
bool _createToken) {
00533
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00534 _ttype = COLON;
00535
int _saveIndex;
00536
00537 match(static_cast<unsigned char>(
':'));
00538
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00539 _token = makeToken(_ttype);
00540 _token->setText(
text.substr(_begin,
text.length()-_begin));
00541 }
00542 _returnToken = _token;
00543 _saveIndex=0;
00544 }
00545
00546 void JavaLexer::mCOMMA(
bool _createToken) {
00547
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00548 _ttype = COMMA;
00549
int _saveIndex;
00550
00551 match(static_cast<unsigned char>(
','));
00552
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00553 _token = makeToken(_ttype);
00554 _token->setText(
text.substr(_begin,
text.length()-_begin));
00555 }
00556 _returnToken = _token;
00557 _saveIndex=0;
00558 }
00559
00560 void JavaLexer::mASSIGN(
bool _createToken) {
00561
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00562 _ttype = ASSIGN;
00563
int _saveIndex;
00564
00565 match(static_cast<unsigned char>(
'='));
00566
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00567 _token = makeToken(_ttype);
00568 _token->setText(
text.substr(_begin,
text.length()-_begin));
00569 }
00570 _returnToken = _token;
00571 _saveIndex=0;
00572 }
00573
00574 void JavaLexer::mEQUAL(
bool _createToken) {
00575
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00576 _ttype = EQUAL;
00577
int _saveIndex;
00578
00579 match(
"==");
00580
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00581 _token = makeToken(_ttype);
00582 _token->setText(
text.substr(_begin,
text.length()-_begin));
00583 }
00584 _returnToken = _token;
00585 _saveIndex=0;
00586 }
00587
00588 void JavaLexer::mLNOT(
bool _createToken) {
00589
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00590 _ttype = LNOT;
00591
int _saveIndex;
00592
00593 match(static_cast<unsigned char>(
'!'));
00594
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00595 _token = makeToken(_ttype);
00596 _token->setText(
text.substr(_begin,
text.length()-_begin));
00597 }
00598 _returnToken = _token;
00599 _saveIndex=0;
00600 }
00601
00602 void JavaLexer::mBNOT(
bool _createToken) {
00603
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00604 _ttype = BNOT;
00605
int _saveIndex;
00606
00607 match(static_cast<unsigned char>(
'~'));
00608
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00609 _token = makeToken(_ttype);
00610 _token->setText(
text.substr(_begin,
text.length()-_begin));
00611 }
00612 _returnToken = _token;
00613 _saveIndex=0;
00614 }
00615
00616 void JavaLexer::mNOT_EQUAL(
bool _createToken) {
00617
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00618 _ttype = NOT_EQUAL;
00619
int _saveIndex;
00620
00621 match(
"!=");
00622
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00623 _token = makeToken(_ttype);
00624 _token->setText(
text.substr(_begin,
text.length()-_begin));
00625 }
00626 _returnToken = _token;
00627 _saveIndex=0;
00628 }
00629
00630 void JavaLexer::mDIV(
bool _createToken) {
00631
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00632 _ttype = DIV;
00633
int _saveIndex;
00634
00635 match(static_cast<unsigned char>(
'/'));
00636
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00637 _token = makeToken(_ttype);
00638 _token->setText(
text.substr(_begin,
text.length()-_begin));
00639 }
00640 _returnToken = _token;
00641 _saveIndex=0;
00642 }
00643
00644 void JavaLexer::mDIV_ASSIGN(
bool _createToken) {
00645
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00646 _ttype = DIV_ASSIGN;
00647
int _saveIndex;
00648
00649 match(
"/=");
00650
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00651 _token = makeToken(_ttype);
00652 _token->setText(
text.substr(_begin,
text.length()-_begin));
00653 }
00654 _returnToken = _token;
00655 _saveIndex=0;
00656 }
00657
00658 void JavaLexer::mPLUS(
bool _createToken) {
00659
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00660 _ttype = PLUS;
00661
int _saveIndex;
00662
00663 match(static_cast<unsigned char>(
'+'));
00664
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00665 _token = makeToken(_ttype);
00666 _token->setText(
text.substr(_begin,
text.length()-_begin));
00667 }
00668 _returnToken = _token;
00669 _saveIndex=0;
00670 }
00671
00672 void JavaLexer::mPLUS_ASSIGN(
bool _createToken) {
00673
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00674 _ttype = PLUS_ASSIGN;
00675
int _saveIndex;
00676
00677 match(
"+=");
00678
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00679 _token = makeToken(_ttype);
00680 _token->setText(
text.substr(_begin,
text.length()-_begin));
00681 }
00682 _returnToken = _token;
00683 _saveIndex=0;
00684 }
00685
00686 void JavaLexer::mINC(
bool _createToken) {
00687
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00688 _ttype = INC;
00689
int _saveIndex;
00690
00691 match(
"++");
00692
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00693 _token = makeToken(_ttype);
00694 _token->setText(
text.substr(_begin,
text.length()-_begin));
00695 }
00696 _returnToken = _token;
00697 _saveIndex=0;
00698 }
00699
00700 void JavaLexer::mMINUS(
bool _createToken) {
00701
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00702 _ttype = MINUS;
00703
int _saveIndex;
00704
00705 match(static_cast<unsigned char>(
'-'));
00706
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00707 _token = makeToken(_ttype);
00708 _token->setText(
text.substr(_begin,
text.length()-_begin));
00709 }
00710 _returnToken = _token;
00711 _saveIndex=0;
00712 }
00713
00714 void JavaLexer::mMINUS_ASSIGN(
bool _createToken) {
00715
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00716 _ttype = MINUS_ASSIGN;
00717
int _saveIndex;
00718
00719 match(
"-=");
00720
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00721 _token = makeToken(_ttype);
00722 _token->setText(
text.substr(_begin,
text.length()-_begin));
00723 }
00724 _returnToken = _token;
00725 _saveIndex=0;
00726 }
00727
00728 void JavaLexer::mDEC(
bool _createToken) {
00729
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00730 _ttype = DEC;
00731
int _saveIndex;
00732
00733 match(
"--");
00734
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00735 _token = makeToken(_ttype);
00736 _token->setText(
text.substr(_begin,
text.length()-_begin));
00737 }
00738 _returnToken = _token;
00739 _saveIndex=0;
00740 }
00741
00742 void JavaLexer::mSTAR(
bool _createToken) {
00743
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00744 _ttype = STAR;
00745
int _saveIndex;
00746
00747 match(static_cast<unsigned char>(
'*'));
00748
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00749 _token = makeToken(_ttype);
00750 _token->setText(
text.substr(_begin,
text.length()-_begin));
00751 }
00752 _returnToken = _token;
00753 _saveIndex=0;
00754 }
00755
00756 void JavaLexer::mSTAR_ASSIGN(
bool _createToken) {
00757
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00758 _ttype = STAR_ASSIGN;
00759
int _saveIndex;
00760
00761 match(
"*=");
00762
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00763 _token = makeToken(_ttype);
00764 _token->setText(
text.substr(_begin,
text.length()-_begin));
00765 }
00766 _returnToken = _token;
00767 _saveIndex=0;
00768 }
00769
00770 void JavaLexer::mMOD(
bool _createToken) {
00771
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00772 _ttype = MOD;
00773
int _saveIndex;
00774
00775 match(static_cast<unsigned char>(
'%'));
00776
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00777 _token = makeToken(_ttype);
00778 _token->setText(
text.substr(_begin,
text.length()-_begin));
00779 }
00780 _returnToken = _token;
00781 _saveIndex=0;
00782 }
00783
00784 void JavaLexer::mMOD_ASSIGN(
bool _createToken) {
00785
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00786 _ttype = MOD_ASSIGN;
00787
int _saveIndex;
00788
00789 match(
"%=");
00790
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00791 _token = makeToken(_ttype);
00792 _token->setText(
text.substr(_begin,
text.length()-_begin));
00793 }
00794 _returnToken = _token;
00795 _saveIndex=0;
00796 }
00797
00798 void JavaLexer::mSR(
bool _createToken) {
00799
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00800 _ttype = SR;
00801
int _saveIndex;
00802
00803 match(
">>");
00804
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00805 _token = makeToken(_ttype);
00806 _token->setText(
text.substr(_begin,
text.length()-_begin));
00807 }
00808 _returnToken = _token;
00809 _saveIndex=0;
00810 }
00811
00812 void JavaLexer::mSR_ASSIGN(
bool _createToken) {
00813
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00814 _ttype = SR_ASSIGN;
00815
int _saveIndex;
00816
00817 match(
">>=");
00818
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00819 _token = makeToken(_ttype);
00820 _token->setText(
text.substr(_begin,
text.length()-_begin));
00821 }
00822 _returnToken = _token;
00823 _saveIndex=0;
00824 }
00825
00826 void JavaLexer::mBSR(
bool _createToken) {
00827
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00828 _ttype = BSR;
00829
int _saveIndex;
00830
00831 match(
">>>");
00832
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00833 _token = makeToken(_ttype);
00834 _token->setText(
text.substr(_begin,
text.length()-_begin));
00835 }
00836 _returnToken = _token;
00837 _saveIndex=0;
00838 }
00839
00840 void JavaLexer::mBSR_ASSIGN(
bool _createToken) {
00841
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00842 _ttype = BSR_ASSIGN;
00843
int _saveIndex;
00844
00845 match(
">>>=");
00846
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00847 _token = makeToken(_ttype);
00848 _token->setText(
text.substr(_begin,
text.length()-_begin));
00849 }
00850 _returnToken = _token;
00851 _saveIndex=0;
00852 }
00853
00854 void JavaLexer::mGE(
bool _createToken) {
00855
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00856 _ttype = GE;
00857
int _saveIndex;
00858
00859 match(
">=");
00860
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00861 _token = makeToken(_ttype);
00862 _token->setText(
text.substr(_begin,
text.length()-_begin));
00863 }
00864 _returnToken = _token;
00865 _saveIndex=0;
00866 }
00867
00868 void JavaLexer::mGT(
bool _createToken) {
00869
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00870 _ttype = GT;
00871
int _saveIndex;
00872
00873 match(
">");
00874
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00875 _token = makeToken(_ttype);
00876 _token->setText(
text.substr(_begin,
text.length()-_begin));
00877 }
00878 _returnToken = _token;
00879 _saveIndex=0;
00880 }
00881
00882 void JavaLexer::mSL(
bool _createToken) {
00883
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00884 _ttype = SL;
00885
int _saveIndex;
00886
00887 match(
"<<");
00888
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00889 _token = makeToken(_ttype);
00890 _token->setText(
text.substr(_begin,
text.length()-_begin));
00891 }
00892 _returnToken = _token;
00893 _saveIndex=0;
00894 }
00895
00896 void JavaLexer::mSL_ASSIGN(
bool _createToken) {
00897
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00898 _ttype = SL_ASSIGN;
00899
int _saveIndex;
00900
00901 match(
"<<=");
00902
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00903 _token = makeToken(_ttype);
00904 _token->setText(
text.substr(_begin,
text.length()-_begin));
00905 }
00906 _returnToken = _token;
00907 _saveIndex=0;
00908 }
00909
00910 void JavaLexer::mLE(
bool _createToken) {
00911
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00912 _ttype = LE;
00913
int _saveIndex;
00914
00915 match(
"<=");
00916
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00917 _token = makeToken(_ttype);
00918 _token->setText(
text.substr(_begin,
text.length()-_begin));
00919 }
00920 _returnToken = _token;
00921 _saveIndex=0;
00922 }
00923
00924 void JavaLexer::mLT_(
bool _createToken) {
00925
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00926 _ttype = LT_;
00927
int _saveIndex;
00928
00929 match(static_cast<unsigned char>(
'<'));
00930
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00931 _token = makeToken(_ttype);
00932 _token->setText(
text.substr(_begin,
text.length()-_begin));
00933 }
00934 _returnToken = _token;
00935 _saveIndex=0;
00936 }
00937
00938 void JavaLexer::mBXOR(
bool _createToken) {
00939
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00940 _ttype = BXOR;
00941
int _saveIndex;
00942
00943 match(static_cast<unsigned char>(
'^'));
00944
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00945 _token = makeToken(_ttype);
00946 _token->setText(
text.substr(_begin,
text.length()-_begin));
00947 }
00948 _returnToken = _token;
00949 _saveIndex=0;
00950 }
00951
00952 void JavaLexer::mBXOR_ASSIGN(
bool _createToken) {
00953
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00954 _ttype = BXOR_ASSIGN;
00955
int _saveIndex;
00956
00957 match(
"^=");
00958
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00959 _token = makeToken(_ttype);
00960 _token->setText(
text.substr(_begin,
text.length()-_begin));
00961 }
00962 _returnToken = _token;
00963 _saveIndex=0;
00964 }
00965
00966 void JavaLexer::mBOR(
bool _createToken) {
00967
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00968 _ttype = BOR;
00969
int _saveIndex;
00970
00971 match(static_cast<unsigned char>(
'|'));
00972
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00973 _token = makeToken(_ttype);
00974 _token->setText(
text.substr(_begin,
text.length()-_begin));
00975 }
00976 _returnToken = _token;
00977 _saveIndex=0;
00978 }
00979
00980 void JavaLexer::mBOR_ASSIGN(
bool _createToken) {
00981
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00982 _ttype = BOR_ASSIGN;
00983
int _saveIndex;
00984
00985 match(
"|=");
00986
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00987 _token = makeToken(_ttype);
00988 _token->setText(
text.substr(_begin,
text.length()-_begin));
00989 }
00990 _returnToken = _token;
00991 _saveIndex=0;
00992 }
00993
00994 void JavaLexer::mLOR(
bool _createToken) {
00995
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
00996 _ttype = LOR;
00997
int _saveIndex;
00998
00999 match(
"||");
01000
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01001 _token = makeToken(_ttype);
01002 _token->setText(
text.substr(_begin,
text.length()-_begin));
01003 }
01004 _returnToken = _token;
01005 _saveIndex=0;
01006 }
01007
01008 void JavaLexer::mBAND(
bool _createToken) {
01009
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01010 _ttype = BAND;
01011
int _saveIndex;
01012
01013 match(static_cast<unsigned char>(
'&'));
01014
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01015 _token = makeToken(_ttype);
01016 _token->setText(
text.substr(_begin,
text.length()-_begin));
01017 }
01018 _returnToken = _token;
01019 _saveIndex=0;
01020 }
01021
01022 void JavaLexer::mBAND_ASSIGN(
bool _createToken) {
01023
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01024 _ttype = BAND_ASSIGN;
01025
int _saveIndex;
01026
01027 match(
"&=");
01028
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01029 _token = makeToken(_ttype);
01030 _token->setText(
text.substr(_begin,
text.length()-_begin));
01031 }
01032 _returnToken = _token;
01033 _saveIndex=0;
01034 }
01035
01036 void JavaLexer::mLAND(
bool _createToken) {
01037
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01038 _ttype = LAND;
01039
int _saveIndex;
01040
01041 match(
"&&");
01042
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01043 _token = makeToken(_ttype);
01044 _token->setText(
text.substr(_begin,
text.length()-_begin));
01045 }
01046 _returnToken = _token;
01047 _saveIndex=0;
01048 }
01049
01050 void JavaLexer::mSEMI(
bool _createToken) {
01051
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01052 _ttype = SEMI;
01053
int _saveIndex;
01054
01055 match(static_cast<unsigned char>(
';'));
01056
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01057 _token = makeToken(_ttype);
01058 _token->setText(
text.substr(_begin,
text.length()-_begin));
01059 }
01060 _returnToken = _token;
01061 _saveIndex=0;
01062 }
01063
01064 void JavaLexer::mWS(
bool _createToken) {
01065
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01066 _ttype = WS;
01067
int _saveIndex;
01068
01069 {
01070
int _cnt245=0;
01071
for (;;) {
01072
switch ( LA(1)) {
01073
case static_cast<unsigned char>(
' '):
01074 {
01075 match(static_cast<unsigned char>(
' '));
01076
break;
01077 }
01078
case static_cast<unsigned char>(
'\t'):
01079 {
01080 match(static_cast<unsigned char>(
'\t'));
01081
break;
01082 }
01083
case static_cast<unsigned char>('\14'):
01084 {
01085 match(static_cast<unsigned char>('\14'));
01086
break;
01087 }
01088
case static_cast<unsigned char>(
'\n'):
01089
case static_cast<unsigned char>(
'\r'):
01090 {
01091 {
01092
if ((LA(1) == static_cast<unsigned char>(
'\r')) && (LA(2) == static_cast<unsigned char>(
'\n')) && (
true) && (
true)) {
01093 match(
"\r\n");
01094 }
01095
else if ((LA(1) == static_cast<unsigned char>(
'\r')) && (
true) && (
true) && (
true)) {
01096 match(static_cast<unsigned char>(
'\r'));
01097 }
01098
else if ((LA(1) == static_cast<unsigned char>(
'\n'))) {
01099 match(static_cast<unsigned char>(
'\n'));
01100 }
01101
else {
01102
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01103 }
01104
01105 }
01106
#line 1137 "java.g"
01107
newline();
01108
#line 1109 "JavaLexer.cpp"
01109
break;
01110 }
01111
default:
01112 {
01113
if ( _cnt245>=1 ) {
goto _loop245; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01114 }
01115 }
01116 _cnt245++;
01117 }
01118 _loop245:;
01119 }
01120
#line 1139 "java.g"
01121
_ttype =
ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01122
#line 1123 "JavaLexer.cpp"
01123
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01124 _token = makeToken(_ttype);
01125 _token->setText(
text.substr(_begin,
text.length()-_begin));
01126 }
01127 _returnToken = _token;
01128 _saveIndex=0;
01129 }
01130
01131 void JavaLexer::mSL_COMMENT(
bool _createToken) {
01132
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01133 _ttype = SL_COMMENT;
01134
int _saveIndex;
01135
01136 match(
"//");
01137 {
01138
for (;;) {
01139
if ((
_tokenSet_0.member(LA(1)))) {
01140 {
01141 match(
_tokenSet_0);
01142 }
01143 }
01144
else {
01145
goto _loop249;
01146 }
01147
01148 }
01149 _loop249:;
01150 }
01151 {
01152
switch ( LA(1)) {
01153
case static_cast<unsigned char>(
'\n'):
01154 {
01155 match(static_cast<unsigned char>(
'\n'));
01156
break;
01157 }
01158
case static_cast<unsigned char>(
'\r'):
01159 {
01160 match(static_cast<unsigned char>(
'\r'));
01161 {
01162
if ((LA(1) == static_cast<unsigned char>(
'\n'))) {
01163 match(static_cast<unsigned char>(
'\n'));
01164 }
01165
else {
01166 }
01167
01168 }
01169
break;
01170 }
01171
default:
01172 {
01173
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01174 }
01175 }
01176 }
01177
#line 1146 "java.g"
01178
01179 _ttype =
ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01180 newline();
01181
01182
#line 1183 "JavaLexer.cpp"
01183
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01184 _token = makeToken(_ttype);
01185 _token->setText(
text.substr(_begin,
text.length()-_begin));
01186 }
01187 _returnToken = _token;
01188 _saveIndex=0;
01189 }
01190
01191 void JavaLexer::mML_COMMENT(
bool _createToken) {
01192
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01193 _ttype = ML_COMMENT;
01194
int _saveIndex;
01195
01196 match(
"/*");
01197 {
01198
for (;;) {
01199
if ((LA(1) == static_cast<unsigned char>(
'\r')) && (LA(2) == static_cast<unsigned char>(
'\n')) && ((LA(3) >= static_cast<unsigned char>(
'\3') && LA(3) <= static_cast<unsigned char>('\377'))) && ((LA(4) >= static_cast<unsigned char>(
'\3') && LA(4) <= static_cast<unsigned char>('\377')))) {
01200 match(static_cast<unsigned char>(
'\r'));
01201 match(static_cast<unsigned char>(
'\n'));
01202
#line 1167 "java.g"
01203
newline();
01204
#line 1205 "JavaLexer.cpp"
01205
}
01206
else if (((LA(1) == static_cast<unsigned char>(
'*')) && ((LA(2) >= static_cast<unsigned char>(
'\3') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>(
'\3') && LA(3) <= static_cast<unsigned char>('\377'))))&&( LA(2)!=
'/' )) {
01207 match(static_cast<unsigned char>(
'*'));
01208 }
01209
else if ((LA(1) == static_cast<unsigned char>(
'\r')) && ((LA(2) >= static_cast<unsigned char>(
'\3') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>(
'\3') && LA(3) <= static_cast<unsigned char>('\377'))) && (
true)) {
01210 match(static_cast<unsigned char>(
'\r'));
01211
#line 1168 "java.g"
01212
newline();
01213
#line 1214 "JavaLexer.cpp"
01214
}
01215
else if ((LA(1) == static_cast<unsigned char>(
'\n'))) {
01216 match(static_cast<unsigned char>(
'\n'));
01217
#line 1169 "java.g"
01218
newline();
01219
#line 1220 "JavaLexer.cpp"
01220
}
01221
else if ((
_tokenSet_1.member(LA(1)))) {
01222 {
01223 match(
_tokenSet_1);
01224 }
01225 }
01226
else {
01227
goto _loop255;
01228 }
01229
01230 }
01231 _loop255:;
01232 }
01233 match(
"*/");
01234
#line 1173 "java.g"
01235
_ttype =
ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01236
#line 1237 "JavaLexer.cpp"
01237
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01238 _token = makeToken(_ttype);
01239 _token->setText(
text.substr(_begin,
text.length()-_begin));
01240 }
01241 _returnToken = _token;
01242 _saveIndex=0;
01243 }
01244
01245 void JavaLexer::mCHAR_LITERAL(
bool _createToken) {
01246
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01247 _ttype = CHAR_LITERAL;
01248
int _saveIndex;
01249
01250 match(static_cast<unsigned char>(
'\''));
01251 {
01252
if ((LA(1) == static_cast<unsigned char>(
'\\'))) {
01253
mESC(
false);
01254 }
01255
else if ((
_tokenSet_2.member(LA(1)))) {
01256 matchNot(static_cast<unsigned char>(
'\''));
01257 }
01258
else {
01259
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01260 }
01261
01262 }
01263 match(static_cast<unsigned char>(
'\''));
01264
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01265 _token = makeToken(_ttype);
01266 _token->setText(
text.substr(_begin,
text.length()-_begin));
01267 }
01268 _returnToken = _token;
01269 _saveIndex=0;
01270 }
01271
01272 void JavaLexer::mESC(
bool _createToken) {
01273
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01274 _ttype = ESC;
01275
int _saveIndex;
01276
01277 match(static_cast<unsigned char>(
'\\'));
01278 {
01279
switch ( LA(1)) {
01280
case static_cast<unsigned char>(
'n'):
01281 {
01282 match(static_cast<unsigned char>(
'n'));
01283
break;
01284 }
01285
case static_cast<unsigned char>(
'r'):
01286 {
01287 match(static_cast<unsigned char>(
'r'));
01288
break;
01289 }
01290
case static_cast<unsigned char>(
't'):
01291 {
01292 match(static_cast<unsigned char>(
't'));
01293
break;
01294 }
01295
case static_cast<unsigned char>(
'b'):
01296 {
01297 match(static_cast<unsigned char>(
'b'));
01298
break;
01299 }
01300
case static_cast<unsigned char>(
'f'):
01301 {
01302 match(static_cast<unsigned char>(
'f'));
01303
break;
01304 }
01305
case static_cast<unsigned char>(
'"'):
01306 {
01307 match(static_cast<unsigned char>(
'"'));
01308
break;
01309 }
01310
case static_cast<unsigned char>(
'\''):
01311 {
01312 match(static_cast<unsigned char>(
'\''));
01313
break;
01314 }
01315
case static_cast<unsigned char>(
'\\'):
01316 {
01317 match(static_cast<unsigned char>(
'\\'));
01318
break;
01319 }
01320
case static_cast<unsigned char>(
'u'):
01321 {
01322 {
01323
int _cnt265=0;
01324
for (;;) {
01325
if ((LA(1) == static_cast<unsigned char>(
'u'))) {
01326 match(static_cast<unsigned char>(
'u'));
01327 }
01328
else {
01329
if ( _cnt265>=1 ) {
goto _loop265; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01330 }
01331
01332 _cnt265++;
01333 }
01334 _loop265:;
01335 }
01336
mHEX_DIGIT(
false);
01337
mHEX_DIGIT(
false);
01338
mHEX_DIGIT(
false);
01339
mHEX_DIGIT(
false);
01340
break;
01341 }
01342
case static_cast<unsigned char>(
'0'):
01343
case static_cast<unsigned char>(
'1'):
01344
case static_cast<unsigned char>(
'2'):
01345
case static_cast<unsigned char>(
'3'):
01346 {
01347 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'3'));
01348 {
01349
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'7'))) && ((LA(2) >= static_cast<unsigned char>(
'\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (
true) && (
true)) {
01350 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'7'));
01351 {
01352
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'7'))) && ((LA(2) >= static_cast<unsigned char>(
'\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (
true) && (
true)) {
01353 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'7'));
01354 }
01355
else if (((LA(1) >= static_cast<unsigned char>(
'\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (
true) && (
true) && (
true)) {
01356 }
01357
else {
01358
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01359 }
01360
01361 }
01362 }
01363
else if (((LA(1) >= static_cast<unsigned char>(
'\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (
true) && (
true) && (
true)) {
01364 }
01365
else {
01366
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01367 }
01368
01369 }
01370
break;
01371 }
01372
case static_cast<unsigned char>(
'4'):
01373
case static_cast<unsigned char>(
'5'):
01374
case static_cast<unsigned char>(
'6'):
01375
case static_cast<unsigned char>(
'7'):
01376 {
01377 matchRange(static_cast<unsigned char>(
'4'),static_cast<unsigned char>(
'7'));
01378 {
01379
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'7'))) && ((LA(2) >= static_cast<unsigned char>(
'\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (
true) && (
true)) {
01380 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'7'));
01381 }
01382
else if (((LA(1) >= static_cast<unsigned char>(
'\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (
true) && (
true) && (
true)) {
01383 }
01384
else {
01385
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01386 }
01387
01388 }
01389
break;
01390 }
01391
default:
01392 {
01393
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01394 }
01395 }
01396 }
01397
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01398 _token = makeToken(_ttype);
01399 _token->setText(
text.substr(_begin,
text.length()-_begin));
01400 }
01401 _returnToken = _token;
01402 _saveIndex=0;
01403 }
01404
01405 void JavaLexer::mSTRING_LITERAL(
bool _createToken) {
01406
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01407 _ttype = STRING_LITERAL;
01408
int _saveIndex;
01409
01410 match(static_cast<unsigned char>(
'"'));
01411 {
01412
for (;;) {
01413
if ((LA(1) == static_cast<unsigned char>(
'\\'))) {
01414
mESC(
false);
01415 }
01416
else if ((
_tokenSet_3.member(LA(1)))) {
01417 {
01418 match(
_tokenSet_3);
01419 }
01420 }
01421
else {
01422
goto _loop261;
01423 }
01424
01425 }
01426 _loop261:;
01427 }
01428 match(static_cast<unsigned char>(
'"'));
01429
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01430 _token = makeToken(_ttype);
01431 _token->setText(
text.substr(_begin,
text.length()-_begin));
01432 }
01433 _returnToken = _token;
01434 _saveIndex=0;
01435 }
01436
01437 void JavaLexer::mHEX_DIGIT(
bool _createToken) {
01438
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01439 _ttype = HEX_DIGIT;
01440
int _saveIndex;
01441
01442 {
01443
switch ( LA(1)) {
01444
case static_cast<unsigned char>(
'0'):
01445
case static_cast<unsigned char>(
'1'):
01446
case static_cast<unsigned char>(
'2'):
01447
case static_cast<unsigned char>(
'3'):
01448
case static_cast<unsigned char>(
'4'):
01449
case static_cast<unsigned char>(
'5'):
01450
case static_cast<unsigned char>(
'6'):
01451
case static_cast<unsigned char>(
'7'):
01452
case static_cast<unsigned char>(
'8'):
01453
case static_cast<unsigned char>(
'9'):
01454 {
01455 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
01456
break;
01457 }
01458
case static_cast<unsigned char>(
'A'):
01459
case static_cast<unsigned char>(
'B'):
01460
case static_cast<unsigned char>(
'C'):
01461
case static_cast<unsigned char>(
'D'):
01462
case static_cast<unsigned char>(
'E'):
01463
case static_cast<unsigned char>(
'F'):
01464 {
01465 matchRange(static_cast<unsigned char>(
'A'),static_cast<unsigned char>(
'F'));
01466
break;
01467 }
01468
case static_cast<unsigned char>(
'a'):
01469
case static_cast<unsigned char>(
'b'):
01470
case static_cast<unsigned char>(
'c'):
01471
case static_cast<unsigned char>(
'd'):
01472
case static_cast<unsigned char>(
'e'):
01473
case static_cast<unsigned char>(
'f'):
01474 {
01475 matchRange(static_cast<unsigned char>(
'a'),static_cast<unsigned char>(
'f'));
01476
break;
01477 }
01478
default:
01479 {
01480
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01481 }
01482 }
01483 }
01484
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01485 _token = makeToken(_ttype);
01486 _token->setText(
text.substr(_begin,
text.length()-_begin));
01487 }
01488 _returnToken = _token;
01489 _saveIndex=0;
01490 }
01491
01492 void JavaLexer::mVOCAB(
bool _createToken) {
01493
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01494 _ttype = VOCAB;
01495
int _saveIndex;
01496
01497 matchRange(static_cast<unsigned char>(
'\3'),static_cast<unsigned char>('\377'));
01498
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01499 _token = makeToken(_ttype);
01500 _token->setText(
text.substr(_begin,
text.length()-_begin));
01501 }
01502 _returnToken = _token;
01503 _saveIndex=0;
01504 }
01505
01506 void JavaLexer::mIDENT(
bool _createToken) {
01507
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01508 _ttype = IDENT;
01509
int _saveIndex;
01510
01511 {
01512
switch ( LA(1)) {
01513
case static_cast<unsigned char>(
'a'):
01514
case static_cast<unsigned char>(
'b'):
01515
case static_cast<unsigned char>(
'c'):
01516
case static_cast<unsigned char>(
'd'):
01517
case static_cast<unsigned char>(
'e'):
01518
case static_cast<unsigned char>(
'f'):
01519
case static_cast<unsigned char>(
'g'):
01520
case static_cast<unsigned char>(
'h'):
01521
case static_cast<unsigned char>(
'i'):
01522
case static_cast<unsigned char>(
'j'):
01523
case static_cast<unsigned char>(
'k'):
01524
case static_cast<unsigned char>(
'l'):
01525
case static_cast<unsigned char>(
'm'):
01526
case static_cast<unsigned char>(
'n'):
01527
case static_cast<unsigned char>(
'o'):
01528
case static_cast<unsigned char>(
'p'):
01529
case static_cast<unsigned char>(
'q'):
01530
case static_cast<unsigned char>(
'r'):
01531
case static_cast<unsigned char>(
's'):
01532
case static_cast<unsigned char>(
't'):
01533
case static_cast<unsigned char>(
'u'):
01534
case static_cast<unsigned char>(
'v'):
01535
case static_cast<unsigned char>(
'w'):
01536
case static_cast<unsigned char>(
'x'):
01537
case static_cast<unsigned char>(
'y'):
01538
case static_cast<unsigned char>(
'z'):
01539 {
01540 matchRange(static_cast<unsigned char>(
'a'),static_cast<unsigned char>(
'z'));
01541
break;
01542 }
01543
case static_cast<unsigned char>(
'A'):
01544
case static_cast<unsigned char>(
'B'):
01545
case static_cast<unsigned char>(
'C'):
01546
case static_cast<unsigned char>(
'D'):
01547
case static_cast<unsigned char>(
'E'):
01548
case static_cast<unsigned char>(
'F'):
01549
case static_cast<unsigned char>(
'G'):
01550
case static_cast<unsigned char>(
'H'):
01551
case static_cast<unsigned char>(
'I'):
01552
case static_cast<unsigned char>(
'J'):
01553
case static_cast<unsigned char>(
'K'):
01554
case static_cast<unsigned char>(
'L'):
01555
case static_cast<unsigned char>(
'M'):
01556
case static_cast<unsigned char>(
'N'):
01557
case static_cast<unsigned char>(
'O'):
01558
case static_cast<unsigned char>(
'P'):
01559
case static_cast<unsigned char>(
'Q'):
01560
case static_cast<unsigned char>(
'R'):
01561
case static_cast<unsigned char>(
'S'):
01562
case static_cast<unsigned char>(
'T'):
01563
case static_cast<unsigned char>(
'U'):
01564
case static_cast<unsigned char>(
'V'):
01565
case static_cast<unsigned char>(
'W'):
01566
case static_cast<unsigned char>(
'X'):
01567
case static_cast<unsigned char>(
'Y'):
01568
case static_cast<unsigned char>(
'Z'):
01569 {
01570 matchRange(static_cast<unsigned char>(
'A'),static_cast<unsigned char>(
'Z'));
01571
break;
01572 }
01573
case static_cast<unsigned char>(
'_'):
01574 {
01575 match(static_cast<unsigned char>(
'_'));
01576
break;
01577 }
01578
case static_cast<unsigned char>(
'$'):
01579 {
01580 match(static_cast<unsigned char>(
'$'));
01581
break;
01582 }
01583
default:
01584 {
01585
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01586 }
01587 }
01588 }
01589 {
01590
for (;;) {
01591
switch ( LA(1)) {
01592
case static_cast<unsigned char>(
'a'):
01593
case static_cast<unsigned char>(
'b'):
01594
case static_cast<unsigned char>(
'c'):
01595
case static_cast<unsigned char>(
'd'):
01596
case static_cast<unsigned char>(
'e'):
01597
case static_cast<unsigned char>(
'f'):
01598
case static_cast<unsigned char>(
'g'):
01599
case static_cast<unsigned char>(
'h'):
01600
case static_cast<unsigned char>(
'i'):
01601
case static_cast<unsigned char>(
'j'):
01602
case static_cast<unsigned char>(
'k'):
01603
case static_cast<unsigned char>(
'l'):
01604
case static_cast<unsigned char>(
'm'):
01605
case static_cast<unsigned char>(
'n'):
01606
case static_cast<unsigned char>(
'o'):
01607
case static_cast<unsigned char>(
'p'):
01608
case static_cast<unsigned char>(
'q'):
01609
case static_cast<unsigned char>(
'r'):
01610
case static_cast<unsigned char>(
's'):
01611
case static_cast<unsigned char>(
't'):
01612
case static_cast<unsigned char>(
'u'):
01613
case static_cast<unsigned char>(
'v'):
01614
case static_cast<unsigned char>(
'w'):
01615
case static_cast<unsigned char>(
'x'):
01616
case static_cast<unsigned char>(
'y'):
01617
case static_cast<unsigned char>(
'z'):
01618 {
01619 matchRange(static_cast<unsigned char>(
'a'),static_cast<unsigned char>(
'z'));
01620
break;
01621 }
01622
case static_cast<unsigned char>(
'A'):
01623
case static_cast<unsigned char>(
'B'):
01624
case static_cast<unsigned char>(
'C'):
01625
case static_cast<unsigned char>(
'D'):
01626
case static_cast<unsigned char>(
'E'):
01627
case static_cast<unsigned char>(
'F'):
01628
case static_cast<unsigned char>(
'G'):
01629
case static_cast<unsigned char>(
'H'):
01630
case static_cast<unsigned char>(
'I'):
01631
case static_cast<unsigned char>(
'J'):
01632
case static_cast<unsigned char>(
'K'):
01633
case static_cast<unsigned char>(
'L'):
01634
case static_cast<unsigned char>(
'M'):
01635
case static_cast<unsigned char>(
'N'):
01636
case static_cast<unsigned char>(
'O'):
01637
case static_cast<unsigned char>(
'P'):
01638
case static_cast<unsigned char>(
'Q'):
01639
case static_cast<unsigned char>(
'R'):
01640
case static_cast<unsigned char>(
'S'):
01641
case static_cast<unsigned char>(
'T'):
01642
case static_cast<unsigned char>(
'U'):
01643
case static_cast<unsigned char>(
'V'):
01644
case static_cast<unsigned char>(
'W'):
01645
case static_cast<unsigned char>(
'X'):
01646
case static_cast<unsigned char>(
'Y'):
01647
case static_cast<unsigned char>(
'Z'):
01648 {
01649 matchRange(static_cast<unsigned char>(
'A'),static_cast<unsigned char>(
'Z'));
01650
break;
01651 }
01652
case static_cast<unsigned char>(
'_'):
01653 {
01654 match(static_cast<unsigned char>(
'_'));
01655
break;
01656 }
01657
case static_cast<unsigned char>(
'0'):
01658
case static_cast<unsigned char>(
'1'):
01659
case static_cast<unsigned char>(
'2'):
01660
case static_cast<unsigned char>(
'3'):
01661
case static_cast<unsigned char>(
'4'):
01662
case static_cast<unsigned char>(
'5'):
01663
case static_cast<unsigned char>(
'6'):
01664
case static_cast<unsigned char>(
'7'):
01665
case static_cast<unsigned char>(
'8'):
01666
case static_cast<unsigned char>(
'9'):
01667 {
01668 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
01669
break;
01670 }
01671
case static_cast<unsigned char>(
'$'):
01672 {
01673 match(static_cast<unsigned char>(
'$'));
01674
break;
01675 }
01676
default:
01677 {
01678
goto _loop275;
01679 }
01680 }
01681 }
01682 _loop275:;
01683 }
01684 _ttype = testLiteralsTable(_ttype);
01685
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01686 _token = makeToken(_ttype);
01687 _token->setText(
text.substr(_begin,
text.length()-_begin));
01688 }
01689 _returnToken = _token;
01690 _saveIndex=0;
01691 }
01692
01693 void JavaLexer::mNUM_INT(
bool _createToken) {
01694
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
01695 _ttype = NUM_INT;
01696
int _saveIndex;
01697
ANTLR_USE_NAMESPACE(antlr)
RefToken f1;
01698
ANTLR_USE_NAMESPACE(antlr)
RefToken f2;
01699
ANTLR_USE_NAMESPACE(antlr)
RefToken f3;
01700
ANTLR_USE_NAMESPACE(antlr)
RefToken f4;
01701
#line 1251 "java.g"
01702
01703
bool isDecimal =
false;
01704
ANTLR_USE_NAMESPACE(antlr)
RefToken t =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01705
01706
#line 1707 "JavaLexer.cpp"
01707
01708
switch ( LA(1)) {
01709
case static_cast<unsigned char>(
'.'):
01710 {
01711 match(static_cast<unsigned char>(
'.'));
01712
#line 1256 "java.g"
01713
_ttype = DOT;
01714
#line 1715 "JavaLexer.cpp"
01715
{
01716
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'9')))) {
01717 {
01718
int _cnt279=0;
01719
for (;;) {
01720
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'9')))) {
01721 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
01722 }
01723
else {
01724
if ( _cnt279>=1 ) {
goto _loop279; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01725 }
01726
01727 _cnt279++;
01728 }
01729 _loop279:;
01730 }
01731 {
01732
if ((LA(1) == static_cast<unsigned char>(
'E') || LA(1) == static_cast<unsigned char>(
'e'))) {
01733
mEXPONENT(
false);
01734 }
01735
else {
01736 }
01737
01738 }
01739 {
01740
if ((LA(1) == static_cast<unsigned char>(
'D') || LA(1) == static_cast<unsigned char>(
'F') || LA(1) == static_cast<unsigned char>(
'd') || LA(1) == static_cast<unsigned char>(
'f'))) {
01741
mFLOAT_SUFFIX(
true);
01742 f1=_returnToken;
01743
#line 1257 "java.g"
01744
t=f1;
01745
#line 1746 "JavaLexer.cpp"
01746
}
01747
else {
01748 }
01749
01750 }
01751
#line 1258 "java.g"
01752
01753
if ( t &&
01754 (t->getText().find(
'f') !=
ANTLR_USE_NAMESPACE(std)string::npos ||
01755 t->getText().find(
'F') !=
ANTLR_USE_NAMESPACE(std)string::npos ) ) {
01756 _ttype = NUM_FLOAT;
01757 }
01758
else {
01759 _ttype = NUM_DOUBLE;
01760 }
01761
01762
#line 1763 "JavaLexer.cpp"
01763
}
01764
else {
01765 }
01766
01767 }
01768
break;
01769 }
01770
case static_cast<unsigned char>(
'0'):
01771
case static_cast<unsigned char>(
'1'):
01772
case static_cast<unsigned char>(
'2'):
01773
case static_cast<unsigned char>(
'3'):
01774
case static_cast<unsigned char>(
'4'):
01775
case static_cast<unsigned char>(
'5'):
01776
case static_cast<unsigned char>(
'6'):
01777
case static_cast<unsigned char>(
'7'):
01778
case static_cast<unsigned char>(
'8'):
01779
case static_cast<unsigned char>(
'9'):
01780 {
01781 {
01782
switch ( LA(1)) {
01783
case static_cast<unsigned char>(
'0'):
01784 {
01785 match(static_cast<unsigned char>(
'0'));
01786
#line 1270 "java.g"
01787
isDecimal =
true;
01788
#line 1789 "JavaLexer.cpp"
01789
{
01790
switch ( LA(1)) {
01791
case static_cast<unsigned char>(
'X'):
01792
case static_cast<unsigned char>(
'x'):
01793 {
01794 {
01795
switch ( LA(1)) {
01796
case static_cast<unsigned char>(
'x'):
01797 {
01798 match(static_cast<unsigned char>(
'x'));
01799
break;
01800 }
01801
case static_cast<unsigned char>(
'X'):
01802 {
01803 match(static_cast<unsigned char>(
'X'));
01804
break;
01805 }
01806
default:
01807 {
01808
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01809 }
01810 }
01811 }
01812 {
01813
int _cnt286=0;
01814
for (;;) {
01815
if ((
_tokenSet_4.member(LA(1))) && (
true) && (
true) && (
true)) {
01816
mHEX_DIGIT(
false);
01817 }
01818
else {
01819
if ( _cnt286>=1 ) {
goto _loop286; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01820 }
01821
01822 _cnt286++;
01823 }
01824 _loop286:;
01825 }
01826
break;
01827 }
01828
case static_cast<unsigned char>(
'0'):
01829
case static_cast<unsigned char>(
'1'):
01830
case static_cast<unsigned char>(
'2'):
01831
case static_cast<unsigned char>(
'3'):
01832
case static_cast<unsigned char>(
'4'):
01833
case static_cast<unsigned char>(
'5'):
01834
case static_cast<unsigned char>(
'6'):
01835
case static_cast<unsigned char>(
'7'):
01836 {
01837 {
01838
int _cnt288=0;
01839
for (;;) {
01840
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'7')))) {
01841 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'7'));
01842 }
01843
else {
01844
if ( _cnt288>=1 ) {
goto _loop288; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01845 }
01846
01847 _cnt288++;
01848 }
01849 _loop288:;
01850 }
01851
break;
01852 }
01853
default:
01854 {
01855 }
01856 }
01857 }
01858
break;
01859 }
01860
case static_cast<unsigned char>(
'1'):
01861
case static_cast<unsigned char>(
'2'):
01862
case static_cast<unsigned char>(
'3'):
01863
case static_cast<unsigned char>(
'4'):
01864
case static_cast<unsigned char>(
'5'):
01865
case static_cast<unsigned char>(
'6'):
01866
case static_cast<unsigned char>(
'7'):
01867
case static_cast<unsigned char>(
'8'):
01868
case static_cast<unsigned char>(
'9'):
01869 {
01870 {
01871 matchRange(static_cast<unsigned char>(
'1'),static_cast<unsigned char>(
'9'));
01872 }
01873 {
01874
for (;;) {
01875
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'9')))) {
01876 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
01877 }
01878
else {
01879
goto _loop291;
01880 }
01881
01882 }
01883 _loop291:;
01884 }
01885
#line 1285 "java.g"
01886
isDecimal=
true;
01887
#line 1888 "JavaLexer.cpp"
01888
break;
01889 }
01890
default:
01891 {
01892
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01893 }
01894 }
01895 }
01896 {
01897
if ((LA(1) == static_cast<unsigned char>(
'L') || LA(1) == static_cast<unsigned char>(
'l'))) {
01898 {
01899
switch ( LA(1)) {
01900
case static_cast<unsigned char>(
'l'):
01901 {
01902 match(static_cast<unsigned char>(
'l'));
01903
break;
01904 }
01905
case static_cast<unsigned char>(
'L'):
01906 {
01907 match(static_cast<unsigned char>(
'L'));
01908
break;
01909 }
01910
default:
01911 {
01912
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01913 }
01914 }
01915 }
01916
#line 1287 "java.g"
01917
_ttype = NUM_LONG;
01918
#line 1919 "JavaLexer.cpp"
01919
}
01920
else if (((LA(1) == static_cast<unsigned char>(
'.') || LA(1) == static_cast<unsigned char>(
'D') || LA(1) == static_cast<unsigned char>(
'E') || LA(1) == static_cast<unsigned char>(
'F') || LA(1) == static_cast<unsigned char>(
'd') || LA(1) == static_cast<unsigned char>(
'e') || LA(1) == static_cast<unsigned char>(
'f')))&&(isDecimal)) {
01921 {
01922
switch ( LA(1)) {
01923
case static_cast<unsigned char>(
'.'):
01924 {
01925 match(static_cast<unsigned char>(
'.'));
01926 {
01927
for (;;) {
01928
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'9')))) {
01929 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
01930 }
01931
else {
01932
goto _loop296;
01933 }
01934
01935 }
01936 _loop296:;
01937 }
01938 {
01939
if ((LA(1) == static_cast<unsigned char>(
'E') || LA(1) == static_cast<unsigned char>(
'e'))) {
01940
mEXPONENT(
false);
01941 }
01942
else {
01943 }
01944
01945 }
01946 {
01947
if ((LA(1) == static_cast<unsigned char>(
'D') || LA(1) == static_cast<unsigned char>(
'F') || LA(1) == static_cast<unsigned char>(
'd') || LA(1) == static_cast<unsigned char>(
'f'))) {
01948
mFLOAT_SUFFIX(
true);
01949 f2=_returnToken;
01950
#line 1291 "java.g"
01951
t=f2;
01952
#line 1953 "JavaLexer.cpp"
01953
}
01954
else {
01955 }
01956
01957 }
01958
break;
01959 }
01960
case static_cast<unsigned char>(
'E'):
01961
case static_cast<unsigned char>(
'e'):
01962 {
01963
mEXPONENT(
false);
01964 {
01965
if ((LA(1) == static_cast<unsigned char>(
'D') || LA(1) == static_cast<unsigned char>(
'F') || LA(1) == static_cast<unsigned char>(
'd') || LA(1) == static_cast<unsigned char>(
'f'))) {
01966
mFLOAT_SUFFIX(
true);
01967 f3=_returnToken;
01968
#line 1292 "java.g"
01969
t=f3;
01970
#line 1971 "JavaLexer.cpp"
01971
}
01972
else {
01973 }
01974
01975 }
01976
break;
01977 }
01978
case static_cast<unsigned char>(
'D'):
01979
case static_cast<unsigned char>(
'F'):
01980
case static_cast<unsigned char>(
'd'):
01981
case static_cast<unsigned char>(
'f'):
01982 {
01983
mFLOAT_SUFFIX(
true);
01984 f4=_returnToken;
01985
#line 1293 "java.g"
01986
t=f4;
01987
#line 1988 "JavaLexer.cpp"
01988
break;
01989 }
01990
default:
01991 {
01992
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01993 }
01994 }
01995 }
01996
#line 1295 "java.g"
01997
01998
if ( t &&
01999 (t->getText().find(
'f') !=
ANTLR_USE_NAMESPACE(std)string::npos ||
02000 t->getText().find(
'F') !=
ANTLR_USE_NAMESPACE(std)string::npos ) ) {
02001 _ttype = NUM_FLOAT;
02002 }
02003
else {
02004 _ttype = NUM_DOUBLE;
02005 }
02006
02007
#line 2008 "JavaLexer.cpp"
02008
}
02009
else {
02010 }
02011
02012 }
02013
break;
02014 }
02015
default:
02016 {
02017
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02018 }
02019 }
02020
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02021 _token = makeToken(_ttype);
02022 _token->setText(
text.substr(_begin,
text.length()-_begin));
02023 }
02024 _returnToken = _token;
02025 _saveIndex=0;
02026 }
02027
02028 void JavaLexer::mEXPONENT(
bool _createToken) {
02029
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
02030 _ttype = EXPONENT;
02031
int _saveIndex;
02032
02033 {
02034
switch ( LA(1)) {
02035
case static_cast<unsigned char>(
'e'):
02036 {
02037 match(static_cast<unsigned char>(
'e'));
02038
break;
02039 }
02040
case static_cast<unsigned char>(
'E'):
02041 {
02042 match(static_cast<unsigned char>(
'E'));
02043
break;
02044 }
02045
default:
02046 {
02047
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02048 }
02049 }
02050 }
02051 {
02052
switch ( LA(1)) {
02053
case static_cast<unsigned char>(
'+'):
02054 {
02055 match(static_cast<unsigned char>(
'+'));
02056
break;
02057 }
02058
case static_cast<unsigned char>(
'-'):
02059 {
02060 match(static_cast<unsigned char>(
'-'));
02061
break;
02062 }
02063
case static_cast<unsigned char>(
'0'):
02064
case static_cast<unsigned char>(
'1'):
02065
case static_cast<unsigned char>(
'2'):
02066
case static_cast<unsigned char>(
'3'):
02067
case static_cast<unsigned char>(
'4'):
02068
case static_cast<unsigned char>(
'5'):
02069
case static_cast<unsigned char>(
'6'):
02070
case static_cast<unsigned char>(
'7'):
02071
case static_cast<unsigned char>(
'8'):
02072
case static_cast<unsigned char>(
'9'):
02073 {
02074
break;
02075 }
02076
default:
02077 {
02078
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02079 }
02080 }
02081 }
02082 {
02083
int _cnt304=0;
02084
for (;;) {
02085
if (((LA(1) >= static_cast<unsigned char>(
'0') && LA(1) <= static_cast<unsigned char>(
'9')))) {
02086 matchRange(static_cast<unsigned char>(
'0'),static_cast<unsigned char>(
'9'));
02087 }
02088
else {
02089
if ( _cnt304>=1 ) {
goto _loop304; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
02090 }
02091
02092 _cnt304++;
02093 }
02094 _loop304:;
02095 }
02096
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02097 _token = makeToken(_ttype);
02098 _token->setText(
text.substr(_begin,
text.length()-_begin));
02099 }
02100 _returnToken = _token;
02101 _saveIndex=0;
02102 }
02103
02104 void JavaLexer::mFLOAT_SUFFIX(
bool _createToken) {
02105
int _ttype;
ANTLR_USE_NAMESPACE(antlr)
RefToken _token;
int _begin=
text.length();
02106 _ttype = FLOAT_SUFFIX;
02107
int _saveIndex;
02108
02109
switch ( LA(1)) {
02110
case static_cast<unsigned char>(
'f'):
02111 {
02112 match(static_cast<unsigned char>(
'f'));
02113
break;
02114 }
02115
case static_cast<unsigned char>(
'F'):
02116 {
02117 match(static_cast<unsigned char>(
'F'));
02118
break;
02119 }
02120
case static_cast<unsigned char>(
'd'):
02121 {
02122 match(static_cast<unsigned char>(
'd'));
02123
break;
02124 }
02125
case static_cast<unsigned char>(
'D'):
02126 {
02127 match(static_cast<unsigned char>(
'D'));
02128
break;
02129 }
02130
default:
02131 {
02132
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02133 }
02134 }
02135
if ( _createToken && _token==
ANTLR_USE_NAMESPACE(antlr)
nullToken && _ttype!=
ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02136 _token = makeToken(_ttype);
02137 _token->setText(
text.substr(_begin,
text.length()-_begin));
02138 }
02139 _returnToken = _token;
02140 _saveIndex=0;
02141 }
02142
02143
02144 const unsigned long JavaLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02145
02146
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161
02162
02163
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaLexer::_tokenSet_0(_tokenSet_0_data_,16);
02164 const
unsigned long JavaLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02165
02166
02167
02168
02169
02170
02171
02172
02173
02174
02175
02176
02177
02178
02179
02180
02181
02182
02183
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaLexer::_tokenSet_1(_tokenSet_1_data_,16);
02184 const
unsigned long JavaLexer::_tokenSet_2_data_[] = { 4294967288UL, 4294967167UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02185
02186
02187
02188
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199
02200
02201
02202
02203
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaLexer::_tokenSet_2(_tokenSet_2_data_,16);
02204 const
unsigned long JavaLexer::_tokenSet_3_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02205
02206
02207
02208
02209
02210
02211
02212
02213
02214
02215
02216
02217
02218
02219
02220
02221
02222
02223
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaLexer::_tokenSet_3(_tokenSet_3_data_,16);
02224 const
unsigned long JavaLexer::_tokenSet_4_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02225
02226
02227
02228
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaLexer::_tokenSet_4(_tokenSet_4_data_,10);
02229