00001
00002
#include "JavaRecognizer.hpp"
00003
#include <antlr/NoViableAltException.hpp>
00004
#include <antlr/SemanticException.hpp>
00005
#include <antlr/ASTFactory.hpp>
00006
#line 1 "java.g"
00007
#line 8 "JavaRecognizer.cpp"
00008 JavaRecognizer::JavaRecognizer(
ANTLR_USE_NAMESPACE(antlr)
TokenBuffer& tokenBuf,
int k)
00009 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(tokenBuf,k)
00010 {
00011 }
00012
00013 JavaRecognizer::JavaRecognizer(
ANTLR_USE_NAMESPACE(antlr)
TokenBuffer& tokenBuf)
00014 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(tokenBuf,2)
00015 {
00016 }
00017
00018 JavaRecognizer::JavaRecognizer(
ANTLR_USE_NAMESPACE(antlr)
TokenStream& lexer,
int k)
00019 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(lexer,k)
00020 {
00021 }
00022
00023 JavaRecognizer::JavaRecognizer(
ANTLR_USE_NAMESPACE(antlr)
TokenStream& lexer)
00024 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(lexer,2)
00025 {
00026 }
00027
00028 JavaRecognizer::JavaRecognizer(
const ANTLR_USE_NAMESPACE(antlr)
ParserSharedInputState& state)
00029 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(state,2)
00030 {
00031 }
00032
00033 void JavaRecognizer::compilationUnit() {
00034
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00035
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00036
RefJavaAST compilationUnit_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00037
00038
try {
00039 {
00040
switch ( LA(1)) {
00041
case LITERAL_package:
00042 {
00043
packageDefinition();
00044
if (inputState->guessing==0) {
00045 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00046 }
00047
break;
00048 }
00049
case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
00050
case FINAL:
00051
case ABSTRACT:
00052
case STRICTFP:
00053
case SEMI:
00054
case LITERAL_import:
00055
case LITERAL_private:
00056
case LITERAL_public:
00057
case LITERAL_protected:
00058
case LITERAL_static:
00059
case LITERAL_transient:
00060
case LITERAL_native:
00061
case LITERAL_threadsafe:
00062
case LITERAL_synchronized:
00063
case LITERAL_volatile:
00064
case LITERAL_class:
00065
case LITERAL_interface:
00066 {
00067
break;
00068 }
00069
default:
00070 {
00071
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00072 }
00073 }
00074 }
00075 {
00076
for (;;) {
00077
if ((LA(1) == LITERAL_import)) {
00078
importDefinition();
00079
if (inputState->guessing==0) {
00080 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00081 }
00082 }
00083
else {
00084
goto _loop4;
00085 }
00086
00087 }
00088 _loop4:;
00089 }
00090 {
00091
for (;;) {
00092
if ((
_tokenSet_0.member(LA(1)))) {
00093
typeDefinition();
00094
if (inputState->guessing==0) {
00095 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00096 }
00097 }
00098
else {
00099
goto _loop6;
00100 }
00101
00102 }
00103 _loop6:;
00104 }
00105 match(
ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
00106 compilationUnit_AST = (currentAST.
root);
00107 }
00108
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00109
if( inputState->guessing == 0 ) {
00110
reportError(ex);
00111 consume();
00112 consumeUntil(
_tokenSet_1);
00113 }
else {
00114
throw;
00115 }
00116 }
00117
returnAST = compilationUnit_AST;
00118 }
00119
00120 void JavaRecognizer::packageDefinition() {
00121
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00122
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00123
RefJavaAST packageDefinition_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00124
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00125
RefJavaAST p_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00126
00127
try {
00128 p = LT(1);
00129
if ( inputState->guessing == 0 ) {
00130 p_AST = astFactory->create(p);
00131 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
00132 }
00133 match(LITERAL_package);
00134
if ( inputState->guessing==0 ) {
00135
#line 196 "java.g"
00136
p_AST->setType(PACKAGE_DEF);
00137
#line 138 "JavaRecognizer.cpp"
00138
}
00139
identifier();
00140
if (inputState->guessing==0) {
00141 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00142 }
00143 match(SEMI);
00144 packageDefinition_AST = (currentAST.
root);
00145 }
00146
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00147
if( inputState->guessing == 0 ) {
00148
reportError(ex);
00149 consume();
00150 consumeUntil(
_tokenSet_2);
00151 }
else {
00152
throw;
00153 }
00154 }
00155
returnAST = packageDefinition_AST;
00156 }
00157
00158 void JavaRecognizer::importDefinition() {
00159
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00160
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00161
RefJavaAST importDefinition_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00162
ANTLR_USE_NAMESPACE(antlr)
RefToken i =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00163
RefJavaAST i_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00164
00165
try {
00166 i = LT(1);
00167
if ( inputState->guessing == 0 ) {
00168 i_AST = astFactory->create(i);
00169 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(i_AST.get()));
00170 }
00171 match(LITERAL_import);
00172
if ( inputState->guessing==0 ) {
00173
#line 202 "java.g"
00174
i_AST->setType(IMPORT);
00175
#line 176 "JavaRecognizer.cpp"
00176
}
00177
identifierStar();
00178
if (inputState->guessing==0) {
00179 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00180 }
00181 match(SEMI);
00182 importDefinition_AST = (currentAST.
root);
00183 }
00184
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00185
if( inputState->guessing == 0 ) {
00186
reportError(ex);
00187 consume();
00188 consumeUntil(
_tokenSet_2);
00189 }
else {
00190
throw;
00191 }
00192 }
00193
returnAST = importDefinition_AST;
00194 }
00195
00196 void JavaRecognizer::typeDefinition() {
00197
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00198
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00199
RefJavaAST typeDefinition_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00200
RefJavaAST m_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00201
00202
try {
00203
switch ( LA(1)) {
00204
case FINAL:
00205
case ABSTRACT:
00206
case STRICTFP:
00207
case LITERAL_private:
00208
case LITERAL_public:
00209
case LITERAL_protected:
00210
case LITERAL_static:
00211
case LITERAL_transient:
00212
case LITERAL_native:
00213
case LITERAL_threadsafe:
00214
case LITERAL_synchronized:
00215
case LITERAL_volatile:
00216
case LITERAL_class:
00217
case LITERAL_interface:
00218 {
00219
modifiers();
00220
if (inputState->guessing==0) {
00221 m_AST =
returnAST;
00222 }
00223 {
00224
switch ( LA(1)) {
00225
case LITERAL_class:
00226 {
00227
classDefinition(m_AST);
00228
if (inputState->guessing==0) {
00229 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00230 }
00231
break;
00232 }
00233
case LITERAL_interface:
00234 {
00235
interfaceDefinition(m_AST);
00236
if (inputState->guessing==0) {
00237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00238 }
00239
break;
00240 }
00241
default:
00242 {
00243
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00244 }
00245 }
00246 }
00247 typeDefinition_AST = (currentAST.
root);
00248
break;
00249 }
00250
case SEMI:
00251 {
00252 match(SEMI);
00253 typeDefinition_AST = (currentAST.
root);
00254
break;
00255 }
00256
default:
00257 {
00258
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00259 }
00260 }
00261 }
00262
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00263
if( inputState->guessing == 0 ) {
00264
reportError(ex);
00265 consume();
00266 consumeUntil(
_tokenSet_3);
00267 }
else {
00268
throw;
00269 }
00270 }
00271
returnAST = typeDefinition_AST;
00272 }
00273
00274 void JavaRecognizer::identifier() {
00275
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00276
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00277
RefJavaAST identifier_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00278
00279
try {
00280
RefJavaAST tmp5_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00281
if ( inputState->guessing == 0 ) {
00282 tmp5_AST = astFactory->create(LT(1));
00283 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp5_AST.get()));
00284 }
00285 match(IDENT);
00286 {
00287
for (;;) {
00288
if ((LA(1) == DOT)) {
00289
RefJavaAST tmp6_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00290
if ( inputState->guessing == 0 ) {
00291 tmp6_AST = astFactory->create(LT(1));
00292 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp6_AST.get()));
00293 }
00294 match(DOT);
00295
RefJavaAST tmp7_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00296
if ( inputState->guessing == 0 ) {
00297 tmp7_AST = astFactory->create(LT(1));
00298 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp7_AST.get()));
00299 }
00300 match(IDENT);
00301 }
00302
else {
00303
goto _loop23;
00304 }
00305
00306 }
00307 _loop23:;
00308 }
00309 identifier_AST = (currentAST.
root);
00310 }
00311
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00312
if( inputState->guessing == 0 ) {
00313
reportError(ex);
00314 consume();
00315 consumeUntil(
_tokenSet_4);
00316 }
else {
00317
throw;
00318 }
00319 }
00320
returnAST = identifier_AST;
00321 }
00322
00323 void JavaRecognizer::identifierStar() {
00324
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00325
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00326
RefJavaAST identifierStar_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00327
00328
try {
00329
RefJavaAST tmp8_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00330
if ( inputState->guessing == 0 ) {
00331 tmp8_AST = astFactory->create(LT(1));
00332 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp8_AST.get()));
00333 }
00334 match(IDENT);
00335 {
00336
for (;;) {
00337
if ((LA(1) == DOT) && (LA(2) == IDENT)) {
00338
RefJavaAST tmp9_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00339
if ( inputState->guessing == 0 ) {
00340 tmp9_AST = astFactory->create(LT(1));
00341 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp9_AST.get()));
00342 }
00343 match(DOT);
00344
RefJavaAST tmp10_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00345
if ( inputState->guessing == 0 ) {
00346 tmp10_AST = astFactory->create(LT(1));
00347 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp10_AST.get()));
00348 }
00349 match(IDENT);
00350 }
00351
else {
00352
goto _loop26;
00353 }
00354
00355 }
00356 _loop26:;
00357 }
00358 {
00359
switch ( LA(1)) {
00360
case DOT:
00361 {
00362
RefJavaAST tmp11_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00363
if ( inputState->guessing == 0 ) {
00364 tmp11_AST = astFactory->create(LT(1));
00365 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp11_AST.get()));
00366 }
00367 match(DOT);
00368
RefJavaAST tmp12_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00369
if ( inputState->guessing == 0 ) {
00370 tmp12_AST = astFactory->create(LT(1));
00371 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp12_AST.get()));
00372 }
00373 match(STAR);
00374
break;
00375 }
00376
case SEMI:
00377 {
00378
break;
00379 }
00380
default:
00381 {
00382
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00383 }
00384 }
00385 }
00386 identifierStar_AST = (currentAST.
root);
00387 }
00388
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00389
if( inputState->guessing == 0 ) {
00390
reportError(ex);
00391 consume();
00392 consumeUntil(
_tokenSet_5);
00393 }
else {
00394
throw;
00395 }
00396 }
00397
returnAST = identifierStar_AST;
00398 }
00399
00400 void JavaRecognizer::modifiers() {
00401
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00402
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00403
RefJavaAST modifiers_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00404
00405
try {
00406 {
00407
for (;;) {
00408
if ((
_tokenSet_6.member(LA(1)))) {
00409
modifier();
00410
if (inputState->guessing==0) {
00411 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00412 }
00413 }
00414
else {
00415
goto _loop30;
00416 }
00417
00418 }
00419 _loop30:;
00420 }
00421
if ( inputState->guessing==0 ) {
00422 modifiers_AST =
RefJavaAST(currentAST.
root);
00423
#line 290 "java.g"
00424
modifiers_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(modifiers_AST.get()))));
00425
#line 426 "JavaRecognizer.cpp"
00426
currentAST.
root = modifiers_AST;
00427
if ( modifiers_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00428 modifiers_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00429 currentAST.
child = modifiers_AST->getFirstChild();
00430
else
00431 currentAST.
child = modifiers_AST;
00432 currentAST.
advanceChildToEnd();
00433 }
00434 modifiers_AST = (currentAST.
root);
00435 }
00436
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00437
if( inputState->guessing == 0 ) {
00438
reportError(ex);
00439 consume();
00440 consumeUntil(
_tokenSet_7);
00441 }
else {
00442
throw;
00443 }
00444 }
00445
returnAST = modifiers_AST;
00446 }
00447
00448 void JavaRecognizer::classDefinition(
00449 RefJavaAST modifiers
00450 ) {
00451
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00452
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00453
RefJavaAST classDefinition_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00454
RefJavaAST sc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00455
RefJavaAST ic_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00456
RefJavaAST cb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00457
00458
try {
00459 match(LITERAL_class);
00460
RefJavaAST tmp14_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00461
if ( inputState->guessing == 0 ) {
00462 tmp14_AST = astFactory->create(LT(1));
00463 }
00464 match(IDENT);
00465
superClassClause();
00466
if (inputState->guessing==0) {
00467 sc_AST =
returnAST;
00468 }
00469
implementsClause();
00470
if (inputState->guessing==0) {
00471 ic_AST =
returnAST;
00472 }
00473
classBlock();
00474
if (inputState->guessing==0) {
00475 cb_AST =
returnAST;
00476 }
00477
if ( inputState->guessing==0 ) {
00478 classDefinition_AST =
RefJavaAST(currentAST.
root);
00479
#line 319 "java.g"
00480
classDefinition_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(6))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CLASS_DEF,
"CLASS_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(modifiers.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp14_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(sc_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(ic_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cb_AST.get()))));
00481
#line 482 "JavaRecognizer.cpp"
00482
currentAST.
root = classDefinition_AST;
00483
if ( classDefinition_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00484 classDefinition_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00485 currentAST.
child = classDefinition_AST->getFirstChild();
00486
else
00487 currentAST.
child = classDefinition_AST;
00488 currentAST.
advanceChildToEnd();
00489 }
00490 }
00491
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00492
if( inputState->guessing == 0 ) {
00493
reportError(ex);
00494 consume();
00495 consumeUntil(
_tokenSet_8);
00496 }
else {
00497
throw;
00498 }
00499 }
00500
returnAST = classDefinition_AST;
00501 }
00502
00503 void JavaRecognizer::interfaceDefinition(
00504 RefJavaAST modifiers
00505 ) {
00506
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00507
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00508
RefJavaAST interfaceDefinition_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00509
RefJavaAST ie_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00510
RefJavaAST cb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00511
00512
try {
00513 match(LITERAL_interface);
00514
RefJavaAST tmp16_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00515
if ( inputState->guessing == 0 ) {
00516 tmp16_AST = astFactory->create(LT(1));
00517 }
00518 match(IDENT);
00519
interfaceExtends();
00520
if (inputState->guessing==0) {
00521 ie_AST =
returnAST;
00522 }
00523
classBlock();
00524
if (inputState->guessing==0) {
00525 cb_AST =
returnAST;
00526 }
00527
if ( inputState->guessing==0 ) {
00528 interfaceDefinition_AST =
RefJavaAST(currentAST.
root);
00529
#line 335 "java.g"
00530
interfaceDefinition_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(5))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(INTERFACE_DEF,
"INTERFACE_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(modifiers.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp16_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(ie_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cb_AST.get()))));
00531
#line 532 "JavaRecognizer.cpp"
00532
currentAST.
root = interfaceDefinition_AST;
00533
if ( interfaceDefinition_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00534 interfaceDefinition_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00535 currentAST.
child = interfaceDefinition_AST->getFirstChild();
00536
else
00537 currentAST.
child = interfaceDefinition_AST;
00538 currentAST.
advanceChildToEnd();
00539 }
00540 }
00541
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00542
if( inputState->guessing == 0 ) {
00543
reportError(ex);
00544 consume();
00545 consumeUntil(
_tokenSet_9);
00546 }
else {
00547
throw;
00548 }
00549 }
00550
returnAST = interfaceDefinition_AST;
00551 }
00552
00556 void JavaRecognizer::declaration() {
00557
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00558
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00559
RefJavaAST declaration_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00560
RefJavaAST m_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00561
RefJavaAST t_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00562
RefJavaAST v_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00563
00564
try {
00565
modifiers();
00566
if (inputState->guessing==0) {
00567 m_AST =
returnAST;
00568 }
00569
typeSpec(
false);
00570
if (inputState->guessing==0) {
00571 t_AST =
returnAST;
00572 }
00573
variableDefinitions(m_AST,t_AST);
00574
if (inputState->guessing==0) {
00575 v_AST =
returnAST;
00576 }
00577
if ( inputState->guessing==0 ) {
00578 declaration_AST =
RefJavaAST(currentAST.
root);
00579
#line 220 "java.g"
00580
declaration_AST = v_AST;
00581
#line 582 "JavaRecognizer.cpp"
00582
currentAST.
root = declaration_AST;
00583
if ( declaration_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00584 declaration_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00585 currentAST.
child = declaration_AST->getFirstChild();
00586
else
00587 currentAST.
child = declaration_AST;
00588 currentAST.
advanceChildToEnd();
00589 }
00590 }
00591
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00592
if( inputState->guessing == 0 ) {
00593
reportError(ex);
00594 consume();
00595 consumeUntil(
_tokenSet_5);
00596 }
else {
00597
throw;
00598 }
00599 }
00600
returnAST = declaration_AST;
00601 }
00602
00603 void JavaRecognizer::typeSpec(
00604
bool addImagNode
00605 ) {
00606
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00607
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00608
RefJavaAST typeSpec_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00609
00610
try {
00611
switch ( LA(1)) {
00612
case IDENT:
00613 {
00614
classTypeSpec(addImagNode);
00615
if (inputState->guessing==0) {
00616 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00617 }
00618 typeSpec_AST = (currentAST.
root);
00619
break;
00620 }
00621
case LITERAL_void:
00622
case LITERAL_boolean:
00623
case LITERAL_byte:
00624
case LITERAL_char:
00625
case LITERAL_short:
00626
case LITERAL_int:
00627
case LITERAL_float:
00628
case LITERAL_long:
00629
case LITERAL_double:
00630 {
00631
builtInTypeSpec(addImagNode);
00632
if (inputState->guessing==0) {
00633 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00634 }
00635 typeSpec_AST = (currentAST.
root);
00636
break;
00637 }
00638
default:
00639 {
00640
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00641 }
00642 }
00643 }
00644
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00645
if( inputState->guessing == 0 ) {
00646
reportError(ex);
00647 consume();
00648 consumeUntil(
_tokenSet_10);
00649 }
else {
00650
throw;
00651 }
00652 }
00653
returnAST = typeSpec_AST;
00654 }
00655
00656 void JavaRecognizer::variableDefinitions(
00657 RefJavaAST mods, RefJavaAST t
00658 ) {
00659
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00660
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00661
RefJavaAST variableDefinitions_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00662
00663
try {
00664
variableDeclarator((
RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)mods),
00665 (
RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)t));
00666
if (inputState->guessing==0) {
00667 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00668 }
00669 {
00670
for (;;) {
00671
if ((LA(1) == COMMA)) {
00672 match(COMMA);
00673
variableDeclarator((
RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)mods),
00674 (
RefJavaAST)getASTFactory()->dupTree((antlr::RefAST)t));
00675
if (inputState->guessing==0) {
00676 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00677 }
00678 }
00679
else {
00680
goto _loop59;
00681 }
00682
00683 }
00684 _loop59:;
00685 }
00686 variableDefinitions_AST = (currentAST.
root);
00687 }
00688
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00689
if( inputState->guessing == 0 ) {
00690
reportError(ex);
00691 consume();
00692 consumeUntil(
_tokenSet_5);
00693 }
else {
00694
throw;
00695 }
00696 }
00697
returnAST = variableDefinitions_AST;
00698 }
00699
00700 void JavaRecognizer::classTypeSpec(
00701
bool addImagNode
00702 ) {
00703
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00704
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00705
RefJavaAST classTypeSpec_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00706
ANTLR_USE_NAMESPACE(antlr)
RefToken lb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00707
RefJavaAST lb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00708
00709
try {
00710
identifier();
00711
if (inputState->guessing==0) {
00712 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00713 }
00714 {
00715
for (;;) {
00716
if ((LA(1) == LBRACK)) {
00717 lb = LT(1);
00718
if ( inputState->guessing == 0 ) {
00719 lb_AST = astFactory->create(lb);
00720 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lb_AST.get()));
00721 }
00722 match(LBRACK);
00723
if ( inputState->guessing==0 ) {
00724
#line 233 "java.g"
00725
lb_AST->setType(ARRAY_DECLARATOR);
00726
#line 727 "JavaRecognizer.cpp"
00727
}
00728 match(RBRACK);
00729 }
00730
else {
00731
goto _loop15;
00732 }
00733
00734 }
00735 _loop15:;
00736 }
00737
if ( inputState->guessing==0 ) {
00738 classTypeSpec_AST =
RefJavaAST(currentAST.
root);
00739
#line 234 "java.g"
00740
00741
if ( addImagNode ) {
00742 classTypeSpec_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TYPE,
"TYPE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(classTypeSpec_AST.get()))));
00743 }
00744
00745
#line 746 "JavaRecognizer.cpp"
00746
currentAST.
root = classTypeSpec_AST;
00747
if ( classTypeSpec_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00748 classTypeSpec_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00749 currentAST.
child = classTypeSpec_AST->getFirstChild();
00750
else
00751 currentAST.
child = classTypeSpec_AST;
00752 currentAST.
advanceChildToEnd();
00753 }
00754 classTypeSpec_AST = (currentAST.
root);
00755 }
00756
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00757
if( inputState->guessing == 0 ) {
00758
reportError(ex);
00759 consume();
00760 consumeUntil(
_tokenSet_10);
00761 }
else {
00762
throw;
00763 }
00764 }
00765
returnAST = classTypeSpec_AST;
00766 }
00767
00768 void JavaRecognizer::builtInTypeSpec(
00769
bool addImagNode
00770 ) {
00771
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00772
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00773
RefJavaAST builtInTypeSpec_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00774
ANTLR_USE_NAMESPACE(antlr)
RefToken lb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00775
RefJavaAST lb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00776
00777
try {
00778
builtInType();
00779
if (inputState->guessing==0) {
00780 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00781 }
00782 {
00783
for (;;) {
00784
if ((LA(1) == LBRACK)) {
00785 lb = LT(1);
00786
if ( inputState->guessing == 0 ) {
00787 lb_AST = astFactory->create(lb);
00788 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lb_AST.get()));
00789 }
00790 match(LBRACK);
00791
if ( inputState->guessing==0 ) {
00792
#line 244 "java.g"
00793
lb_AST->setType(ARRAY_DECLARATOR);
00794
#line 795 "JavaRecognizer.cpp"
00795
}
00796 match(RBRACK);
00797 }
00798
else {
00799
goto _loop18;
00800 }
00801
00802 }
00803 _loop18:;
00804 }
00805
if ( inputState->guessing==0 ) {
00806 builtInTypeSpec_AST =
RefJavaAST(currentAST.
root);
00807
#line 245 "java.g"
00808
00809
if ( addImagNode ) {
00810 builtInTypeSpec_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TYPE,
"TYPE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(builtInTypeSpec_AST.get()))));
00811 }
00812
00813
#line 814 "JavaRecognizer.cpp"
00814
currentAST.
root = builtInTypeSpec_AST;
00815
if ( builtInTypeSpec_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00816 builtInTypeSpec_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00817 currentAST.
child = builtInTypeSpec_AST->getFirstChild();
00818
else
00819 currentAST.
child = builtInTypeSpec_AST;
00820 currentAST.
advanceChildToEnd();
00821 }
00822 builtInTypeSpec_AST = (currentAST.
root);
00823 }
00824
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00825
if( inputState->guessing == 0 ) {
00826
reportError(ex);
00827 consume();
00828 consumeUntil(
_tokenSet_10);
00829 }
else {
00830
throw;
00831 }
00832 }
00833
returnAST = builtInTypeSpec_AST;
00834 }
00835
00836 void JavaRecognizer::builtInType() {
00837
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00838
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00839
RefJavaAST builtInType_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00840
00841
try {
00842
switch ( LA(1)) {
00843
case LITERAL_void:
00844 {
00845
RefJavaAST tmp20_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00846
if ( inputState->guessing == 0 ) {
00847 tmp20_AST = astFactory->create(LT(1));
00848 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp20_AST.get()));
00849 }
00850 match(LITERAL_void);
00851 builtInType_AST = (currentAST.
root);
00852
break;
00853 }
00854
case LITERAL_boolean:
00855 {
00856
RefJavaAST tmp21_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00857
if ( inputState->guessing == 0 ) {
00858 tmp21_AST = astFactory->create(LT(1));
00859 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp21_AST.get()));
00860 }
00861 match(LITERAL_boolean);
00862 builtInType_AST = (currentAST.
root);
00863
break;
00864 }
00865
case LITERAL_byte:
00866 {
00867
RefJavaAST tmp22_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00868
if ( inputState->guessing == 0 ) {
00869 tmp22_AST = astFactory->create(LT(1));
00870 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp22_AST.get()));
00871 }
00872 match(LITERAL_byte);
00873 builtInType_AST = (currentAST.
root);
00874
break;
00875 }
00876
case LITERAL_char:
00877 {
00878
RefJavaAST tmp23_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00879
if ( inputState->guessing == 0 ) {
00880 tmp23_AST = astFactory->create(LT(1));
00881 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp23_AST.get()));
00882 }
00883 match(LITERAL_char);
00884 builtInType_AST = (currentAST.
root);
00885
break;
00886 }
00887
case LITERAL_short:
00888 {
00889
RefJavaAST tmp24_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00890
if ( inputState->guessing == 0 ) {
00891 tmp24_AST = astFactory->create(LT(1));
00892 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp24_AST.get()));
00893 }
00894 match(LITERAL_short);
00895 builtInType_AST = (currentAST.
root);
00896
break;
00897 }
00898
case LITERAL_int:
00899 {
00900
RefJavaAST tmp25_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00901
if ( inputState->guessing == 0 ) {
00902 tmp25_AST = astFactory->create(LT(1));
00903 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp25_AST.get()));
00904 }
00905 match(LITERAL_int);
00906 builtInType_AST = (currentAST.
root);
00907
break;
00908 }
00909
case LITERAL_float:
00910 {
00911
RefJavaAST tmp26_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00912
if ( inputState->guessing == 0 ) {
00913 tmp26_AST = astFactory->create(LT(1));
00914 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp26_AST.get()));
00915 }
00916 match(LITERAL_float);
00917 builtInType_AST = (currentAST.
root);
00918
break;
00919 }
00920
case LITERAL_long:
00921 {
00922
RefJavaAST tmp27_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00923
if ( inputState->guessing == 0 ) {
00924 tmp27_AST = astFactory->create(LT(1));
00925 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp27_AST.get()));
00926 }
00927 match(LITERAL_long);
00928 builtInType_AST = (currentAST.
root);
00929
break;
00930 }
00931
case LITERAL_double:
00932 {
00933
RefJavaAST tmp28_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00934
if ( inputState->guessing == 0 ) {
00935 tmp28_AST = astFactory->create(LT(1));
00936 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp28_AST.get()));
00937 }
00938 match(LITERAL_double);
00939 builtInType_AST = (currentAST.
root);
00940
break;
00941 }
00942
default:
00943 {
00944
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00945 }
00946 }
00947 }
00948
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00949
if( inputState->guessing == 0 ) {
00950
reportError(ex);
00951 consume();
00952 consumeUntil(
_tokenSet_11);
00953 }
else {
00954
throw;
00955 }
00956 }
00957
returnAST = builtInType_AST;
00958 }
00959
00960 void JavaRecognizer::type() {
00961
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00962
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00963
RefJavaAST type_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00964
00965
try {
00966
switch ( LA(1)) {
00967
case IDENT:
00968 {
00969
identifier();
00970
if (inputState->guessing==0) {
00971 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00972 }
00973 type_AST = (currentAST.
root);
00974
break;
00975 }
00976
case LITERAL_void:
00977
case LITERAL_boolean:
00978
case LITERAL_byte:
00979
case LITERAL_char:
00980
case LITERAL_short:
00981
case LITERAL_int:
00982
case LITERAL_float:
00983
case LITERAL_long:
00984
case LITERAL_double:
00985 {
00986
builtInType();
00987
if (inputState->guessing==0) {
00988 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00989 }
00990 type_AST = (currentAST.
root);
00991
break;
00992 }
00993
default:
00994 {
00995
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00996 }
00997 }
00998 }
00999
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01000
if( inputState->guessing == 0 ) {
01001
reportError(ex);
01002 consume();
01003 consumeUntil(
_tokenSet_12);
01004 }
else {
01005
throw;
01006 }
01007 }
01008
returnAST = type_AST;
01009 }
01010
01011 void JavaRecognizer::modifier() {
01012
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01013
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01014
RefJavaAST modifier_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01015
01016
try {
01017
switch ( LA(1)) {
01018
case LITERAL_private:
01019 {
01020
RefJavaAST tmp29_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01021
if ( inputState->guessing == 0 ) {
01022 tmp29_AST = astFactory->create(LT(1));
01023 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp29_AST.get()));
01024 }
01025 match(LITERAL_private);
01026 modifier_AST = (currentAST.
root);
01027
break;
01028 }
01029
case LITERAL_public:
01030 {
01031
RefJavaAST tmp30_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01032
if ( inputState->guessing == 0 ) {
01033 tmp30_AST = astFactory->create(LT(1));
01034 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp30_AST.get()));
01035 }
01036 match(LITERAL_public);
01037 modifier_AST = (currentAST.
root);
01038
break;
01039 }
01040
case LITERAL_protected:
01041 {
01042
RefJavaAST tmp31_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01043
if ( inputState->guessing == 0 ) {
01044 tmp31_AST = astFactory->create(LT(1));
01045 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp31_AST.get()));
01046 }
01047 match(LITERAL_protected);
01048 modifier_AST = (currentAST.
root);
01049
break;
01050 }
01051
case LITERAL_static:
01052 {
01053
RefJavaAST tmp32_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01054
if ( inputState->guessing == 0 ) {
01055 tmp32_AST = astFactory->create(LT(1));
01056 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp32_AST.get()));
01057 }
01058 match(LITERAL_static);
01059 modifier_AST = (currentAST.
root);
01060
break;
01061 }
01062
case LITERAL_transient:
01063 {
01064
RefJavaAST tmp33_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01065
if ( inputState->guessing == 0 ) {
01066 tmp33_AST = astFactory->create(LT(1));
01067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp33_AST.get()));
01068 }
01069 match(LITERAL_transient);
01070 modifier_AST = (currentAST.
root);
01071
break;
01072 }
01073
case FINAL:
01074 {
01075
RefJavaAST tmp34_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01076
if ( inputState->guessing == 0 ) {
01077 tmp34_AST = astFactory->create(LT(1));
01078 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp34_AST.get()));
01079 }
01080 match(FINAL);
01081 modifier_AST = (currentAST.
root);
01082
break;
01083 }
01084
case ABSTRACT:
01085 {
01086
RefJavaAST tmp35_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01087
if ( inputState->guessing == 0 ) {
01088 tmp35_AST = astFactory->create(LT(1));
01089 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp35_AST.get()));
01090 }
01091 match(ABSTRACT);
01092 modifier_AST = (currentAST.
root);
01093
break;
01094 }
01095
case LITERAL_native:
01096 {
01097
RefJavaAST tmp36_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01098
if ( inputState->guessing == 0 ) {
01099 tmp36_AST = astFactory->create(LT(1));
01100 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp36_AST.get()));
01101 }
01102 match(LITERAL_native);
01103 modifier_AST = (currentAST.
root);
01104
break;
01105 }
01106
case LITERAL_threadsafe:
01107 {
01108
RefJavaAST tmp37_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01109
if ( inputState->guessing == 0 ) {
01110 tmp37_AST = astFactory->create(LT(1));
01111 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp37_AST.get()));
01112 }
01113 match(LITERAL_threadsafe);
01114 modifier_AST = (currentAST.
root);
01115
break;
01116 }
01117
case LITERAL_synchronized:
01118 {
01119
RefJavaAST tmp38_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01120
if ( inputState->guessing == 0 ) {
01121 tmp38_AST = astFactory->create(LT(1));
01122 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp38_AST.get()));
01123 }
01124 match(LITERAL_synchronized);
01125 modifier_AST = (currentAST.
root);
01126
break;
01127 }
01128
case LITERAL_volatile:
01129 {
01130
RefJavaAST tmp39_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01131
if ( inputState->guessing == 0 ) {
01132 tmp39_AST = astFactory->create(LT(1));
01133 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp39_AST.get()));
01134 }
01135 match(LITERAL_volatile);
01136 modifier_AST = (currentAST.
root);
01137
break;
01138 }
01139
case STRICTFP:
01140 {
01141
RefJavaAST tmp40_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01142
if ( inputState->guessing == 0 ) {
01143 tmp40_AST = astFactory->create(LT(1));
01144 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp40_AST.get()));
01145 }
01146 match(STRICTFP);
01147 modifier_AST = (currentAST.
root);
01148
break;
01149 }
01150
default:
01151 {
01152
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01153 }
01154 }
01155 }
01156
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01157
if( inputState->guessing == 0 ) {
01158
reportError(ex);
01159 consume();
01160 consumeUntil(
_tokenSet_13);
01161 }
else {
01162
throw;
01163 }
01164 }
01165
returnAST = modifier_AST;
01166 }
01167
01168 void JavaRecognizer::superClassClause() {
01169
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01170
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01171
RefJavaAST superClassClause_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01172
RefJavaAST id_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01173
01174
try {
01175 {
01176
switch ( LA(1)) {
01177
case LITERAL_extends:
01178 {
01179 match(LITERAL_extends);
01180
identifier();
01181
if (inputState->guessing==0) {
01182 id_AST =
returnAST;
01183 }
01184
break;
01185 }
01186
case LCURLY:
01187
case LITERAL_implements:
01188 {
01189
break;
01190 }
01191
default:
01192 {
01193
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01194 }
01195 }
01196 }
01197
if ( inputState->guessing==0 ) {
01198 superClassClause_AST =
RefJavaAST(currentAST.
root);
01199
#line 325 "java.g"
01200
superClassClause_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXTENDS_CLAUSE,
"EXTENDS_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(id_AST.get()))));
01201
#line 1202 "JavaRecognizer.cpp"
01202
currentAST.
root = superClassClause_AST;
01203
if ( superClassClause_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01204 superClassClause_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01205 currentAST.
child = superClassClause_AST->getFirstChild();
01206
else
01207 currentAST.
child = superClassClause_AST;
01208 currentAST.
advanceChildToEnd();
01209 }
01210 }
01211
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01212
if( inputState->guessing == 0 ) {
01213
reportError(ex);
01214 consume();
01215 consumeUntil(
_tokenSet_14);
01216 }
else {
01217
throw;
01218 }
01219 }
01220
returnAST = superClassClause_AST;
01221 }
01222
01223 void JavaRecognizer::implementsClause() {
01224
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01225
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01226
RefJavaAST implementsClause_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01227
ANTLR_USE_NAMESPACE(antlr)
RefToken i =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01228
RefJavaAST i_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01229
01230
try {
01231 {
01232
switch ( LA(1)) {
01233
case LITERAL_implements:
01234 {
01235 i = LT(1);
01236
if ( inputState->guessing == 0 ) {
01237 i_AST = astFactory->create(i);
01238 }
01239 match(LITERAL_implements);
01240
identifier();
01241
if (inputState->guessing==0) {
01242 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01243 }
01244 {
01245
for (;;) {
01246
if ((LA(1) == COMMA)) {
01247 match(COMMA);
01248
identifier();
01249
if (inputState->guessing==0) {
01250 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01251 }
01252 }
01253
else {
01254
goto _loop46;
01255 }
01256
01257 }
01258 _loop46:;
01259 }
01260
break;
01261 }
01262
case LCURLY:
01263 {
01264
break;
01265 }
01266
default:
01267 {
01268
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01269 }
01270 }
01271 }
01272
if ( inputState->guessing==0 ) {
01273 implementsClause_AST =
RefJavaAST(currentAST.
root);
01274
#line 363 "java.g"
01275
implementsClause_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(IMPLEMENTS_CLAUSE,
"IMPLEMENTS_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(implementsClause_AST.get()))));
01276
#line 1277 "JavaRecognizer.cpp"
01277
currentAST.
root = implementsClause_AST;
01278
if ( implementsClause_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01279 implementsClause_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01280 currentAST.
child = implementsClause_AST->getFirstChild();
01281
else
01282 currentAST.
child = implementsClause_AST;
01283 currentAST.
advanceChildToEnd();
01284 }
01285 implementsClause_AST = (currentAST.
root);
01286 }
01287
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01288
if( inputState->guessing == 0 ) {
01289
reportError(ex);
01290 consume();
01291 consumeUntil(
_tokenSet_15);
01292 }
else {
01293
throw;
01294 }
01295 }
01296
returnAST = implementsClause_AST;
01297 }
01298
01299 void JavaRecognizer::classBlock() {
01300
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01301
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01302
RefJavaAST classBlock_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01303
01304
try {
01305 match(LCURLY);
01306 {
01307
for (;;) {
01308
switch ( LA(1)) {
01309
case FINAL:
01310
case ABSTRACT:
01311
case STRICTFP:
01312
case LITERAL_void:
01313
case LITERAL_boolean:
01314
case LITERAL_byte:
01315
case LITERAL_char:
01316
case LITERAL_short:
01317
case LITERAL_int:
01318
case LITERAL_float:
01319
case LITERAL_long:
01320
case LITERAL_double:
01321
case IDENT:
01322
case LITERAL_private:
01323
case LITERAL_public:
01324
case LITERAL_protected:
01325
case LITERAL_static:
01326
case LITERAL_transient:
01327
case LITERAL_native:
01328
case LITERAL_threadsafe:
01329
case LITERAL_synchronized:
01330
case LITERAL_volatile:
01331
case LITERAL_class:
01332
case LITERAL_interface:
01333
case LCURLY:
01334 {
01335
field();
01336
if (inputState->guessing==0) {
01337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01338 }
01339
break;
01340 }
01341
case SEMI:
01342 {
01343 match(SEMI);
01344
break;
01345 }
01346
default:
01347 {
01348
goto _loop38;
01349 }
01350 }
01351 }
01352 _loop38:;
01353 }
01354 match(RCURLY);
01355
if ( inputState->guessing==0 ) {
01356 classBlock_AST =
RefJavaAST(currentAST.
root);
01357
#line 345 "java.g"
01358
classBlock_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(OBJBLOCK,
"OBJBLOCK").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(classBlock_AST.get()))));
01359
#line 1360 "JavaRecognizer.cpp"
01360
currentAST.
root = classBlock_AST;
01361
if ( classBlock_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01362 classBlock_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01363 currentAST.
child = classBlock_AST->getFirstChild();
01364
else
01365 currentAST.
child = classBlock_AST;
01366 currentAST.
advanceChildToEnd();
01367 }
01368 classBlock_AST = (currentAST.
root);
01369 }
01370
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01371
if( inputState->guessing == 0 ) {
01372
reportError(ex);
01373 consume();
01374 consumeUntil(
_tokenSet_16);
01375 }
else {
01376
throw;
01377 }
01378 }
01379
returnAST = classBlock_AST;
01380 }
01381
01382 void JavaRecognizer::interfaceExtends() {
01383
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01384
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01385
RefJavaAST interfaceExtends_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01386
ANTLR_USE_NAMESPACE(antlr)
RefToken e =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01387
RefJavaAST e_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01388
01389
try {
01390 {
01391
switch ( LA(1)) {
01392
case LITERAL_extends:
01393 {
01394 e = LT(1);
01395
if ( inputState->guessing == 0 ) {
01396 e_AST = astFactory->create(e);
01397 }
01398 match(LITERAL_extends);
01399
identifier();
01400
if (inputState->guessing==0) {
01401 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01402 }
01403 {
01404
for (;;) {
01405
if ((LA(1) == COMMA)) {
01406 match(COMMA);
01407
identifier();
01408
if (inputState->guessing==0) {
01409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01410 }
01411 }
01412
else {
01413
goto _loop42;
01414 }
01415
01416 }
01417 _loop42:;
01418 }
01419
break;
01420 }
01421
case LCURLY:
01422 {
01423
break;
01424 }
01425
default:
01426 {
01427
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01428 }
01429 }
01430 }
01431
if ( inputState->guessing==0 ) {
01432 interfaceExtends_AST =
RefJavaAST(currentAST.
root);
01433
#line 354 "java.g"
01434
interfaceExtends_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXTENDS_CLAUSE,
"EXTENDS_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(interfaceExtends_AST.get()))));
01435
#line 1436 "JavaRecognizer.cpp"
01436
currentAST.
root = interfaceExtends_AST;
01437
if ( interfaceExtends_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01438 interfaceExtends_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01439 currentAST.
child = interfaceExtends_AST->getFirstChild();
01440
else
01441 currentAST.
child = interfaceExtends_AST;
01442 currentAST.
advanceChildToEnd();
01443 }
01444 interfaceExtends_AST = (currentAST.
root);
01445 }
01446
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01447
if( inputState->guessing == 0 ) {
01448
reportError(ex);
01449 consume();
01450 consumeUntil(
_tokenSet_15);
01451 }
else {
01452
throw;
01453 }
01454 }
01455
returnAST = interfaceExtends_AST;
01456 }
01457
01458 void JavaRecognizer::field() {
01459
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01460
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01461
RefJavaAST field_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01462
RefJavaAST mods_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01463
RefJavaAST h_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01464
RefJavaAST s_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01465
RefJavaAST cd_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01466
RefJavaAST id_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01467
RefJavaAST t_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01468
RefJavaAST param_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01469
RefJavaAST rt_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01470
RefJavaAST tc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01471
RefJavaAST s2_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01472
RefJavaAST v_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01473
RefJavaAST s3_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01474
RefJavaAST s4_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01475
01476
try {
01477
if ((
_tokenSet_13.member(LA(1))) && (
_tokenSet_17.member(LA(2)))) {
01478
modifiers();
01479
if (inputState->guessing==0) {
01480 mods_AST =
returnAST;
01481 }
01482 {
01483
switch ( LA(1)) {
01484
case LITERAL_class:
01485 {
01486
classDefinition(mods_AST);
01487
if (inputState->guessing==0) {
01488 cd_AST =
returnAST;
01489 }
01490
if ( inputState->guessing==0 ) {
01491 field_AST =
RefJavaAST(currentAST.
root);
01492
#line 378 "java.g"
01493
field_AST = cd_AST;
01494
#line 1495 "JavaRecognizer.cpp"
01495
currentAST.
root = field_AST;
01496
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01497 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01498 currentAST.
child = field_AST->getFirstChild();
01499
else
01500 currentAST.
child = field_AST;
01501 currentAST.
advanceChildToEnd();
01502 }
01503
break;
01504 }
01505
case LITERAL_interface:
01506 {
01507
interfaceDefinition(mods_AST);
01508
if (inputState->guessing==0) {
01509 id_AST =
returnAST;
01510 }
01511
if ( inputState->guessing==0 ) {
01512 field_AST =
RefJavaAST(currentAST.
root);
01513
#line 381 "java.g"
01514
field_AST = id_AST;
01515
#line 1516 "JavaRecognizer.cpp"
01516
currentAST.
root = field_AST;
01517
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01518 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01519 currentAST.
child = field_AST->getFirstChild();
01520
else
01521 currentAST.
child = field_AST;
01522 currentAST.
advanceChildToEnd();
01523 }
01524
break;
01525 }
01526
default:
01527
if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
01528
ctorHead();
01529
if (inputState->guessing==0) {
01530 h_AST =
returnAST;
01531 }
01532
constructorBody();
01533
if (inputState->guessing==0) {
01534 s_AST =
returnAST;
01535 }
01536
if ( inputState->guessing==0 ) {
01537 field_AST =
RefJavaAST(currentAST.
root);
01538
#line 375 "java.g"
01539
field_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(4))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CTOR_DEF,
"CTOR_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mods_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(h_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()))));
01540
#line 1541 "JavaRecognizer.cpp"
01541
currentAST.
root = field_AST;
01542
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01543 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01544 currentAST.
child = field_AST->getFirstChild();
01545
else
01546 currentAST.
child = field_AST;
01547 currentAST.
advanceChildToEnd();
01548 }
01549 }
01550
else if (((LA(1) >= LITERAL_void && LA(1) <= IDENT)) && (
_tokenSet_18.member(LA(2)))) {
01551
typeSpec(
false);
01552
if (inputState->guessing==0) {
01553 t_AST =
returnAST;
01554 }
01555 {
01556
if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
01557
RefJavaAST tmp47_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01558
if ( inputState->guessing == 0 ) {
01559 tmp47_AST = astFactory->create(LT(1));
01560 }
01561 match(IDENT);
01562 match(LPAREN);
01563
parameterDeclarationList();
01564
if (inputState->guessing==0) {
01565 param_AST =
returnAST;
01566 }
01567 match(RPAREN);
01568
declaratorBrackets(t_AST);
01569
if (inputState->guessing==0) {
01570 rt_AST =
returnAST;
01571 }
01572 {
01573
switch ( LA(1)) {
01574
case LITERAL_throws:
01575 {
01576
throwsClause();
01577
if (inputState->guessing==0) {
01578 tc_AST =
returnAST;
01579 }
01580
break;
01581 }
01582
case SEMI:
01583
case LCURLY:
01584 {
01585
break;
01586 }
01587
default:
01588 {
01589
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01590 }
01591 }
01592 }
01593 {
01594
switch ( LA(1)) {
01595
case LCURLY:
01596 {
01597
compoundStatement();
01598
if (inputState->guessing==0) {
01599 s2_AST =
returnAST;
01600 }
01601
break;
01602 }
01603
case SEMI:
01604 {
01605
RefJavaAST tmp50_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01606
if ( inputState->guessing == 0 ) {
01607 tmp50_AST = astFactory->create(LT(1));
01608 }
01609 match(SEMI);
01610
break;
01611 }
01612
default:
01613 {
01614
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01615 }
01616 }
01617 }
01618
if ( inputState->guessing==0 ) {
01619 field_AST =
RefJavaAST(currentAST.
root);
01620
#line 396 "java.g"
01621
field_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(7))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(METHOD_DEF,
"METHOD_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mods_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TYPE,
"TYPE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(rt_AST.get())))).get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp47_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(param_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tc_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s2_AST.get()))));
01622
#line 1623 "JavaRecognizer.cpp"
01623
currentAST.
root = field_AST;
01624
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01625 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01626 currentAST.
child = field_AST->getFirstChild();
01627
else
01628 currentAST.
child = field_AST;
01629 currentAST.
advanceChildToEnd();
01630 }
01631 }
01632
else if ((LA(1) == IDENT) && (
_tokenSet_19.member(LA(2)))) {
01633
variableDefinitions(mods_AST,t_AST);
01634
if (inputState->guessing==0) {
01635 v_AST =
returnAST;
01636 }
01637
RefJavaAST tmp51_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01638
if ( inputState->guessing == 0 ) {
01639 tmp51_AST = astFactory->create(LT(1));
01640 }
01641 match(SEMI);
01642
if ( inputState->guessing==0 ) {
01643 field_AST =
RefJavaAST(currentAST.
root);
01644
#line 405 "java.g"
01645
field_AST = v_AST;
01646
#line 1647 "JavaRecognizer.cpp"
01647
currentAST.
root = field_AST;
01648
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01649 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01650 currentAST.
child = field_AST->getFirstChild();
01651
else
01652 currentAST.
child = field_AST;
01653 currentAST.
advanceChildToEnd();
01654 }
01655 }
01656
else {
01657
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01658 }
01659
01660 }
01661 }
01662
else {
01663
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01664 }
01665 }
01666 }
01667 }
01668
else if ((LA(1) == LITERAL_static) && (LA(2) == LCURLY)) {
01669 match(LITERAL_static);
01670
compoundStatement();
01671
if (inputState->guessing==0) {
01672 s3_AST =
returnAST;
01673 }
01674
if ( inputState->guessing==0 ) {
01675 field_AST =
RefJavaAST(currentAST.
root);
01676
#line 411 "java.g"
01677
field_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(STATIC_INIT,
"STATIC_INIT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s3_AST.get()))));
01678
#line 1679 "JavaRecognizer.cpp"
01679
currentAST.
root = field_AST;
01680
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01681 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01682 currentAST.
child = field_AST->getFirstChild();
01683
else
01684 currentAST.
child = field_AST;
01685 currentAST.
advanceChildToEnd();
01686 }
01687 }
01688
else if ((LA(1) == LCURLY)) {
01689
compoundStatement();
01690
if (inputState->guessing==0) {
01691 s4_AST =
returnAST;
01692 }
01693
if ( inputState->guessing==0 ) {
01694 field_AST =
RefJavaAST(currentAST.
root);
01695
#line 415 "java.g"
01696
field_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(INSTANCE_INIT,
"INSTANCE_INIT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s4_AST.get()))));
01697
#line 1698 "JavaRecognizer.cpp"
01698
currentAST.
root = field_AST;
01699
if ( field_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01700 field_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01701 currentAST.
child = field_AST->getFirstChild();
01702
else
01703 currentAST.
child = field_AST;
01704 currentAST.
advanceChildToEnd();
01705 }
01706 }
01707
else {
01708
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01709 }
01710
01711 }
01712
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01713
if( inputState->guessing == 0 ) {
01714
reportError(ex);
01715 consume();
01716 consumeUntil(
_tokenSet_20);
01717 }
else {
01718
throw;
01719 }
01720 }
01721
returnAST = field_AST;
01722 }
01723
01724 void JavaRecognizer::ctorHead() {
01725
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01726
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01727
RefJavaAST ctorHead_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01728
01729
try {
01730
RefJavaAST tmp53_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01731
if ( inputState->guessing == 0 ) {
01732 tmp53_AST = astFactory->create(LT(1));
01733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp53_AST.get()));
01734 }
01735 match(IDENT);
01736 match(LPAREN);
01737
parameterDeclarationList();
01738
if (inputState->guessing==0) {
01739 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01740 }
01741 match(RPAREN);
01742 {
01743
switch ( LA(1)) {
01744
case LITERAL_throws:
01745 {
01746
throwsClause();
01747
if (inputState->guessing==0) {
01748 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01749 }
01750
break;
01751 }
01752
case LCURLY:
01753 {
01754
break;
01755 }
01756
default:
01757 {
01758
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01759 }
01760 }
01761 }
01762 ctorHead_AST = (currentAST.
root);
01763 }
01764
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01765
if( inputState->guessing == 0 ) {
01766
reportError(ex);
01767 consume();
01768 consumeUntil(
_tokenSet_15);
01769 }
else {
01770
throw;
01771 }
01772 }
01773
returnAST = ctorHead_AST;
01774 }
01775
01776 void JavaRecognizer::constructorBody() {
01777
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01778
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01779
RefJavaAST constructorBody_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01780
ANTLR_USE_NAMESPACE(antlr)
RefToken lc =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01781
RefJavaAST lc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01782
01783
try {
01784 lc = LT(1);
01785
if ( inputState->guessing == 0 ) {
01786 lc_AST = astFactory->create(lc);
01787 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lc_AST.get()));
01788 }
01789 match(LCURLY);
01790
if ( inputState->guessing==0 ) {
01791
#line 419 "java.g"
01792
lc_AST->setType(SLIST);
01793
#line 1794 "JavaRecognizer.cpp"
01794
}
01795 {
01796
if ((LA(1) == LITERAL_this || LA(1) == LITERAL_super) && (LA(2) == LPAREN)) {
01797
explicitConstructorInvocation();
01798
if (inputState->guessing==0) {
01799 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01800 }
01801 }
01802
else if ((
_tokenSet_21.member(LA(1))) && (
_tokenSet_22.member(LA(2)))) {
01803 }
01804
else {
01805
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01806 }
01807
01808 }
01809 {
01810
for (;;) {
01811
if ((
_tokenSet_23.member(LA(1)))) {
01812
statement();
01813
if (inputState->guessing==0) {
01814 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01815 }
01816 }
01817
else {
01818
goto _loop55;
01819 }
01820
01821 }
01822 _loop55:;
01823 }
01824 match(RCURLY);
01825 constructorBody_AST = (currentAST.
root);
01826 }
01827
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01828
if( inputState->guessing == 0 ) {
01829
reportError(ex);
01830 consume();
01831 consumeUntil(
_tokenSet_20);
01832 }
else {
01833
throw;
01834 }
01835 }
01836
returnAST = constructorBody_AST;
01837 }
01838
01839 void JavaRecognizer::parameterDeclarationList() {
01840
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01841
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01842
RefJavaAST parameterDeclarationList_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01843
01844
try {
01845 {
01846
switch ( LA(1)) {
01847
case FINAL:
01848
case LITERAL_void:
01849
case LITERAL_boolean:
01850
case LITERAL_byte:
01851
case LITERAL_char:
01852
case LITERAL_short:
01853
case LITERAL_int:
01854
case LITERAL_float:
01855
case LITERAL_long:
01856
case LITERAL_double:
01857
case IDENT:
01858 {
01859
parameterDeclaration();
01860
if (inputState->guessing==0) {
01861 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01862 }
01863 {
01864
for (;;) {
01865
if ((LA(1) == COMMA)) {
01866 match(COMMA);
01867
parameterDeclaration();
01868
if (inputState->guessing==0) {
01869 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01870 }
01871 }
01872
else {
01873
goto _loop80;
01874 }
01875
01876 }
01877 _loop80:;
01878 }
01879
break;
01880 }
01881
case RPAREN:
01882 {
01883
break;
01884 }
01885
default:
01886 {
01887
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01888 }
01889 }
01890 }
01891
if ( inputState->guessing==0 ) {
01892 parameterDeclarationList_AST =
RefJavaAST(currentAST.
root);
01893
#line 508 "java.g"
01894
parameterDeclarationList_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETERS,
"PARAMETERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(parameterDeclarationList_AST.get()))));
01895
#line 1896 "JavaRecognizer.cpp"
01896
currentAST.
root = parameterDeclarationList_AST;
01897
if ( parameterDeclarationList_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01898 parameterDeclarationList_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01899 currentAST.
child = parameterDeclarationList_AST->getFirstChild();
01900
else
01901 currentAST.
child = parameterDeclarationList_AST;
01902 currentAST.
advanceChildToEnd();
01903 }
01904 parameterDeclarationList_AST = (currentAST.
root);
01905 }
01906
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01907
if( inputState->guessing == 0 ) {
01908
reportError(ex);
01909 consume();
01910 consumeUntil(
_tokenSet_24);
01911 }
else {
01912
throw;
01913 }
01914 }
01915
returnAST = parameterDeclarationList_AST;
01916 }
01917
01918 void JavaRecognizer::declaratorBrackets(
01919 RefJavaAST typ
01920 ) {
01921
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01922
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01923
RefJavaAST declaratorBrackets_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01924
ANTLR_USE_NAMESPACE(antlr)
RefToken lb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01925
RefJavaAST lb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01926
01927
try {
01928
if ( inputState->guessing==0 ) {
01929 declaratorBrackets_AST =
RefJavaAST(currentAST.
root);
01930
#line 452 "java.g"
01931
declaratorBrackets_AST=typ;
01932
#line 1933 "JavaRecognizer.cpp"
01933
currentAST.
root = declaratorBrackets_AST;
01934
if ( declaratorBrackets_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01935 declaratorBrackets_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01936 currentAST.
child = declaratorBrackets_AST->getFirstChild();
01937
else
01938 currentAST.
child = declaratorBrackets_AST;
01939 currentAST.
advanceChildToEnd();
01940 }
01941 {
01942
for (;;) {
01943
if ((LA(1) == LBRACK)) {
01944 lb = LT(1);
01945
if ( inputState->guessing == 0 ) {
01946 lb_AST = astFactory->create(lb);
01947 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lb_AST.get()));
01948 }
01949 match(LBRACK);
01950
if ( inputState->guessing==0 ) {
01951
#line 453 "java.g"
01952
lb_AST->setType(ARRAY_DECLARATOR);
01953
#line 1954 "JavaRecognizer.cpp"
01954
}
01955 match(RBRACK);
01956 }
01957
else {
01958
goto _loop63;
01959 }
01960
01961 }
01962 _loop63:;
01963 }
01964 declaratorBrackets_AST = (currentAST.
root);
01965 }
01966
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01967
if( inputState->guessing == 0 ) {
01968
reportError(ex);
01969 consume();
01970 consumeUntil(
_tokenSet_25);
01971 }
else {
01972
throw;
01973 }
01974 }
01975
returnAST = declaratorBrackets_AST;
01976 }
01977
01978 void JavaRecognizer::throwsClause() {
01979
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01980
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01981
RefJavaAST throwsClause_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01982
01983
try {
01984
RefJavaAST tmp59_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01985
if ( inputState->guessing == 0 ) {
01986 tmp59_AST = astFactory->create(LT(1));
01987 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp59_AST.get()));
01988 }
01989 match(LITERAL_throws);
01990
identifier();
01991
if (inputState->guessing==0) {
01992 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01993 }
01994 {
01995
for (;;) {
01996
if ((LA(1) == COMMA)) {
01997 match(COMMA);
01998
identifier();
01999
if (inputState->guessing==0) {
02000 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02001 }
02002 }
02003
else {
02004
goto _loop76;
02005 }
02006
02007 }
02008 _loop76:;
02009 }
02010 throwsClause_AST = (currentAST.
root);
02011 }
02012
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02013
if( inputState->guessing == 0 ) {
02014
reportError(ex);
02015 consume();
02016 consumeUntil(
_tokenSet_26);
02017 }
else {
02018
throw;
02019 }
02020 }
02021
returnAST = throwsClause_AST;
02022 }
02023
02024 void JavaRecognizer::compoundStatement() {
02025
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02026
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02027
RefJavaAST compoundStatement_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02028
ANTLR_USE_NAMESPACE(antlr)
RefToken lc =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02029
RefJavaAST lc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02030
02031
try {
02032 lc = LT(1);
02033
if ( inputState->guessing == 0 ) {
02034 lc_AST = astFactory->create(lc);
02035 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lc_AST.get()));
02036 }
02037 match(LCURLY);
02038
if ( inputState->guessing==0 ) {
02039
#line 535 "java.g"
02040
lc_AST->setType(SLIST);
02041
#line 2042 "JavaRecognizer.cpp"
02042
}
02043 {
02044
for (;;) {
02045
if ((
_tokenSet_23.member(LA(1)))) {
02046
statement();
02047
if (inputState->guessing==0) {
02048 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02049 }
02050 }
02051
else {
02052
goto _loop86;
02053 }
02054
02055 }
02056 _loop86:;
02057 }
02058 match(RCURLY);
02059 compoundStatement_AST = (currentAST.
root);
02060 }
02061
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02062
if( inputState->guessing == 0 ) {
02063
reportError(ex);
02064 consume();
02065 consumeUntil(
_tokenSet_27);
02066 }
else {
02067
throw;
02068 }
02069 }
02070
returnAST = compoundStatement_AST;
02071 }
02072
02074 void JavaRecognizer::explicitConstructorInvocation() {
02075
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02076
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02077
RefJavaAST explicitConstructorInvocation_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02078
ANTLR_USE_NAMESPACE(antlr)
RefToken lp1 =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02079
RefJavaAST lp1_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02080
ANTLR_USE_NAMESPACE(antlr)
RefToken lp2 =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02081
RefJavaAST lp2_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02082
02083
try {
02084
switch ( LA(1)) {
02085
case LITERAL_this:
02086 {
02087 match(LITERAL_this);
02088 lp1 = LT(1);
02089
if ( inputState->guessing == 0 ) {
02090 lp1_AST = astFactory->create(lp1);
02091 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp1_AST.get()));
02092 }
02093 match(LPAREN);
02094
argList();
02095
if (inputState->guessing==0) {
02096 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02097 }
02098 match(RPAREN);
02099 match(SEMI);
02100
if ( inputState->guessing==0 ) {
02101
#line 428 "java.g"
02102
lp1_AST->setType(CTOR_CALL);
02103
#line 2104 "JavaRecognizer.cpp"
02104
}
02105 explicitConstructorInvocation_AST = (currentAST.
root);
02106
break;
02107 }
02108
case LITERAL_super:
02109 {
02110 match(LITERAL_super);
02111 lp2 = LT(1);
02112
if ( inputState->guessing == 0 ) {
02113 lp2_AST = astFactory->create(lp2);
02114 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp2_AST.get()));
02115 }
02116 match(LPAREN);
02117
argList();
02118
if (inputState->guessing==0) {
02119 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02120 }
02121 match(RPAREN);
02122 match(SEMI);
02123
if ( inputState->guessing==0 ) {
02124
#line 430 "java.g"
02125
lp2_AST->setType(SUPER_CTOR_CALL);
02126
#line 2127 "JavaRecognizer.cpp"
02127
}
02128 explicitConstructorInvocation_AST = (currentAST.
root);
02129
break;
02130 }
02131
default:
02132 {
02133
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02134 }
02135 }
02136 }
02137
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02138
if( inputState->guessing == 0 ) {
02139
reportError(ex);
02140 consume();
02141 consumeUntil(
_tokenSet_21);
02142 }
else {
02143
throw;
02144 }
02145 }
02146
returnAST = explicitConstructorInvocation_AST;
02147 }
02148
02149 void JavaRecognizer::statement() {
02150
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02151
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02152
RefJavaAST statement_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02153
RefJavaAST m_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02154
ANTLR_USE_NAMESPACE(antlr)
RefToken c =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02155
RefJavaAST c_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02156
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02157
RefJavaAST s_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02158
02159
try {
02160
switch ( LA(1)) {
02161
case LCURLY:
02162 {
02163
compoundStatement();
02164
if (inputState->guessing==0) {
02165 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02166 }
02167 statement_AST = (currentAST.
root);
02168
break;
02169 }
02170
case LITERAL_if:
02171 {
02172
RefJavaAST tmp68_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02173
if ( inputState->guessing == 0 ) {
02174 tmp68_AST = astFactory->create(LT(1));
02175 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp68_AST.get()));
02176 }
02177 match(LITERAL_if);
02178 match(LPAREN);
02179
expression();
02180
if (inputState->guessing==0) {
02181 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02182 }
02183 match(RPAREN);
02184
statement();
02185
if (inputState->guessing==0) {
02186 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02187 }
02188 {
02189
if ((LA(1) == LITERAL_else) && (
_tokenSet_23.member(LA(2)))) {
02190 match(LITERAL_else);
02191
statement();
02192
if (inputState->guessing==0) {
02193 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02194 }
02195 }
02196
else if ((
_tokenSet_28.member(LA(1))) && (
_tokenSet_29.member(LA(2)))) {
02197 }
02198
else {
02199
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02200 }
02201
02202 }
02203 statement_AST = (currentAST.
root);
02204
break;
02205 }
02206
case LITERAL_for:
02207 {
02208
RefJavaAST tmp72_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02209
if ( inputState->guessing == 0 ) {
02210 tmp72_AST = astFactory->create(LT(1));
02211 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp72_AST.get()));
02212 }
02213 match(LITERAL_for);
02214 match(LPAREN);
02215
forInit();
02216
if (inputState->guessing==0) {
02217 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02218 }
02219 match(SEMI);
02220
forCond();
02221
if (inputState->guessing==0) {
02222 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02223 }
02224 match(SEMI);
02225
forIter();
02226
if (inputState->guessing==0) {
02227 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02228 }
02229 match(RPAREN);
02230
statement();
02231
if (inputState->guessing==0) {
02232 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02233 }
02234 statement_AST = (currentAST.
root);
02235
break;
02236 }
02237
case LITERAL_while:
02238 {
02239
RefJavaAST tmp77_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02240
if ( inputState->guessing == 0 ) {
02241 tmp77_AST = astFactory->create(LT(1));
02242 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp77_AST.get()));
02243 }
02244 match(LITERAL_while);
02245 match(LPAREN);
02246
expression();
02247
if (inputState->guessing==0) {
02248 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02249 }
02250 match(RPAREN);
02251
statement();
02252
if (inputState->guessing==0) {
02253 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02254 }
02255 statement_AST = (currentAST.
root);
02256
break;
02257 }
02258
case LITERAL_do:
02259 {
02260
RefJavaAST tmp80_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02261
if ( inputState->guessing == 0 ) {
02262 tmp80_AST = astFactory->create(LT(1));
02263 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp80_AST.get()));
02264 }
02265 match(LITERAL_do);
02266
statement();
02267
if (inputState->guessing==0) {
02268 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02269 }
02270 match(LITERAL_while);
02271 match(LPAREN);
02272
expression();
02273
if (inputState->guessing==0) {
02274 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02275 }
02276 match(RPAREN);
02277 match(SEMI);
02278 statement_AST = (currentAST.
root);
02279
break;
02280 }
02281
case LITERAL_break:
02282 {
02283
RefJavaAST tmp85_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02284
if ( inputState->guessing == 0 ) {
02285 tmp85_AST = astFactory->create(LT(1));
02286 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp85_AST.get()));
02287 }
02288 match(LITERAL_break);
02289 {
02290
switch ( LA(1)) {
02291
case IDENT:
02292 {
02293
RefJavaAST tmp86_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02294
if ( inputState->guessing == 0 ) {
02295 tmp86_AST = astFactory->create(LT(1));
02296 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp86_AST.get()));
02297 }
02298 match(IDENT);
02299
break;
02300 }
02301
case SEMI:
02302 {
02303
break;
02304 }
02305
default:
02306 {
02307
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02308 }
02309 }
02310 }
02311 match(SEMI);
02312 statement_AST = (currentAST.
root);
02313
break;
02314 }
02315
case LITERAL_continue:
02316 {
02317
RefJavaAST tmp88_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02318
if ( inputState->guessing == 0 ) {
02319 tmp88_AST = astFactory->create(LT(1));
02320 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp88_AST.get()));
02321 }
02322 match(LITERAL_continue);
02323 {
02324
switch ( LA(1)) {
02325
case IDENT:
02326 {
02327
RefJavaAST tmp89_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02328
if ( inputState->guessing == 0 ) {
02329 tmp89_AST = astFactory->create(LT(1));
02330 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp89_AST.get()));
02331 }
02332 match(IDENT);
02333
break;
02334 }
02335
case SEMI:
02336 {
02337
break;
02338 }
02339
default:
02340 {
02341
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02342 }
02343 }
02344 }
02345 match(SEMI);
02346 statement_AST = (currentAST.
root);
02347
break;
02348 }
02349
case LITERAL_return:
02350 {
02351
RefJavaAST tmp91_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02352
if ( inputState->guessing == 0 ) {
02353 tmp91_AST = astFactory->create(LT(1));
02354 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp91_AST.get()));
02355 }
02356 match(LITERAL_return);
02357 {
02358
switch ( LA(1)) {
02359
case LITERAL_void:
02360
case LITERAL_boolean:
02361
case LITERAL_byte:
02362
case LITERAL_char:
02363
case LITERAL_short:
02364
case LITERAL_int:
02365
case LITERAL_float:
02366
case LITERAL_long:
02367
case LITERAL_double:
02368
case IDENT:
02369
case LPAREN:
02370
case LITERAL_this:
02371
case LITERAL_super:
02372
case PLUS:
02373
case MINUS:
02374
case INC:
02375
case DEC:
02376
case BNOT:
02377
case LNOT:
02378
case LITERAL_true:
02379
case LITERAL_false:
02380
case LITERAL_null:
02381
case LITERAL_new:
02382
case NUM_INT:
02383
case CHAR_LITERAL:
02384
case STRING_LITERAL:
02385
case NUM_FLOAT:
02386
case NUM_LONG:
02387
case NUM_DOUBLE:
02388 {
02389
expression();
02390
if (inputState->guessing==0) {
02391 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02392 }
02393
break;
02394 }
02395
case SEMI:
02396 {
02397
break;
02398 }
02399
default:
02400 {
02401
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02402 }
02403 }
02404 }
02405 match(SEMI);
02406 statement_AST = (currentAST.
root);
02407
break;
02408 }
02409
case LITERAL_switch:
02410 {
02411
RefJavaAST tmp93_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02412
if ( inputState->guessing == 0 ) {
02413 tmp93_AST = astFactory->create(LT(1));
02414 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp93_AST.get()));
02415 }
02416 match(LITERAL_switch);
02417 match(LPAREN);
02418
expression();
02419
if (inputState->guessing==0) {
02420 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02421 }
02422 match(RPAREN);
02423 match(LCURLY);
02424 {
02425
for (;;) {
02426
if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)) {
02427
casesGroup();
02428
if (inputState->guessing==0) {
02429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02430 }
02431 }
02432
else {
02433
goto _loop95;
02434 }
02435
02436 }
02437 _loop95:;
02438 }
02439 match(RCURLY);
02440 statement_AST = (currentAST.
root);
02441
break;
02442 }
02443
case LITERAL_try:
02444 {
02445
tryBlock();
02446
if (inputState->guessing==0) {
02447 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02448 }
02449 statement_AST = (currentAST.
root);
02450
break;
02451 }
02452
case LITERAL_throw:
02453 {
02454
RefJavaAST tmp98_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02455
if ( inputState->guessing == 0 ) {
02456 tmp98_AST = astFactory->create(LT(1));
02457 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp98_AST.get()));
02458 }
02459 match(LITERAL_throw);
02460
expression();
02461
if (inputState->guessing==0) {
02462 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02463 }
02464 match(SEMI);
02465 statement_AST = (currentAST.
root);
02466
break;
02467 }
02468
case SEMI:
02469 {
02470 s = LT(1);
02471
if ( inputState->guessing == 0 ) {
02472 s_AST = astFactory->create(s);
02473 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
02474 }
02475 match(SEMI);
02476
if ( inputState->guessing==0 ) {
02477
#line 617 "java.g"
02478
s_AST->setType(EMPTY_STAT);
02479
#line 2480 "JavaRecognizer.cpp"
02480
}
02481 statement_AST = (currentAST.
root);
02482
break;
02483 }
02484
default:
02485
bool synPredMatched89 =
false;
02486
if (((
_tokenSet_30.member(LA(1))) && (
_tokenSet_31.member(LA(2))))) {
02487
int _m89 = mark();
02488 synPredMatched89 =
true;
02489 inputState->guessing++;
02490
try {
02491 {
02492
declaration();
02493 }
02494 }
02495
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
02496 synPredMatched89 =
false;
02497 }
02498 rewind(_m89);
02499 inputState->guessing--;
02500 }
02501
if ( synPredMatched89 ) {
02502
declaration();
02503
if (inputState->guessing==0) {
02504 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02505 }
02506 match(SEMI);
02507 statement_AST = (currentAST.
root);
02508 }
02509
else if ((
_tokenSet_32.member(LA(1))) && (
_tokenSet_33.member(LA(2)))) {
02510
expression();
02511
if (inputState->guessing==0) {
02512 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02513 }
02514 match(SEMI);
02515 statement_AST = (currentAST.
root);
02516 }
02517
else if ((
_tokenSet_34.member(LA(1))) && (
_tokenSet_35.member(LA(2)))) {
02518
modifiers();
02519
if (inputState->guessing==0) {
02520 m_AST =
returnAST;
02521 }
02522
classDefinition(m_AST);
02523
if (inputState->guessing==0) {
02524 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02525 }
02526 statement_AST = (currentAST.
root);
02527 }
02528
else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
02529
RefJavaAST tmp102_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02530
if ( inputState->guessing == 0 ) {
02531 tmp102_AST = astFactory->create(LT(1));
02532 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp102_AST.get()));
02533 }
02534 match(IDENT);
02535 c = LT(1);
02536
if ( inputState->guessing == 0 ) {
02537 c_AST = astFactory->create(c);
02538 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
02539 }
02540 match(COLON);
02541
if ( inputState->guessing==0 ) {
02542
#line 560 "java.g"
02543
c_AST->setType(LABELED_STAT);
02544
#line 2545 "JavaRecognizer.cpp"
02545
}
02546
statement();
02547
if (inputState->guessing==0) {
02548 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02549 }
02550 statement_AST = (currentAST.
root);
02551 }
02552
else if ((LA(1) == LITERAL_synchronized) && (LA(2) == LPAREN)) {
02553
RefJavaAST tmp103_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02554
if ( inputState->guessing == 0 ) {
02555 tmp103_AST = astFactory->create(LT(1));
02556 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp103_AST.get()));
02557 }
02558 match(LITERAL_synchronized);
02559 match(LPAREN);
02560
expression();
02561
if (inputState->guessing==0) {
02562 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02563 }
02564 match(RPAREN);
02565
compoundStatement();
02566
if (inputState->guessing==0) {
02567 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02568 }
02569 statement_AST = (currentAST.
root);
02570 }
02571
else {
02572
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02573 }
02574 }
02575 }
02576
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02577
if( inputState->guessing == 0 ) {
02578
reportError(ex);
02579 consume();
02580 consumeUntil(
_tokenSet_28);
02581 }
else {
02582
throw;
02583 }
02584 }
02585
returnAST = statement_AST;
02586 }
02587
02588 void JavaRecognizer::argList() {
02589
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02590
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02591
RefJavaAST argList_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02592
02593
try {
02594 {
02595
switch ( LA(1)) {
02596
case LITERAL_void:
02597
case LITERAL_boolean:
02598
case LITERAL_byte:
02599
case LITERAL_char:
02600
case LITERAL_short:
02601
case LITERAL_int:
02602
case LITERAL_float:
02603
case LITERAL_long:
02604
case LITERAL_double:
02605
case IDENT:
02606
case LPAREN:
02607
case LITERAL_this:
02608
case LITERAL_super:
02609
case PLUS:
02610
case MINUS:
02611
case INC:
02612
case DEC:
02613
case BNOT:
02614
case LNOT:
02615
case LITERAL_true:
02616
case LITERAL_false:
02617
case LITERAL_null:
02618
case LITERAL_new:
02619
case NUM_INT:
02620
case CHAR_LITERAL:
02621
case STRING_LITERAL:
02622
case NUM_FLOAT:
02623
case NUM_LONG:
02624
case NUM_DOUBLE:
02625 {
02626
expressionList();
02627
if (inputState->guessing==0) {
02628 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02629 }
02630
break;
02631 }
02632
case RPAREN:
02633 {
02634
if ( inputState->guessing==0 ) {
02635 argList_AST =
RefJavaAST(currentAST.
root);
02636
#line 1008 "java.g"
02637
argList_AST = astFactory->create(ELIST,
"ELIST");
02638
#line 2639 "JavaRecognizer.cpp"
02639
currentAST.
root = argList_AST;
02640
if ( argList_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02641 argList_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02642 currentAST.
child = argList_AST->getFirstChild();
02643
else
02644 currentAST.
child = argList_AST;
02645 currentAST.
advanceChildToEnd();
02646 }
02647
break;
02648 }
02649
default:
02650 {
02651
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02652 }
02653 }
02654 }
02655 argList_AST = (currentAST.
root);
02656 }
02657
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02658
if( inputState->guessing == 0 ) {
02659
reportError(ex);
02660 consume();
02661 consumeUntil(
_tokenSet_24);
02662 }
else {
02663
throw;
02664 }
02665 }
02666
returnAST = argList_AST;
02667 }
02668
02673 void JavaRecognizer::variableDeclarator(
02674 RefJavaAST mods, RefJavaAST t
02675 ) {
02676
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02677
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02678
RefJavaAST variableDeclarator_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02679
ANTLR_USE_NAMESPACE(antlr)
RefToken id =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02680
RefJavaAST id_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02681
RefJavaAST d_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02682
RefJavaAST v_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02683
02684
try {
02685
id = LT(1);
02686
if ( inputState->guessing == 0 ) {
02687 id_AST = astFactory->create(
id);
02688 }
02689 match(IDENT);
02690
declaratorBrackets(t);
02691
if (inputState->guessing==0) {
02692 d_AST =
returnAST;
02693 }
02694
varInitializer();
02695
if (inputState->guessing==0) {
02696 v_AST =
returnAST;
02697 }
02698
if ( inputState->guessing==0 ) {
02699 variableDeclarator_AST =
RefJavaAST(currentAST.
root);
02700
#line 448 "java.g"
02701
variableDeclarator_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(5))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VARIABLE_DEF,
"VARIABLE_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mods.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TYPE,
"TYPE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get())))).get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(id_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(v_AST.get()))));
02702
#line 2703 "JavaRecognizer.cpp"
02703
currentAST.
root = variableDeclarator_AST;
02704
if ( variableDeclarator_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02705 variableDeclarator_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02706 currentAST.
child = variableDeclarator_AST->getFirstChild();
02707
else
02708 currentAST.
child = variableDeclarator_AST;
02709 currentAST.
advanceChildToEnd();
02710 }
02711 }
02712
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02713
if( inputState->guessing == 0 ) {
02714
reportError(ex);
02715 consume();
02716 consumeUntil(
_tokenSet_36);
02717 }
else {
02718
throw;
02719 }
02720 }
02721
returnAST = variableDeclarator_AST;
02722 }
02723
02724 void JavaRecognizer::varInitializer() {
02725
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02726
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02727
RefJavaAST varInitializer_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02728
02729
try {
02730 {
02731
switch ( LA(1)) {
02732
case ASSIGN:
02733 {
02734
RefJavaAST tmp106_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02735
if ( inputState->guessing == 0 ) {
02736 tmp106_AST = astFactory->create(LT(1));
02737 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp106_AST.get()));
02738 }
02739 match(ASSIGN);
02740
initializer();
02741
if (inputState->guessing==0) {
02742 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02743 }
02744
break;
02745 }
02746
case SEMI:
02747
case COMMA:
02748 {
02749
break;
02750 }
02751
default:
02752 {
02753
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02754 }
02755 }
02756 }
02757 varInitializer_AST = (currentAST.
root);
02758 }
02759
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02760
if( inputState->guessing == 0 ) {
02761
reportError(ex);
02762 consume();
02763 consumeUntil(
_tokenSet_36);
02764 }
else {
02765
throw;
02766 }
02767 }
02768
returnAST = varInitializer_AST;
02769 }
02770
02771 void JavaRecognizer::initializer() {
02772
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02773
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02774
RefJavaAST initializer_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02775
02776
try {
02777
switch ( LA(1)) {
02778
case LITERAL_void:
02779
case LITERAL_boolean:
02780
case LITERAL_byte:
02781
case LITERAL_char:
02782
case LITERAL_short:
02783
case LITERAL_int:
02784
case LITERAL_float:
02785
case LITERAL_long:
02786
case LITERAL_double:
02787
case IDENT:
02788
case LPAREN:
02789
case LITERAL_this:
02790
case LITERAL_super:
02791
case PLUS:
02792
case MINUS:
02793
case INC:
02794
case DEC:
02795
case BNOT:
02796
case LNOT:
02797
case LITERAL_true:
02798
case LITERAL_false:
02799
case LITERAL_null:
02800
case LITERAL_new:
02801
case NUM_INT:
02802
case CHAR_LITERAL:
02803
case STRING_LITERAL:
02804
case NUM_FLOAT:
02805
case NUM_LONG:
02806
case NUM_DOUBLE:
02807 {
02808
expression();
02809
if (inputState->guessing==0) {
02810 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02811 }
02812 initializer_AST = (currentAST.
root);
02813
break;
02814 }
02815
case LCURLY:
02816 {
02817
arrayInitializer();
02818
if (inputState->guessing==0) {
02819 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02820 }
02821 initializer_AST = (currentAST.
root);
02822
break;
02823 }
02824
default:
02825 {
02826
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02827 }
02828 }
02829 }
02830
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02831
if( inputState->guessing == 0 ) {
02832
reportError(ex);
02833 consume();
02834 consumeUntil(
_tokenSet_37);
02835 }
else {
02836
throw;
02837 }
02838 }
02839
returnAST = initializer_AST;
02840 }
02841
02842 void JavaRecognizer::arrayInitializer() {
02843
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02844
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02845
RefJavaAST arrayInitializer_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02846
ANTLR_USE_NAMESPACE(antlr)
RefToken lc =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02847
RefJavaAST lc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02848
02849
try {
02850 lc = LT(1);
02851
if ( inputState->guessing == 0 ) {
02852 lc_AST = astFactory->create(lc);
02853 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lc_AST.get()));
02854 }
02855 match(LCURLY);
02856
if ( inputState->guessing==0 ) {
02857
#line 462 "java.g"
02858
lc_AST->setType(ARRAY_INIT);
02859
#line 2860 "JavaRecognizer.cpp"
02860
}
02861 {
02862
switch ( LA(1)) {
02863
case LITERAL_void:
02864
case LITERAL_boolean:
02865
case LITERAL_byte:
02866
case LITERAL_char:
02867
case LITERAL_short:
02868
case LITERAL_int:
02869
case LITERAL_float:
02870
case LITERAL_long:
02871
case LITERAL_double:
02872
case IDENT:
02873
case LCURLY:
02874
case LPAREN:
02875
case LITERAL_this:
02876
case LITERAL_super:
02877
case PLUS:
02878
case MINUS:
02879
case INC:
02880
case DEC:
02881
case BNOT:
02882
case LNOT:
02883
case LITERAL_true:
02884
case LITERAL_false:
02885
case LITERAL_null:
02886
case LITERAL_new:
02887
case NUM_INT:
02888
case CHAR_LITERAL:
02889
case STRING_LITERAL:
02890
case NUM_FLOAT:
02891
case NUM_LONG:
02892
case NUM_DOUBLE:
02893 {
02894
initializer();
02895
if (inputState->guessing==0) {
02896 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02897 }
02898 {
02899
for (;;) {
02900
if ((LA(1) == COMMA) && (
_tokenSet_38.member(LA(2)))) {
02901 match(COMMA);
02902
initializer();
02903
if (inputState->guessing==0) {
02904 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02905 }
02906 }
02907
else {
02908
goto _loop69;
02909 }
02910
02911 }
02912 _loop69:;
02913 }
02914 {
02915
switch ( LA(1)) {
02916
case COMMA:
02917 {
02918 match(COMMA);
02919
break;
02920 }
02921
case RCURLY:
02922 {
02923
break;
02924 }
02925
default:
02926 {
02927
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02928 }
02929 }
02930 }
02931
break;
02932 }
02933
case RCURLY:
02934 {
02935
break;
02936 }
02937
default:
02938 {
02939
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02940 }
02941 }
02942 }
02943 match(RCURLY);
02944 arrayInitializer_AST = (currentAST.
root);
02945 }
02946
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02947
if( inputState->guessing == 0 ) {
02948
reportError(ex);
02949 consume();
02950 consumeUntil(
_tokenSet_39);
02951 }
else {
02952
throw;
02953 }
02954 }
02955
returnAST = arrayInitializer_AST;
02956 }
02957
02958 void JavaRecognizer::expression() {
02959
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02960
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02961
RefJavaAST expression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02962
02963
try {
02964
assignmentExpression();
02965
if (inputState->guessing==0) {
02966 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02967 }
02968
if ( inputState->guessing==0 ) {
02969 expression_AST =
RefJavaAST(currentAST.
root);
02970
#line 715 "java.g"
02971
expression_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXPR,
"EXPR").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(expression_AST.get()))));
02972
#line 2973 "JavaRecognizer.cpp"
02973
currentAST.
root = expression_AST;
02974
if ( expression_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02975 expression_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02976 currentAST.
child = expression_AST->getFirstChild();
02977
else
02978 currentAST.
child = expression_AST;
02979 currentAST.
advanceChildToEnd();
02980 }
02981 expression_AST = (currentAST.
root);
02982 }
02983
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02984
if( inputState->guessing == 0 ) {
02985
reportError(ex);
02986 consume();
02987 consumeUntil(
_tokenSet_40);
02988 }
else {
02989
throw;
02990 }
02991 }
02992
returnAST = expression_AST;
02993 }
02994
02995 void JavaRecognizer::parameterDeclaration() {
02996
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02997
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02998
RefJavaAST parameterDeclaration_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02999
RefJavaAST pm_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03000
RefJavaAST t_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03001
ANTLR_USE_NAMESPACE(antlr)
RefToken id =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03002
RefJavaAST id_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03003
RefJavaAST pd_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03004
03005
try {
03006
parameterModifier();
03007
if (inputState->guessing==0) {
03008 pm_AST =
returnAST;
03009 }
03010
typeSpec(
false);
03011
if (inputState->guessing==0) {
03012 t_AST =
returnAST;
03013 }
03014
id = LT(1);
03015
if ( inputState->guessing == 0 ) {
03016 id_AST = astFactory->create(
id);
03017 }
03018 match(IDENT);
03019
declaratorBrackets(t_AST);
03020
if (inputState->guessing==0) {
03021 pd_AST =
returnAST;
03022 }
03023
if ( inputState->guessing==0 ) {
03024 parameterDeclaration_AST =
RefJavaAST(currentAST.
root);
03025
#line 516 "java.g"
03026
parameterDeclaration_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(4))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_DEF,
"PARAMETER_DEF").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pm_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TYPE,
"TYPE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pd_AST.get())))).get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(id_AST.get()))));
03027
#line 3028 "JavaRecognizer.cpp"
03028
currentAST.
root = parameterDeclaration_AST;
03029
if ( parameterDeclaration_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03030 parameterDeclaration_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03031 currentAST.
child = parameterDeclaration_AST->getFirstChild();
03032
else
03033 currentAST.
child = parameterDeclaration_AST;
03034 currentAST.
advanceChildToEnd();
03035 }
03036 }
03037
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03038
if( inputState->guessing == 0 ) {
03039
reportError(ex);
03040 consume();
03041 consumeUntil(
_tokenSet_41);
03042 }
else {
03043
throw;
03044 }
03045 }
03046
returnAST = parameterDeclaration_AST;
03047 }
03048
03049 void JavaRecognizer::parameterModifier() {
03050
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03051
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03052
RefJavaAST parameterModifier_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03053
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03054
RefJavaAST f_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03055
03056
try {
03057 {
03058
switch ( LA(1)) {
03059
case FINAL:
03060 {
03061 f = LT(1);
03062
if ( inputState->guessing == 0 ) {
03063 f_AST = astFactory->create(f);
03064 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
03065 }
03066 match(FINAL);
03067
break;
03068 }
03069
case LITERAL_void:
03070
case LITERAL_boolean:
03071
case LITERAL_byte:
03072
case LITERAL_char:
03073
case LITERAL_short:
03074
case LITERAL_int:
03075
case LITERAL_float:
03076
case LITERAL_long:
03077
case LITERAL_double:
03078
case IDENT:
03079 {
03080
break;
03081 }
03082
default:
03083 {
03084
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03085 }
03086 }
03087 }
03088
if ( inputState->guessing==0 ) {
03089 parameterModifier_AST =
RefJavaAST(currentAST.
root);
03090
#line 522 "java.g"
03091
parameterModifier_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()))));
03092
#line 3093 "JavaRecognizer.cpp"
03093
currentAST.
root = parameterModifier_AST;
03094
if ( parameterModifier_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03095 parameterModifier_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03096 currentAST.
child = parameterModifier_AST->getFirstChild();
03097
else
03098 currentAST.
child = parameterModifier_AST;
03099 currentAST.
advanceChildToEnd();
03100 }
03101 parameterModifier_AST = (currentAST.
root);
03102 }
03103
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03104
if( inputState->guessing == 0 ) {
03105
reportError(ex);
03106 consume();
03107 consumeUntil(
_tokenSet_42);
03108 }
else {
03109
throw;
03110 }
03111 }
03112
returnAST = parameterModifier_AST;
03113 }
03114
03115 void JavaRecognizer::forInit() {
03116
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03117
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03118
RefJavaAST forInit_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03119
03120
try {
03121 {
03122
bool synPredMatched107 =
false;
03123
if (((
_tokenSet_30.member(LA(1))) && (
_tokenSet_31.member(LA(2))))) {
03124
int _m107 = mark();
03125 synPredMatched107 =
true;
03126 inputState->guessing++;
03127
try {
03128 {
03129
declaration();
03130 }
03131 }
03132
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
03133 synPredMatched107 =
false;
03134 }
03135 rewind(_m107);
03136 inputState->guessing--;
03137 }
03138
if ( synPredMatched107 ) {
03139
declaration();
03140
if (inputState->guessing==0) {
03141 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03142 }
03143 }
03144
else if ((
_tokenSet_32.member(LA(1))) && (
_tokenSet_43.member(LA(2)))) {
03145
expressionList();
03146
if (inputState->guessing==0) {
03147 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03148 }
03149 }
03150
else if ((LA(1) == SEMI)) {
03151 }
03152
else {
03153
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03154 }
03155
03156 }
03157
if ( inputState->guessing==0 ) {
03158 forInit_AST =
RefJavaAST(currentAST.
root);
03159
#line 651 "java.g"
03160
forInit_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FOR_INIT,
"FOR_INIT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(forInit_AST.get()))));
03161
#line 3162 "JavaRecognizer.cpp"
03162
currentAST.
root = forInit_AST;
03163
if ( forInit_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03164 forInit_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03165 currentAST.
child = forInit_AST->getFirstChild();
03166
else
03167 currentAST.
child = forInit_AST;
03168 currentAST.
advanceChildToEnd();
03169 }
03170 forInit_AST = (currentAST.
root);
03171 }
03172
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03173
if( inputState->guessing == 0 ) {
03174
reportError(ex);
03175 consume();
03176 consumeUntil(
_tokenSet_5);
03177 }
else {
03178
throw;
03179 }
03180 }
03181
returnAST = forInit_AST;
03182 }
03183
03184 void JavaRecognizer::forCond() {
03185
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03186
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03187
RefJavaAST forCond_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03188
03189
try {
03190 {
03191
switch ( LA(1)) {
03192
case LITERAL_void:
03193
case LITERAL_boolean:
03194
case LITERAL_byte:
03195
case LITERAL_char:
03196
case LITERAL_short:
03197
case LITERAL_int:
03198
case LITERAL_float:
03199
case LITERAL_long:
03200
case LITERAL_double:
03201
case IDENT:
03202
case LPAREN:
03203
case LITERAL_this:
03204
case LITERAL_super:
03205
case PLUS:
03206
case MINUS:
03207
case INC:
03208
case DEC:
03209
case BNOT:
03210
case LNOT:
03211
case LITERAL_true:
03212
case LITERAL_false:
03213
case LITERAL_null:
03214
case LITERAL_new:
03215
case NUM_INT:
03216
case CHAR_LITERAL:
03217
case STRING_LITERAL:
03218
case NUM_FLOAT:
03219
case NUM_LONG:
03220
case NUM_DOUBLE:
03221 {
03222
expression();
03223
if (inputState->guessing==0) {
03224 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03225 }
03226
break;
03227 }
03228
case SEMI:
03229 {
03230
break;
03231 }
03232
default:
03233 {
03234
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03235 }
03236 }
03237 }
03238
if ( inputState->guessing==0 ) {
03239 forCond_AST =
RefJavaAST(currentAST.
root);
03240
#line 656 "java.g"
03241
forCond_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FOR_CONDITION,
"FOR_CONDITION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(forCond_AST.get()))));
03242
#line 3243 "JavaRecognizer.cpp"
03243
currentAST.
root = forCond_AST;
03244
if ( forCond_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03245 forCond_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03246 currentAST.
child = forCond_AST->getFirstChild();
03247
else
03248 currentAST.
child = forCond_AST;
03249 currentAST.
advanceChildToEnd();
03250 }
03251 forCond_AST = (currentAST.
root);
03252 }
03253
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03254
if( inputState->guessing == 0 ) {
03255
reportError(ex);
03256 consume();
03257 consumeUntil(
_tokenSet_5);
03258 }
else {
03259
throw;
03260 }
03261 }
03262
returnAST = forCond_AST;
03263 }
03264
03265 void JavaRecognizer::forIter() {
03266
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03267
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03268
RefJavaAST forIter_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03269
03270
try {
03271 {
03272
switch ( LA(1)) {
03273
case LITERAL_void:
03274
case LITERAL_boolean:
03275
case LITERAL_byte:
03276
case LITERAL_char:
03277
case LITERAL_short:
03278
case LITERAL_int:
03279
case LITERAL_float:
03280
case LITERAL_long:
03281
case LITERAL_double:
03282
case IDENT:
03283
case LPAREN:
03284
case LITERAL_this:
03285
case LITERAL_super:
03286
case PLUS:
03287
case MINUS:
03288
case INC:
03289
case DEC:
03290
case BNOT:
03291
case LNOT:
03292
case LITERAL_true:
03293
case LITERAL_false:
03294
case LITERAL_null:
03295
case LITERAL_new:
03296
case NUM_INT:
03297
case CHAR_LITERAL:
03298
case STRING_LITERAL:
03299
case NUM_FLOAT:
03300
case NUM_LONG:
03301
case NUM_DOUBLE:
03302 {
03303
expressionList();
03304
if (inputState->guessing==0) {
03305 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03306 }
03307
break;
03308 }
03309
case RPAREN:
03310 {
03311
break;
03312 }
03313
default:
03314 {
03315
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03316 }
03317 }
03318 }
03319
if ( inputState->guessing==0 ) {
03320 forIter_AST =
RefJavaAST(currentAST.
root);
03321
#line 661 "java.g"
03322
forIter_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FOR_ITERATOR,
"FOR_ITERATOR").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(forIter_AST.get()))));
03323
#line 3324 "JavaRecognizer.cpp"
03324
currentAST.
root = forIter_AST;
03325
if ( forIter_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03326 forIter_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03327 currentAST.
child = forIter_AST->getFirstChild();
03328
else
03329 currentAST.
child = forIter_AST;
03330 currentAST.
advanceChildToEnd();
03331 }
03332 forIter_AST = (currentAST.
root);
03333 }
03334
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03335
if( inputState->guessing == 0 ) {
03336
reportError(ex);
03337 consume();
03338 consumeUntil(
_tokenSet_24);
03339 }
else {
03340
throw;
03341 }
03342 }
03343
returnAST = forIter_AST;
03344 }
03345
03346 void JavaRecognizer::casesGroup() {
03347
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03348
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03349
RefJavaAST casesGroup_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03350
03351
try {
03352 {
03353
int _cnt98=0;
03354
for (;;) {
03355
if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default) && (
_tokenSet_44.member(LA(2)))) {
03356
aCase();
03357
if (inputState->guessing==0) {
03358 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03359 }
03360 }
03361
else {
03362
if ( _cnt98>=1 ) {
goto _loop98; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
03363 }
03364
03365 _cnt98++;
03366 }
03367 _loop98:;
03368 }
03369
caseSList();
03370
if (inputState->guessing==0) {
03371 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03372 }
03373
if ( inputState->guessing==0 ) {
03374 casesGroup_AST =
RefJavaAST(currentAST.
root);
03375
#line 632 "java.g"
03376
casesGroup_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CASE_GROUP,
"CASE_GROUP").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(casesGroup_AST.get()))));
03377
#line 3378 "JavaRecognizer.cpp"
03378
currentAST.
root = casesGroup_AST;
03379
if ( casesGroup_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03380 casesGroup_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03381 currentAST.
child = casesGroup_AST->getFirstChild();
03382
else
03383 currentAST.
child = casesGroup_AST;
03384 currentAST.
advanceChildToEnd();
03385 }
03386 casesGroup_AST = (currentAST.
root);
03387 }
03388
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03389
if( inputState->guessing == 0 ) {
03390
reportError(ex);
03391 consume();
03392 consumeUntil(
_tokenSet_45);
03393 }
else {
03394
throw;
03395 }
03396 }
03397
returnAST = casesGroup_AST;
03398 }
03399
03400 void JavaRecognizer::tryBlock() {
03401
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03402
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03403
RefJavaAST tryBlock_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03404
03405
try {
03406
RefJavaAST tmp110_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03407
if ( inputState->guessing == 0 ) {
03408 tmp110_AST = astFactory->create(LT(1));
03409 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp110_AST.get()));
03410 }
03411 match(LITERAL_try);
03412
compoundStatement();
03413
if (inputState->guessing==0) {
03414 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03415 }
03416 {
03417
for (;;) {
03418
if ((LA(1) == LITERAL_catch)) {
03419
handler();
03420
if (inputState->guessing==0) {
03421 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03422 }
03423 }
03424
else {
03425
goto _loop114;
03426 }
03427
03428 }
03429 _loop114:;
03430 }
03431 {
03432
switch ( LA(1)) {
03433
case LITERAL_finally:
03434 {
03435
finallyClause();
03436
if (inputState->guessing==0) {
03437 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03438 }
03439
break;
03440 }
03441
case FINAL:
03442
case ABSTRACT:
03443
case STRICTFP:
03444
case SEMI:
03445
case LITERAL_void:
03446
case LITERAL_boolean:
03447
case LITERAL_byte:
03448
case LITERAL_char:
03449
case LITERAL_short:
03450
case LITERAL_int:
03451
case LITERAL_float:
03452
case LITERAL_long:
03453
case LITERAL_double:
03454
case IDENT:
03455
case LITERAL_private:
03456
case LITERAL_public:
03457
case LITERAL_protected:
03458
case LITERAL_static:
03459
case LITERAL_transient:
03460
case LITERAL_native:
03461
case LITERAL_threadsafe:
03462
case LITERAL_synchronized:
03463
case LITERAL_volatile:
03464
case LITERAL_class:
03465
case LCURLY:
03466
case RCURLY:
03467
case LPAREN:
03468
case LITERAL_this:
03469
case LITERAL_super:
03470
case LITERAL_if:
03471
case LITERAL_else:
03472
case LITERAL_for:
03473
case LITERAL_while:
03474
case LITERAL_do:
03475
case LITERAL_break:
03476
case LITERAL_continue:
03477
case LITERAL_return:
03478
case LITERAL_switch:
03479
case LITERAL_throw:
03480
case LITERAL_case:
03481
case LITERAL_default:
03482
case LITERAL_try:
03483
case PLUS:
03484
case MINUS:
03485
case INC:
03486
case DEC:
03487
case BNOT:
03488
case LNOT:
03489
case LITERAL_true:
03490
case LITERAL_false:
03491
case LITERAL_null:
03492
case LITERAL_new:
03493
case NUM_INT:
03494
case CHAR_LITERAL:
03495
case STRING_LITERAL:
03496
case NUM_FLOAT:
03497
case NUM_LONG:
03498
case NUM_DOUBLE:
03499 {
03500
break;
03501 }
03502
default:
03503 {
03504
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03505 }
03506 }
03507 }
03508 tryBlock_AST = (currentAST.
root);
03509 }
03510
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03511
if( inputState->guessing == 0 ) {
03512
reportError(ex);
03513 consume();
03514 consumeUntil(
_tokenSet_28);
03515 }
else {
03516
throw;
03517 }
03518 }
03519
returnAST = tryBlock_AST;
03520 }
03521
03522 void JavaRecognizer::aCase() {
03523
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03524
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03525
RefJavaAST aCase_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03526
03527
try {
03528 {
03529
switch ( LA(1)) {
03530
case LITERAL_case:
03531 {
03532
RefJavaAST tmp111_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03533
if ( inputState->guessing == 0 ) {
03534 tmp111_AST = astFactory->create(LT(1));
03535 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp111_AST.get()));
03536 }
03537 match(LITERAL_case);
03538
expression();
03539
if (inputState->guessing==0) {
03540 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03541 }
03542
break;
03543 }
03544
case LITERAL_default:
03545 {
03546
RefJavaAST tmp112_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03547
if ( inputState->guessing == 0 ) {
03548 tmp112_AST = astFactory->create(LT(1));
03549 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp112_AST.get()));
03550 }
03551 match(LITERAL_default);
03552
break;
03553 }
03554
default:
03555 {
03556
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03557 }
03558 }
03559 }
03560 match(COLON);
03561 aCase_AST = (currentAST.
root);
03562 }
03563
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03564
if( inputState->guessing == 0 ) {
03565
reportError(ex);
03566 consume();
03567 consumeUntil(
_tokenSet_46);
03568 }
else {
03569
throw;
03570 }
03571 }
03572
returnAST = aCase_AST;
03573 }
03574
03575 void JavaRecognizer::caseSList() {
03576
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03577
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03578
RefJavaAST caseSList_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03579
03580
try {
03581 {
03582
for (;;) {
03583
if ((
_tokenSet_23.member(LA(1)))) {
03584
statement();
03585
if (inputState->guessing==0) {
03586 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03587 }
03588 }
03589
else {
03590
goto _loop103;
03591 }
03592
03593 }
03594 _loop103:;
03595 }
03596
if ( inputState->guessing==0 ) {
03597 caseSList_AST =
RefJavaAST(currentAST.
root);
03598
#line 641 "java.g"
03599
caseSList_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SLIST,
"SLIST").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(caseSList_AST.get()))));
03600
#line 3601 "JavaRecognizer.cpp"
03601
currentAST.
root = caseSList_AST;
03602
if ( caseSList_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03603 caseSList_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03604 currentAST.
child = caseSList_AST->getFirstChild();
03605
else
03606 currentAST.
child = caseSList_AST;
03607 currentAST.
advanceChildToEnd();
03608 }
03609 caseSList_AST = (currentAST.
root);
03610 }
03611
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03612
if( inputState->guessing == 0 ) {
03613
reportError(ex);
03614 consume();
03615 consumeUntil(
_tokenSet_45);
03616 }
else {
03617
throw;
03618 }
03619 }
03620
returnAST = caseSList_AST;
03621 }
03622
03623 void JavaRecognizer::expressionList() {
03624
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03625
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03626
RefJavaAST expressionList_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03627
03628
try {
03629
expression();
03630
if (inputState->guessing==0) {
03631 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03632 }
03633 {
03634
for (;;) {
03635
if ((LA(1) == COMMA)) {
03636 match(COMMA);
03637
expression();
03638
if (inputState->guessing==0) {
03639 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03640 }
03641 }
03642
else {
03643
goto _loop121;
03644 }
03645
03646 }
03647 _loop121:;
03648 }
03649
if ( inputState->guessing==0 ) {
03650 expressionList_AST =
RefJavaAST(currentAST.
root);
03651
#line 721 "java.g"
03652
expressionList_AST =
RefJavaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELIST,
"ELIST").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(expressionList_AST.get()))));
03653
#line 3654 "JavaRecognizer.cpp"
03654
currentAST.
root = expressionList_AST;
03655
if ( expressionList_AST!=static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03656 expressionList_AST->getFirstChild() != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03657 currentAST.
child = expressionList_AST->getFirstChild();
03658
else
03659 currentAST.
child = expressionList_AST;
03660 currentAST.
advanceChildToEnd();
03661 }
03662 expressionList_AST = (currentAST.
root);
03663 }
03664
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03665
if( inputState->guessing == 0 ) {
03666
reportError(ex);
03667 consume();
03668 consumeUntil(
_tokenSet_47);
03669 }
else {
03670
throw;
03671 }
03672 }
03673
returnAST = expressionList_AST;
03674 }
03675
03676 void JavaRecognizer::handler() {
03677
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03678
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03679
RefJavaAST handler_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03680
03681
try {
03682
RefJavaAST tmp115_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03683
if ( inputState->guessing == 0 ) {
03684 tmp115_AST = astFactory->create(LT(1));
03685 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp115_AST.get()));
03686 }
03687 match(LITERAL_catch);
03688 match(LPAREN);
03689
parameterDeclaration();
03690
if (inputState->guessing==0) {
03691 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03692 }
03693 match(RPAREN);
03694
compoundStatement();
03695
if (inputState->guessing==0) {
03696 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03697 }
03698 handler_AST = (currentAST.
root);
03699 }
03700
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03701
if( inputState->guessing == 0 ) {
03702
reportError(ex);
03703 consume();
03704 consumeUntil(
_tokenSet_48);
03705 }
else {
03706
throw;
03707 }
03708 }
03709
returnAST = handler_AST;
03710 }
03711
03712 void JavaRecognizer::finallyClause() {
03713
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03714
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03715
RefJavaAST finallyClause_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03716
03717
try {
03718
RefJavaAST tmp118_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03719
if ( inputState->guessing == 0 ) {
03720 tmp118_AST = astFactory->create(LT(1));
03721 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp118_AST.get()));
03722 }
03723 match(LITERAL_finally);
03724
compoundStatement();
03725
if (inputState->guessing==0) {
03726 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03727 }
03728 finallyClause_AST = (currentAST.
root);
03729 }
03730
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03731
if( inputState->guessing == 0 ) {
03732
reportError(ex);
03733 consume();
03734 consumeUntil(
_tokenSet_28);
03735 }
else {
03736
throw;
03737 }
03738 }
03739
returnAST = finallyClause_AST;
03740 }
03741
03742 void JavaRecognizer::assignmentExpression() {
03743
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03744
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03745
RefJavaAST assignmentExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03746
03747
try {
03748
conditionalExpression();
03749
if (inputState->guessing==0) {
03750 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03751 }
03752 {
03753
switch ( LA(1)) {
03754
case ASSIGN:
03755
case PLUS_ASSIGN:
03756
case MINUS_ASSIGN:
03757
case STAR_ASSIGN:
03758
case DIV_ASSIGN:
03759
case MOD_ASSIGN:
03760
case SR_ASSIGN:
03761
case BSR_ASSIGN:
03762
case SL_ASSIGN:
03763
case BAND_ASSIGN:
03764
case BXOR_ASSIGN:
03765
case BOR_ASSIGN:
03766 {
03767 {
03768
switch ( LA(1)) {
03769
case ASSIGN:
03770 {
03771
RefJavaAST tmp119_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03772
if ( inputState->guessing == 0 ) {
03773 tmp119_AST = astFactory->create(LT(1));
03774 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp119_AST.get()));
03775 }
03776 match(ASSIGN);
03777
break;
03778 }
03779
case PLUS_ASSIGN:
03780 {
03781
RefJavaAST tmp120_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03782
if ( inputState->guessing == 0 ) {
03783 tmp120_AST = astFactory->create(LT(1));
03784 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp120_AST.get()));
03785 }
03786 match(PLUS_ASSIGN);
03787
break;
03788 }
03789
case MINUS_ASSIGN:
03790 {
03791
RefJavaAST tmp121_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03792
if ( inputState->guessing == 0 ) {
03793 tmp121_AST = astFactory->create(LT(1));
03794 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp121_AST.get()));
03795 }
03796 match(MINUS_ASSIGN);
03797
break;
03798 }
03799
case STAR_ASSIGN:
03800 {
03801
RefJavaAST tmp122_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03802
if ( inputState->guessing == 0 ) {
03803 tmp122_AST = astFactory->create(LT(1));
03804 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp122_AST.get()));
03805 }
03806 match(STAR_ASSIGN);
03807
break;
03808 }
03809
case DIV_ASSIGN:
03810 {
03811
RefJavaAST tmp123_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03812
if ( inputState->guessing == 0 ) {
03813 tmp123_AST = astFactory->create(LT(1));
03814 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp123_AST.get()));
03815 }
03816 match(DIV_ASSIGN);
03817
break;
03818 }
03819
case MOD_ASSIGN:
03820 {
03821
RefJavaAST tmp124_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03822
if ( inputState->guessing == 0 ) {
03823 tmp124_AST = astFactory->create(LT(1));
03824 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp124_AST.get()));
03825 }
03826 match(MOD_ASSIGN);
03827
break;
03828 }
03829
case SR_ASSIGN:
03830 {
03831
RefJavaAST tmp125_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03832
if ( inputState->guessing == 0 ) {
03833 tmp125_AST = astFactory->create(LT(1));
03834 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp125_AST.get()));
03835 }
03836 match(SR_ASSIGN);
03837
break;
03838 }
03839
case BSR_ASSIGN:
03840 {
03841
RefJavaAST tmp126_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03842
if ( inputState->guessing == 0 ) {
03843 tmp126_AST = astFactory->create(LT(1));
03844 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp126_AST.get()));
03845 }
03846 match(BSR_ASSIGN);
03847
break;
03848 }
03849
case SL_ASSIGN:
03850 {
03851
RefJavaAST tmp127_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03852
if ( inputState->guessing == 0 ) {
03853 tmp127_AST = astFactory->create(LT(1));
03854 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp127_AST.get()));
03855 }
03856 match(SL_ASSIGN);
03857
break;
03858 }
03859
case BAND_ASSIGN:
03860 {
03861
RefJavaAST tmp128_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03862
if ( inputState->guessing == 0 ) {
03863 tmp128_AST = astFactory->create(LT(1));
03864 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp128_AST.get()));
03865 }
03866 match(BAND_ASSIGN);
03867
break;
03868 }
03869
case BXOR_ASSIGN:
03870 {
03871
RefJavaAST tmp129_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03872
if ( inputState->guessing == 0 ) {
03873 tmp129_AST = astFactory->create(LT(1));
03874 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp129_AST.get()));
03875 }
03876 match(BXOR_ASSIGN);
03877
break;
03878 }
03879
case BOR_ASSIGN:
03880 {
03881
RefJavaAST tmp130_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03882
if ( inputState->guessing == 0 ) {
03883 tmp130_AST = astFactory->create(LT(1));
03884 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp130_AST.get()));
03885 }
03886 match(BOR_ASSIGN);
03887
break;
03888 }
03889
default:
03890 {
03891
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03892 }
03893 }
03894 }
03895
assignmentExpression();
03896
if (inputState->guessing==0) {
03897 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03898 }
03899
break;
03900 }
03901
case SEMI:
03902
case RBRACK:
03903
case RCURLY:
03904
case COMMA:
03905
case RPAREN:
03906
case COLON:
03907 {
03908
break;
03909 }
03910
default:
03911 {
03912
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03913 }
03914 }
03915 }
03916 assignmentExpression_AST = (currentAST.
root);
03917 }
03918
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03919
if( inputState->guessing == 0 ) {
03920
reportError(ex);
03921 consume();
03922 consumeUntil(
_tokenSet_40);
03923 }
else {
03924
throw;
03925 }
03926 }
03927
returnAST = assignmentExpression_AST;
03928 }
03929
03930 void JavaRecognizer::conditionalExpression() {
03931
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03932
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03933
RefJavaAST conditionalExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03934
03935
try {
03936
logicalOrExpression();
03937
if (inputState->guessing==0) {
03938 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03939 }
03940 {
03941
switch ( LA(1)) {
03942
case QUESTION:
03943 {
03944
RefJavaAST tmp131_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03945
if ( inputState->guessing == 0 ) {
03946 tmp131_AST = astFactory->create(LT(1));
03947 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp131_AST.get()));
03948 }
03949 match(QUESTION);
03950
assignmentExpression();
03951
if (inputState->guessing==0) {
03952 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03953 }
03954 match(COLON);
03955
conditionalExpression();
03956
if (inputState->guessing==0) {
03957 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03958 }
03959
break;
03960 }
03961
case SEMI:
03962
case RBRACK:
03963
case RCURLY:
03964
case COMMA:
03965
case RPAREN:
03966
case ASSIGN:
03967
case COLON:
03968
case PLUS_ASSIGN:
03969
case MINUS_ASSIGN:
03970
case STAR_ASSIGN:
03971
case DIV_ASSIGN:
03972
case MOD_ASSIGN:
03973
case SR_ASSIGN:
03974
case BSR_ASSIGN:
03975
case SL_ASSIGN:
03976
case BAND_ASSIGN:
03977
case BXOR_ASSIGN:
03978
case BOR_ASSIGN:
03979 {
03980
break;
03981 }
03982
default:
03983 {
03984
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03985 }
03986 }
03987 }
03988 conditionalExpression_AST = (currentAST.
root);
03989 }
03990
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03991
if( inputState->guessing == 0 ) {
03992
reportError(ex);
03993 consume();
03994 consumeUntil(
_tokenSet_49);
03995 }
else {
03996
throw;
03997 }
03998 }
03999
returnAST = conditionalExpression_AST;
04000 }
04001
04002 void JavaRecognizer::logicalOrExpression() {
04003
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04004
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04005
RefJavaAST logicalOrExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04006
04007
try {
04008
logicalAndExpression();
04009
if (inputState->guessing==0) {
04010 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04011 }
04012 {
04013
for (;;) {
04014
if ((LA(1) == LOR)) {
04015
RefJavaAST tmp133_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04016
if ( inputState->guessing == 0 ) {
04017 tmp133_AST = astFactory->create(LT(1));
04018 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp133_AST.get()));
04019 }
04020 match(LOR);
04021
logicalAndExpression();
04022
if (inputState->guessing==0) {
04023 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04024 }
04025 }
04026
else {
04027
goto _loop129;
04028 }
04029
04030 }
04031 _loop129:;
04032 }
04033 logicalOrExpression_AST = (currentAST.
root);
04034 }
04035
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04036
if( inputState->guessing == 0 ) {
04037
reportError(ex);
04038 consume();
04039 consumeUntil(
_tokenSet_50);
04040 }
else {
04041
throw;
04042 }
04043 }
04044
returnAST = logicalOrExpression_AST;
04045 }
04046
04047 void JavaRecognizer::logicalAndExpression() {
04048
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04049
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04050
RefJavaAST logicalAndExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04051
04052
try {
04053
inclusiveOrExpression();
04054
if (inputState->guessing==0) {
04055 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04056 }
04057 {
04058
for (;;) {
04059
if ((LA(1) == LAND)) {
04060
RefJavaAST tmp134_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04061
if ( inputState->guessing == 0 ) {
04062 tmp134_AST = astFactory->create(LT(1));
04063 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp134_AST.get()));
04064 }
04065 match(LAND);
04066
inclusiveOrExpression();
04067
if (inputState->guessing==0) {
04068 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04069 }
04070 }
04071
else {
04072
goto _loop132;
04073 }
04074
04075 }
04076 _loop132:;
04077 }
04078 logicalAndExpression_AST = (currentAST.
root);
04079 }
04080
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04081
if( inputState->guessing == 0 ) {
04082
reportError(ex);
04083 consume();
04084 consumeUntil(
_tokenSet_51);
04085 }
else {
04086
throw;
04087 }
04088 }
04089
returnAST = logicalAndExpression_AST;
04090 }
04091
04092 void JavaRecognizer::inclusiveOrExpression() {
04093
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04094
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04095
RefJavaAST inclusiveOrExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04096
04097
try {
04098
exclusiveOrExpression();
04099
if (inputState->guessing==0) {
04100 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04101 }
04102 {
04103
for (;;) {
04104
if ((LA(1) == BOR)) {
04105
RefJavaAST tmp135_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04106
if ( inputState->guessing == 0 ) {
04107 tmp135_AST = astFactory->create(LT(1));
04108 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp135_AST.get()));
04109 }
04110 match(BOR);
04111
exclusiveOrExpression();
04112
if (inputState->guessing==0) {
04113 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04114 }
04115 }
04116
else {
04117
goto _loop135;
04118 }
04119
04120 }
04121 _loop135:;
04122 }
04123 inclusiveOrExpression_AST = (currentAST.
root);
04124 }
04125
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04126
if( inputState->guessing == 0 ) {
04127
reportError(ex);
04128 consume();
04129 consumeUntil(
_tokenSet_52);
04130 }
else {
04131
throw;
04132 }
04133 }
04134
returnAST = inclusiveOrExpression_AST;
04135 }
04136
04137 void JavaRecognizer::exclusiveOrExpression() {
04138
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04139
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04140
RefJavaAST exclusiveOrExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04141
04142
try {
04143
andExpression();
04144
if (inputState->guessing==0) {
04145 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04146 }
04147 {
04148
for (;;) {
04149
if ((LA(1) == BXOR)) {
04150
RefJavaAST tmp136_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04151
if ( inputState->guessing == 0 ) {
04152 tmp136_AST = astFactory->create(LT(1));
04153 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp136_AST.get()));
04154 }
04155 match(BXOR);
04156
andExpression();
04157
if (inputState->guessing==0) {
04158 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04159 }
04160 }
04161
else {
04162
goto _loop138;
04163 }
04164
04165 }
04166 _loop138:;
04167 }
04168 exclusiveOrExpression_AST = (currentAST.
root);
04169 }
04170
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04171
if( inputState->guessing == 0 ) {
04172
reportError(ex);
04173 consume();
04174 consumeUntil(
_tokenSet_53);
04175 }
else {
04176
throw;
04177 }
04178 }
04179
returnAST = exclusiveOrExpression_AST;
04180 }
04181
04182 void JavaRecognizer::andExpression() {
04183
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04184
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04185
RefJavaAST andExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04186
04187
try {
04188
equalityExpression();
04189
if (inputState->guessing==0) {
04190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04191 }
04192 {
04193
for (;;) {
04194
if ((LA(1) == BAND)) {
04195
RefJavaAST tmp137_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04196
if ( inputState->guessing == 0 ) {
04197 tmp137_AST = astFactory->create(LT(1));
04198 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp137_AST.get()));
04199 }
04200 match(BAND);
04201
equalityExpression();
04202
if (inputState->guessing==0) {
04203 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04204 }
04205 }
04206
else {
04207
goto _loop141;
04208 }
04209
04210 }
04211 _loop141:;
04212 }
04213 andExpression_AST = (currentAST.
root);
04214 }
04215
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04216
if( inputState->guessing == 0 ) {
04217
reportError(ex);
04218 consume();
04219 consumeUntil(
_tokenSet_54);
04220 }
else {
04221
throw;
04222 }
04223 }
04224
returnAST = andExpression_AST;
04225 }
04226
04227 void JavaRecognizer::equalityExpression() {
04228
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04229
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04230
RefJavaAST equalityExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04231
04232
try {
04233
relationalExpression();
04234
if (inputState->guessing==0) {
04235 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04236 }
04237 {
04238
for (;;) {
04239
if ((LA(1) == NOT_EQUAL || LA(1) == EQUAL)) {
04240 {
04241
switch ( LA(1)) {
04242
case NOT_EQUAL:
04243 {
04244
RefJavaAST tmp138_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04245
if ( inputState->guessing == 0 ) {
04246 tmp138_AST = astFactory->create(LT(1));
04247 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp138_AST.get()));
04248 }
04249 match(NOT_EQUAL);
04250
break;
04251 }
04252
case EQUAL:
04253 {
04254
RefJavaAST tmp139_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04255
if ( inputState->guessing == 0 ) {
04256 tmp139_AST = astFactory->create(LT(1));
04257 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp139_AST.get()));
04258 }
04259 match(EQUAL);
04260
break;
04261 }
04262
default:
04263 {
04264
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04265 }
04266 }
04267 }
04268
relationalExpression();
04269
if (inputState->guessing==0) {
04270 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04271 }
04272 }
04273
else {
04274
goto _loop145;
04275 }
04276
04277 }
04278 _loop145:;
04279 }
04280 equalityExpression_AST = (currentAST.
root);
04281 }
04282
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04283
if( inputState->guessing == 0 ) {
04284
reportError(ex);
04285 consume();
04286 consumeUntil(
_tokenSet_55);
04287 }
else {
04288
throw;
04289 }
04290 }
04291
returnAST = equalityExpression_AST;
04292 }
04293
04294 void JavaRecognizer::relationalExpression() {
04295
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04296
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04297
RefJavaAST relationalExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04298
04299
try {
04300
shiftExpression();
04301
if (inputState->guessing==0) {
04302 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04303 }
04304 {
04305
switch ( LA(1)) {
04306
case SEMI:
04307
case RBRACK:
04308
case RCURLY:
04309
case COMMA:
04310
case RPAREN:
04311
case ASSIGN:
04312
case COLON:
04313
case PLUS_ASSIGN:
04314
case MINUS_ASSIGN:
04315
case STAR_ASSIGN:
04316
case DIV_ASSIGN:
04317
case MOD_ASSIGN:
04318
case SR_ASSIGN:
04319
case BSR_ASSIGN:
04320
case SL_ASSIGN:
04321
case BAND_ASSIGN:
04322
case BXOR_ASSIGN:
04323
case BOR_ASSIGN:
04324
case QUESTION:
04325
case LOR:
04326
case LAND:
04327
case BOR:
04328
case BXOR:
04329
case BAND:
04330
case NOT_EQUAL:
04331
case EQUAL:
04332
case LT_:
04333
case GT:
04334
case LE:
04335
case GE:
04336 {
04337 {
04338
for (;;) {
04339
if (((LA(1) >= LT_ && LA(1) <= GE))) {
04340 {
04341
switch ( LA(1)) {
04342
case LT_:
04343 {
04344
RefJavaAST tmp140_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04345
if ( inputState->guessing == 0 ) {
04346 tmp140_AST = astFactory->create(LT(1));
04347 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp140_AST.get()));
04348 }
04349 match(LT_);
04350
break;
04351 }
04352
case GT:
04353 {
04354
RefJavaAST tmp141_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04355
if ( inputState->guessing == 0 ) {
04356 tmp141_AST = astFactory->create(LT(1));
04357 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp141_AST.get()));
04358 }
04359 match(GT);
04360
break;
04361 }
04362
case LE:
04363 {
04364
RefJavaAST tmp142_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04365
if ( inputState->guessing == 0 ) {
04366 tmp142_AST = astFactory->create(LT(1));
04367 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp142_AST.get()));
04368 }
04369 match(LE);
04370
break;
04371 }
04372
case GE:
04373 {
04374
RefJavaAST tmp143_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04375
if ( inputState->guessing == 0 ) {
04376 tmp143_AST = astFactory->create(LT(1));
04377 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp143_AST.get()));
04378 }
04379 match(GE);
04380
break;
04381 }
04382
default:
04383 {
04384
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04385 }
04386 }
04387 }
04388
shiftExpression();
04389
if (inputState->guessing==0) {
04390 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04391 }
04392 }
04393
else {
04394
goto _loop150;
04395 }
04396
04397 }
04398 _loop150:;
04399 }
04400
break;
04401 }
04402
case LITERAL_instanceof:
04403 {
04404
RefJavaAST tmp144_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04405
if ( inputState->guessing == 0 ) {
04406 tmp144_AST = astFactory->create(LT(1));
04407 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp144_AST.get()));
04408 }
04409 match(LITERAL_instanceof);
04410
typeSpec(
true);
04411
if (inputState->guessing==0) {
04412 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04413 }
04414
break;
04415 }
04416
default:
04417 {
04418
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04419 }
04420 }
04421 }
04422 relationalExpression_AST = (currentAST.
root);
04423 }
04424
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04425
if( inputState->guessing == 0 ) {
04426
reportError(ex);
04427 consume();
04428 consumeUntil(
_tokenSet_56);
04429 }
else {
04430
throw;
04431 }
04432 }
04433
returnAST = relationalExpression_AST;
04434 }
04435
04436 void JavaRecognizer::shiftExpression() {
04437
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04438
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04439
RefJavaAST shiftExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04440
04441
try {
04442
additiveExpression();
04443
if (inputState->guessing==0) {
04444 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04445 }
04446 {
04447
for (;;) {
04448
if (((LA(1) >= SL && LA(1) <= BSR))) {
04449 {
04450
switch ( LA(1)) {
04451
case SL:
04452 {
04453
RefJavaAST tmp145_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04454
if ( inputState->guessing == 0 ) {
04455 tmp145_AST = astFactory->create(LT(1));
04456 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp145_AST.get()));
04457 }
04458 match(SL);
04459
break;
04460 }
04461
case SR:
04462 {
04463
RefJavaAST tmp146_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04464
if ( inputState->guessing == 0 ) {
04465 tmp146_AST = astFactory->create(LT(1));
04466 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp146_AST.get()));
04467 }
04468 match(SR);
04469
break;
04470 }
04471
case BSR:
04472 {
04473
RefJavaAST tmp147_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04474
if ( inputState->guessing == 0 ) {
04475 tmp147_AST = astFactory->create(LT(1));
04476 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp147_AST.get()));
04477 }
04478 match(BSR);
04479
break;
04480 }
04481
default:
04482 {
04483
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04484 }
04485 }
04486 }
04487
additiveExpression();
04488
if (inputState->guessing==0) {
04489 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04490 }
04491 }
04492
else {
04493
goto _loop154;
04494 }
04495
04496 }
04497 _loop154:;
04498 }
04499 shiftExpression_AST = (currentAST.
root);
04500 }
04501
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04502
if( inputState->guessing == 0 ) {
04503
reportError(ex);
04504 consume();
04505 consumeUntil(
_tokenSet_57);
04506 }
else {
04507
throw;
04508 }
04509 }
04510
returnAST = shiftExpression_AST;
04511 }
04512
04513 void JavaRecognizer::additiveExpression() {
04514
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04515
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04516
RefJavaAST additiveExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04517
04518
try {
04519
multiplicativeExpression();
04520
if (inputState->guessing==0) {
04521 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04522 }
04523 {
04524
for (;;) {
04525
if ((LA(1) == PLUS || LA(1) == MINUS)) {
04526 {
04527
switch ( LA(1)) {
04528
case PLUS:
04529 {
04530
RefJavaAST tmp148_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04531
if ( inputState->guessing == 0 ) {
04532 tmp148_AST = astFactory->create(LT(1));
04533 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp148_AST.get()));
04534 }
04535 match(PLUS);
04536
break;
04537 }
04538
case MINUS:
04539 {
04540
RefJavaAST tmp149_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04541
if ( inputState->guessing == 0 ) {
04542 tmp149_AST = astFactory->create(LT(1));
04543 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp149_AST.get()));
04544 }
04545 match(MINUS);
04546
break;
04547 }
04548
default:
04549 {
04550
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04551 }
04552 }
04553 }
04554
multiplicativeExpression();
04555
if (inputState->guessing==0) {
04556 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04557 }
04558 }
04559
else {
04560
goto _loop158;
04561 }
04562
04563 }
04564 _loop158:;
04565 }
04566 additiveExpression_AST = (currentAST.
root);
04567 }
04568
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04569
if( inputState->guessing == 0 ) {
04570
reportError(ex);
04571 consume();
04572 consumeUntil(
_tokenSet_58);
04573 }
else {
04574
throw;
04575 }
04576 }
04577
returnAST = additiveExpression_AST;
04578 }
04579
04580 void JavaRecognizer::multiplicativeExpression() {
04581
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04582
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04583
RefJavaAST multiplicativeExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04584
04585
try {
04586
unaryExpression();
04587
if (inputState->guessing==0) {
04588 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04589 }
04590 {
04591
for (;;) {
04592
if ((
_tokenSet_59.member(LA(1)))) {
04593 {
04594
switch ( LA(1)) {
04595
case STAR:
04596 {
04597
RefJavaAST tmp150_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04598
if ( inputState->guessing == 0 ) {
04599 tmp150_AST = astFactory->create(LT(1));
04600 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp150_AST.get()));
04601 }
04602 match(STAR);
04603
break;
04604 }
04605
case DIV:
04606 {
04607
RefJavaAST tmp151_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04608
if ( inputState->guessing == 0 ) {
04609 tmp151_AST = astFactory->create(LT(1));
04610 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp151_AST.get()));
04611 }
04612 match(DIV);
04613
break;
04614 }
04615
case MOD:
04616 {
04617
RefJavaAST tmp152_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04618
if ( inputState->guessing == 0 ) {
04619 tmp152_AST = astFactory->create(LT(1));
04620 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp152_AST.get()));
04621 }
04622 match(MOD);
04623
break;
04624 }
04625
default:
04626 {
04627
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04628 }
04629 }
04630 }
04631
unaryExpression();
04632
if (inputState->guessing==0) {
04633 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04634 }
04635 }
04636
else {
04637
goto _loop162;
04638 }
04639
04640 }
04641 _loop162:;
04642 }
04643 multiplicativeExpression_AST = (currentAST.
root);
04644 }
04645
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04646
if( inputState->guessing == 0 ) {
04647
reportError(ex);
04648 consume();
04649 consumeUntil(
_tokenSet_60);
04650 }
else {
04651
throw;
04652 }
04653 }
04654
returnAST = multiplicativeExpression_AST;
04655 }
04656
04657 void JavaRecognizer::unaryExpression() {
04658
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04659
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04660
RefJavaAST unaryExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04661
04662
try {
04663
switch ( LA(1)) {
04664
case INC:
04665 {
04666
RefJavaAST tmp153_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04667
if ( inputState->guessing == 0 ) {
04668 tmp153_AST = astFactory->create(LT(1));
04669 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp153_AST.get()));
04670 }
04671 match(INC);
04672
unaryExpression();
04673
if (inputState->guessing==0) {
04674 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04675 }
04676 unaryExpression_AST = (currentAST.
root);
04677
break;
04678 }
04679
case DEC:
04680 {
04681
RefJavaAST tmp154_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04682
if ( inputState->guessing == 0 ) {
04683 tmp154_AST = astFactory->create(LT(1));
04684 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp154_AST.get()));
04685 }
04686 match(DEC);
04687
unaryExpression();
04688
if (inputState->guessing==0) {
04689 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04690 }
04691 unaryExpression_AST = (currentAST.
root);
04692
break;
04693 }
04694
case MINUS:
04695 {
04696
RefJavaAST tmp155_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04697
if ( inputState->guessing == 0 ) {
04698 tmp155_AST = astFactory->create(LT(1));
04699 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp155_AST.get()));
04700 }
04701 match(MINUS);
04702
if ( inputState->guessing==0 ) {
04703
#line 812 "java.g"
04704
tmp155_AST->setType(UNARY_MINUS);
04705
#line 4706 "JavaRecognizer.cpp"
04706
}
04707
unaryExpression();
04708
if (inputState->guessing==0) {
04709 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04710 }
04711 unaryExpression_AST = (currentAST.
root);
04712
break;
04713 }
04714
case PLUS:
04715 {
04716
RefJavaAST tmp156_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04717
if ( inputState->guessing == 0 ) {
04718 tmp156_AST = astFactory->create(LT(1));
04719 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp156_AST.get()));
04720 }
04721 match(PLUS);
04722
if ( inputState->guessing==0 ) {
04723
#line 813 "java.g"
04724
tmp156_AST->setType(UNARY_PLUS);
04725
#line 4726 "JavaRecognizer.cpp"
04726
}
04727
unaryExpression();
04728
if (inputState->guessing==0) {
04729 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04730 }
04731 unaryExpression_AST = (currentAST.
root);
04732
break;
04733 }
04734
case LITERAL_void:
04735
case LITERAL_boolean:
04736
case LITERAL_byte:
04737
case LITERAL_char:
04738
case LITERAL_short:
04739
case LITERAL_int:
04740
case LITERAL_float:
04741
case LITERAL_long:
04742
case LITERAL_double:
04743
case IDENT:
04744
case LPAREN:
04745
case LITERAL_this:
04746
case LITERAL_super:
04747
case BNOT:
04748
case LNOT:
04749
case LITERAL_true:
04750
case LITERAL_false:
04751
case LITERAL_null:
04752
case LITERAL_new:
04753
case NUM_INT:
04754
case CHAR_LITERAL:
04755
case STRING_LITERAL:
04756
case NUM_FLOAT:
04757
case NUM_LONG:
04758
case NUM_DOUBLE:
04759 {
04760
unaryExpressionNotPlusMinus();
04761
if (inputState->guessing==0) {
04762 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04763 }
04764 unaryExpression_AST = (currentAST.
root);
04765
break;
04766 }
04767
default:
04768 {
04769
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04770 }
04771 }
04772 }
04773
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04774
if( inputState->guessing == 0 ) {
04775
reportError(ex);
04776 consume();
04777 consumeUntil(
_tokenSet_61);
04778 }
else {
04779
throw;
04780 }
04781 }
04782
returnAST = unaryExpression_AST;
04783 }
04784
04785 void JavaRecognizer::unaryExpressionNotPlusMinus() {
04786
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04787
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04788
RefJavaAST unaryExpressionNotPlusMinus_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04789
ANTLR_USE_NAMESPACE(antlr)
RefToken lpb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04790
RefJavaAST lpb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04791
ANTLR_USE_NAMESPACE(antlr)
RefToken lp =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04792
RefJavaAST lp_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04793
04794
try {
04795
switch ( LA(1)) {
04796
case BNOT:
04797 {
04798
RefJavaAST tmp157_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04799
if ( inputState->guessing == 0 ) {
04800 tmp157_AST = astFactory->create(LT(1));
04801 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp157_AST.get()));
04802 }
04803 match(BNOT);
04804
unaryExpression();
04805
if (inputState->guessing==0) {
04806 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04807 }
04808 unaryExpressionNotPlusMinus_AST = (currentAST.
root);
04809
break;
04810 }
04811
case LNOT:
04812 {
04813
RefJavaAST tmp158_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04814
if ( inputState->guessing == 0 ) {
04815 tmp158_AST = astFactory->create(LT(1));
04816 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp158_AST.get()));
04817 }
04818 match(LNOT);
04819
unaryExpression();
04820
if (inputState->guessing==0) {
04821 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04822 }
04823 unaryExpressionNotPlusMinus_AST = (currentAST.
root);
04824
break;
04825 }
04826
case LITERAL_void:
04827
case LITERAL_boolean:
04828
case LITERAL_byte:
04829
case LITERAL_char:
04830
case LITERAL_short:
04831
case LITERAL_int:
04832
case LITERAL_float:
04833
case LITERAL_long:
04834
case LITERAL_double:
04835
case IDENT:
04836
case LPAREN:
04837
case LITERAL_this:
04838
case LITERAL_super:
04839
case LITERAL_true:
04840
case LITERAL_false:
04841
case LITERAL_null:
04842
case LITERAL_new:
04843
case NUM_INT:
04844
case CHAR_LITERAL:
04845
case STRING_LITERAL:
04846
case NUM_FLOAT:
04847
case NUM_LONG:
04848
case NUM_DOUBLE:
04849 {
04850 {
04851
if ((LA(1) == LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double))) {
04852 lpb = LT(1);
04853
if ( inputState->guessing == 0 ) {
04854 lpb_AST = astFactory->create(lpb);
04855 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lpb_AST.get()));
04856 }
04857 match(LPAREN);
04858
if ( inputState->guessing==0 ) {
04859
#line 829 "java.g"
04860
lpb_AST->setType(TYPECAST);
04861
#line 4862 "JavaRecognizer.cpp"
04862
}
04863
builtInTypeSpec(
true);
04864
if (inputState->guessing==0) {
04865 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04866 }
04867 match(RPAREN);
04868
unaryExpression();
04869
if (inputState->guessing==0) {
04870 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04871 }
04872 }
04873
else {
04874
bool synPredMatched167 =
false;
04875
if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
04876
int _m167 = mark();
04877 synPredMatched167 =
true;
04878 inputState->guessing++;
04879
try {
04880 {
04881 match(LPAREN);
04882
classTypeSpec(
true);
04883 match(RPAREN);
04884
unaryExpressionNotPlusMinus();
04885 }
04886 }
04887
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
04888 synPredMatched167 =
false;
04889 }
04890 rewind(_m167);
04891 inputState->guessing--;
04892 }
04893
if ( synPredMatched167 ) {
04894 lp = LT(1);
04895
if ( inputState->guessing == 0 ) {
04896 lp_AST = astFactory->create(lp);
04897 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp_AST.get()));
04898 }
04899 match(LPAREN);
04900
if ( inputState->guessing==0 ) {
04901
#line 836 "java.g"
04902
lp_AST->setType(TYPECAST);
04903
#line 4904 "JavaRecognizer.cpp"
04904
}
04905
classTypeSpec(
true);
04906
if (inputState->guessing==0) {
04907 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04908 }
04909 match(RPAREN);
04910
unaryExpressionNotPlusMinus();
04911
if (inputState->guessing==0) {
04912 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04913 }
04914 }
04915
else if ((
_tokenSet_62.member(LA(1))) && (
_tokenSet_63.member(LA(2)))) {
04916
postfixExpression();
04917
if (inputState->guessing==0) {
04918 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04919 }
04920 }
04921
else {
04922
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04923 }
04924 }
04925 }
04926 unaryExpressionNotPlusMinus_AST = (currentAST.
root);
04927
break;
04928 }
04929
default:
04930 {
04931
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04932 }
04933 }
04934 }
04935
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04936
if( inputState->guessing == 0 ) {
04937
reportError(ex);
04938 consume();
04939 consumeUntil(
_tokenSet_61);
04940 }
else {
04941
throw;
04942 }
04943 }
04944
returnAST = unaryExpressionNotPlusMinus_AST;
04945 }
04946
04947 void JavaRecognizer::postfixExpression() {
04948
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04949
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04950
RefJavaAST postfixExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04951
ANTLR_USE_NAMESPACE(antlr)
RefToken lp =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04952
RefJavaAST lp_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04953
ANTLR_USE_NAMESPACE(antlr)
RefToken lp3 =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04954
RefJavaAST lp3_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04955
ANTLR_USE_NAMESPACE(antlr)
RefToken lps =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04956
RefJavaAST lps_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04957
ANTLR_USE_NAMESPACE(antlr)
RefToken lb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04958
RefJavaAST lb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04959
ANTLR_USE_NAMESPACE(antlr)
RefToken in =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04960
RefJavaAST in_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04961
ANTLR_USE_NAMESPACE(antlr)
RefToken de =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04962
RefJavaAST de_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04963
04964
try {
04965
primaryExpression();
04966
if (inputState->guessing==0) {
04967 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04968 }
04969 {
04970
for (;;) {
04971
if ((LA(1) == DOT) && (LA(2) == IDENT)) {
04972
RefJavaAST tmp161_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04973
if ( inputState->guessing == 0 ) {
04974 tmp161_AST = astFactory->create(LT(1));
04975 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp161_AST.get()));
04976 }
04977 match(DOT);
04978
RefJavaAST tmp162_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04979
if ( inputState->guessing == 0 ) {
04980 tmp162_AST = astFactory->create(LT(1));
04981 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp162_AST.get()));
04982 }
04983 match(IDENT);
04984 {
04985
switch ( LA(1)) {
04986
case LPAREN:
04987 {
04988 lp = LT(1);
04989
if ( inputState->guessing == 0 ) {
04990 lp_AST = astFactory->create(lp);
04991 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp_AST.get()));
04992 }
04993 match(LPAREN);
04994
if ( inputState->guessing==0 ) {
04995
#line 867 "java.g"
04996
lp_AST->setType(METHOD_CALL);
04997
#line 4998 "JavaRecognizer.cpp"
04998
}
04999
argList();
05000
if (inputState->guessing==0) {
05001 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05002 }
05003 match(RPAREN);
05004
break;
05005 }
05006
case SEMI:
05007
case LBRACK:
05008
case RBRACK:
05009
case DOT:
05010
case STAR:
05011
case RCURLY:
05012
case COMMA:
05013
case RPAREN:
05014
case ASSIGN:
05015
case COLON:
05016
case PLUS_ASSIGN:
05017
case MINUS_ASSIGN:
05018
case STAR_ASSIGN:
05019
case DIV_ASSIGN:
05020
case MOD_ASSIGN:
05021
case SR_ASSIGN:
05022
case BSR_ASSIGN:
05023
case SL_ASSIGN:
05024
case BAND_ASSIGN:
05025
case BXOR_ASSIGN:
05026
case BOR_ASSIGN:
05027
case QUESTION:
05028
case LOR:
05029
case LAND:
05030
case BOR:
05031
case BXOR:
05032
case BAND:
05033
case NOT_EQUAL:
05034
case EQUAL:
05035
case LT_:
05036
case GT:
05037
case LE:
05038
case GE:
05039
case LITERAL_instanceof:
05040
case SL:
05041
case SR:
05042
case BSR:
05043
case PLUS:
05044
case MINUS:
05045
case DIV:
05046
case MOD:
05047
case INC:
05048
case DEC:
05049 {
05050
break;
05051 }
05052
default:
05053 {
05054
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05055 }
05056 }
05057 }
05058 }
05059
else if ((LA(1) == DOT) && (LA(2) == LITERAL_this)) {
05060
RefJavaAST tmp164_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05061
if ( inputState->guessing == 0 ) {
05062 tmp164_AST = astFactory->create(LT(1));
05063 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp164_AST.get()));
05064 }
05065 match(DOT);
05066
RefJavaAST tmp165_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05067
if ( inputState->guessing == 0 ) {
05068 tmp165_AST = astFactory->create(LT(1));
05069 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp165_AST.get()));
05070 }
05071 match(LITERAL_this);
05072 }
05073
else if ((LA(1) == DOT) && (LA(2) == LITERAL_super)) {
05074
RefJavaAST tmp166_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05075
if ( inputState->guessing == 0 ) {
05076 tmp166_AST = astFactory->create(LT(1));
05077 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp166_AST.get()));
05078 }
05079 match(DOT);
05080
RefJavaAST tmp167_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05081
if ( inputState->guessing == 0 ) {
05082 tmp167_AST = astFactory->create(LT(1));
05083 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp167_AST.get()));
05084 }
05085 match(LITERAL_super);
05086 {
05087
switch ( LA(1)) {
05088
case LPAREN:
05089 {
05090 lp3 = LT(1);
05091
if ( inputState->guessing == 0 ) {
05092 lp3_AST = astFactory->create(lp3);
05093 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp3_AST.get()));
05094 }
05095 match(LPAREN);
05096
argList();
05097
if (inputState->guessing==0) {
05098 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05099 }
05100 match(RPAREN);
05101
if ( inputState->guessing==0 ) {
05102
#line 876 "java.g"
05103
lp3_AST->setType(SUPER_CTOR_CALL);
05104
#line 5105 "JavaRecognizer.cpp"
05105
}
05106
break;
05107 }
05108
case DOT:
05109 {
05110
RefJavaAST tmp169_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05111
if ( inputState->guessing == 0 ) {
05112 tmp169_AST = astFactory->create(LT(1));
05113 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp169_AST.get()));
05114 }
05115 match(DOT);
05116
RefJavaAST tmp170_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05117
if ( inputState->guessing == 0 ) {
05118 tmp170_AST = astFactory->create(LT(1));
05119 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp170_AST.get()));
05120 }
05121 match(IDENT);
05122 {
05123
switch ( LA(1)) {
05124
case LPAREN:
05125 {
05126 lps = LT(1);
05127
if ( inputState->guessing == 0 ) {
05128 lps_AST = astFactory->create(lps);
05129 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lps_AST.get()));
05130 }
05131 match(LPAREN);
05132
if ( inputState->guessing==0 ) {
05133
#line 878 "java.g"
05134
lps_AST->setType(METHOD_CALL);
05135
#line 5136 "JavaRecognizer.cpp"
05136
}
05137
argList();
05138
if (inputState->guessing==0) {
05139 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05140 }
05141 match(RPAREN);
05142
break;
05143 }
05144
case SEMI:
05145
case LBRACK:
05146
case RBRACK:
05147
case DOT:
05148
case STAR:
05149
case RCURLY:
05150
case COMMA:
05151
case RPAREN:
05152
case ASSIGN:
05153
case COLON:
05154
case PLUS_ASSIGN:
05155
case MINUS_ASSIGN:
05156
case STAR_ASSIGN:
05157
case DIV_ASSIGN:
05158
case MOD_ASSIGN:
05159
case SR_ASSIGN:
05160
case BSR_ASSIGN:
05161
case SL_ASSIGN:
05162
case BAND_ASSIGN:
05163
case BXOR_ASSIGN:
05164
case BOR_ASSIGN:
05165
case QUESTION:
05166
case LOR:
05167
case LAND:
05168
case BOR:
05169
case BXOR:
05170
case BAND:
05171
case NOT_EQUAL:
05172
case EQUAL:
05173
case LT_:
05174
case GT:
05175
case LE:
05176
case GE:
05177
case LITERAL_instanceof:
05178
case SL:
05179
case SR:
05180
case BSR:
05181
case PLUS:
05182
case MINUS:
05183
case DIV:
05184
case MOD:
05185
case INC:
05186
case DEC:
05187 {
05188
break;
05189 }
05190
default:
05191 {
05192
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05193 }
05194 }
05195 }
05196
break;
05197 }
05198
default:
05199 {
05200
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05201 }
05202 }
05203 }
05204 }
05205
else if ((LA(1) == DOT) && (LA(2) == LITERAL_new)) {
05206
RefJavaAST tmp172_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05207
if ( inputState->guessing == 0 ) {
05208 tmp172_AST = astFactory->create(LT(1));
05209 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp172_AST.get()));
05210 }
05211 match(DOT);
05212
newExpression();
05213
if (inputState->guessing==0) {
05214 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05215 }
05216 }
05217
else if ((LA(1) == LBRACK)) {
05218 lb = LT(1);
05219
if ( inputState->guessing == 0 ) {
05220 lb_AST = astFactory->create(lb);
05221 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lb_AST.get()));
05222 }
05223 match(LBRACK);
05224
if ( inputState->guessing==0 ) {
05225
#line 884 "java.g"
05226
lb_AST->setType(INDEX_OP);
05227
#line 5228 "JavaRecognizer.cpp"
05228
}
05229
expression();
05230
if (inputState->guessing==0) {
05231 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05232 }
05233 match(RBRACK);
05234 }
05235
else {
05236
goto _loop173;
05237 }
05238
05239 }
05240 _loop173:;
05241 }
05242 {
05243
switch ( LA(1)) {
05244
case INC:
05245 {
05246 in = LT(1);
05247
if ( inputState->guessing == 0 ) {
05248 in_AST = astFactory->create(in);
05249 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(in_AST.get()));
05250 }
05251 match(INC);
05252
if ( inputState->guessing==0 ) {
05253
#line 889 "java.g"
05254
in_AST->setType(POST_INC);
05255
#line 5256 "JavaRecognizer.cpp"
05256
}
05257
break;
05258 }
05259
case DEC:
05260 {
05261 de = LT(1);
05262
if ( inputState->guessing == 0 ) {
05263 de_AST = astFactory->create(de);
05264 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(de_AST.get()));
05265 }
05266 match(DEC);
05267
if ( inputState->guessing==0 ) {
05268
#line 890 "java.g"
05269
de_AST->setType(POST_DEC);
05270
#line 5271 "JavaRecognizer.cpp"
05271
}
05272
break;
05273 }
05274
case SEMI:
05275
case RBRACK:
05276
case STAR:
05277
case RCURLY:
05278
case COMMA:
05279
case RPAREN:
05280
case ASSIGN:
05281
case COLON:
05282
case PLUS_ASSIGN:
05283
case MINUS_ASSIGN:
05284
case STAR_ASSIGN:
05285
case DIV_ASSIGN:
05286
case MOD_ASSIGN:
05287
case SR_ASSIGN:
05288
case BSR_ASSIGN:
05289
case SL_ASSIGN:
05290
case BAND_ASSIGN:
05291
case BXOR_ASSIGN:
05292
case BOR_ASSIGN:
05293
case QUESTION:
05294
case LOR:
05295
case LAND:
05296
case BOR:
05297
case BXOR:
05298
case BAND:
05299
case NOT_EQUAL:
05300
case EQUAL:
05301
case LT_:
05302
case GT:
05303
case LE:
05304
case GE:
05305
case LITERAL_instanceof:
05306
case SL:
05307
case SR:
05308
case BSR:
05309
case PLUS:
05310
case MINUS:
05311
case DIV:
05312
case MOD:
05313 {
05314
break;
05315 }
05316
default:
05317 {
05318
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05319 }
05320 }
05321 }
05322 postfixExpression_AST = (currentAST.
root);
05323 }
05324
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05325
if( inputState->guessing == 0 ) {
05326
reportError(ex);
05327 consume();
05328 consumeUntil(
_tokenSet_61);
05329 }
else {
05330
throw;
05331 }
05332 }
05333
returnAST = postfixExpression_AST;
05334 }
05335
05336 void JavaRecognizer::primaryExpression() {
05337
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05338
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05339
RefJavaAST primaryExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05340
ANTLR_USE_NAMESPACE(antlr)
RefToken lbt =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05341
RefJavaAST lbt_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05342
05343
try {
05344
switch ( LA(1)) {
05345
case IDENT:
05346 {
05347
identPrimary();
05348
if (inputState->guessing==0) {
05349 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05350 }
05351 {
05352
if ((LA(1) == DOT) && (LA(2) == LITERAL_class)) {
05353
RefJavaAST tmp174_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05354
if ( inputState->guessing == 0 ) {
05355 tmp174_AST = astFactory->create(LT(1));
05356 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp174_AST.get()));
05357 }
05358 match(DOT);
05359
RefJavaAST tmp175_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05360
if ( inputState->guessing == 0 ) {
05361 tmp175_AST = astFactory->create(LT(1));
05362 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp175_AST.get()));
05363 }
05364 match(LITERAL_class);
05365 }
05366
else if ((
_tokenSet_39.member(LA(1))) && (
_tokenSet_64.member(LA(2)))) {
05367 }
05368
else {
05369
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05370 }
05371
05372 }
05373 primaryExpression_AST = (currentAST.
root);
05374
break;
05375 }
05376
case NUM_INT:
05377
case CHAR_LITERAL:
05378
case STRING_LITERAL:
05379
case NUM_FLOAT:
05380
case NUM_LONG:
05381
case NUM_DOUBLE:
05382 {
05383
constant();
05384
if (inputState->guessing==0) {
05385 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05386 }
05387 primaryExpression_AST = (currentAST.
root);
05388
break;
05389 }
05390
case LITERAL_true:
05391 {
05392
RefJavaAST tmp176_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05393
if ( inputState->guessing == 0 ) {
05394 tmp176_AST = astFactory->create(LT(1));
05395 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp176_AST.get()));
05396 }
05397 match(LITERAL_true);
05398 primaryExpression_AST = (currentAST.
root);
05399
break;
05400 }
05401
case LITERAL_false:
05402 {
05403
RefJavaAST tmp177_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05404
if ( inputState->guessing == 0 ) {
05405 tmp177_AST = astFactory->create(LT(1));
05406 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp177_AST.get()));
05407 }
05408 match(LITERAL_false);
05409 primaryExpression_AST = (currentAST.
root);
05410
break;
05411 }
05412
case LITERAL_null:
05413 {
05414
RefJavaAST tmp178_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05415
if ( inputState->guessing == 0 ) {
05416 tmp178_AST = astFactory->create(LT(1));
05417 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp178_AST.get()));
05418 }
05419 match(LITERAL_null);
05420 primaryExpression_AST = (currentAST.
root);
05421
break;
05422 }
05423
case LITERAL_new:
05424 {
05425
newExpression();
05426
if (inputState->guessing==0) {
05427 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05428 }
05429 primaryExpression_AST = (currentAST.
root);
05430
break;
05431 }
05432
case LITERAL_this:
05433 {
05434
RefJavaAST tmp179_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05435
if ( inputState->guessing == 0 ) {
05436 tmp179_AST = astFactory->create(LT(1));
05437 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp179_AST.get()));
05438 }
05439 match(LITERAL_this);
05440 primaryExpression_AST = (currentAST.
root);
05441
break;
05442 }
05443
case LITERAL_super:
05444 {
05445
RefJavaAST tmp180_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05446
if ( inputState->guessing == 0 ) {
05447 tmp180_AST = astFactory->create(LT(1));
05448 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp180_AST.get()));
05449 }
05450 match(LITERAL_super);
05451 primaryExpression_AST = (currentAST.
root);
05452
break;
05453 }
05454
case LPAREN:
05455 {
05456 match(LPAREN);
05457
assignmentExpression();
05458
if (inputState->guessing==0) {
05459 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05460 }
05461 match(RPAREN);
05462 primaryExpression_AST = (currentAST.
root);
05463
break;
05464 }
05465
case LITERAL_void:
05466
case LITERAL_boolean:
05467
case LITERAL_byte:
05468
case LITERAL_char:
05469
case LITERAL_short:
05470
case LITERAL_int:
05471
case LITERAL_float:
05472
case LITERAL_long:
05473
case LITERAL_double:
05474 {
05475
builtInType();
05476
if (inputState->guessing==0) {
05477 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05478 }
05479 {
05480
for (;;) {
05481
if ((LA(1) == LBRACK)) {
05482 lbt = LT(1);
05483
if ( inputState->guessing == 0 ) {
05484 lbt_AST = astFactory->create(lbt);
05485 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lbt_AST.get()));
05486 }
05487 match(LBRACK);
05488
if ( inputState->guessing==0 ) {
05489
#line 907 "java.g"
05490
lbt_AST->setType(ARRAY_DECLARATOR);
05491
#line 5492 "JavaRecognizer.cpp"
05492
}
05493 match(RBRACK);
05494 }
05495
else {
05496
goto _loop178;
05497 }
05498
05499 }
05500 _loop178:;
05501 }
05502
RefJavaAST tmp184_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05503
if ( inputState->guessing == 0 ) {
05504 tmp184_AST = astFactory->create(LT(1));
05505 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp184_AST.get()));
05506 }
05507 match(DOT);
05508
RefJavaAST tmp185_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05509
if ( inputState->guessing == 0 ) {
05510 tmp185_AST = astFactory->create(LT(1));
05511 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp185_AST.get()));
05512 }
05513 match(LITERAL_class);
05514 primaryExpression_AST = (currentAST.
root);
05515
break;
05516 }
05517
default:
05518 {
05519
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05520 }
05521 }
05522 }
05523
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05524
if( inputState->guessing == 0 ) {
05525
reportError(ex);
05526 consume();
05527 consumeUntil(
_tokenSet_39);
05528 }
else {
05529
throw;
05530 }
05531 }
05532
returnAST = primaryExpression_AST;
05533 }
05534
05584 void JavaRecognizer::newExpression() {
05585
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05586
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05587
RefJavaAST newExpression_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05588
05589
try {
05590
RefJavaAST tmp186_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05591
if ( inputState->guessing == 0 ) {
05592 tmp186_AST = astFactory->create(LT(1));
05593 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp186_AST.get()));
05594 }
05595 match(LITERAL_new);
05596
type();
05597
if (inputState->guessing==0) {
05598 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05599 }
05600 {
05601
switch ( LA(1)) {
05602
case LPAREN:
05603 {
05604 match(LPAREN);
05605
argList();
05606
if (inputState->guessing==0) {
05607 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05608 }
05609 match(RPAREN);
05610 {
05611
switch ( LA(1)) {
05612
case LCURLY:
05613 {
05614
classBlock();
05615
if (inputState->guessing==0) {
05616 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05617 }
05618
break;
05619 }
05620
case SEMI:
05621
case LBRACK:
05622
case RBRACK:
05623
case DOT:
05624
case STAR:
05625
case RCURLY:
05626
case COMMA:
05627
case RPAREN:
05628
case ASSIGN:
05629
case COLON:
05630
case PLUS_ASSIGN:
05631
case MINUS_ASSIGN:
05632
case STAR_ASSIGN:
05633
case DIV_ASSIGN:
05634
case MOD_ASSIGN:
05635
case SR_ASSIGN:
05636
case BSR_ASSIGN:
05637
case SL_ASSIGN:
05638
case BAND_ASSIGN:
05639
case BXOR_ASSIGN:
05640
case BOR_ASSIGN:
05641
case QUESTION:
05642
case LOR:
05643
case LAND:
05644
case BOR:
05645
case BXOR:
05646
case BAND:
05647
case NOT_EQUAL:
05648
case EQUAL:
05649
case LT_:
05650
case GT:
05651
case LE:
05652
case GE:
05653
case LITERAL_instanceof:
05654
case SL:
05655
case SR:
05656
case BSR:
05657
case PLUS:
05658
case MINUS:
05659
case DIV:
05660
case MOD:
05661
case INC:
05662
case DEC:
05663 {
05664
break;
05665 }
05666
default:
05667 {
05668
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05669 }
05670 }
05671 }
05672
break;
05673 }
05674
case LBRACK:
05675 {
05676
newArrayDeclarator();
05677
if (inputState->guessing==0) {
05678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05679 }
05680 {
05681
switch ( LA(1)) {
05682
case LCURLY:
05683 {
05684
arrayInitializer();
05685
if (inputState->guessing==0) {
05686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05687 }
05688
break;
05689 }
05690
case SEMI:
05691
case LBRACK:
05692
case RBRACK:
05693
case DOT:
05694
case STAR:
05695
case RCURLY:
05696
case COMMA:
05697
case RPAREN:
05698
case ASSIGN:
05699
case COLON:
05700
case PLUS_ASSIGN:
05701
case MINUS_ASSIGN:
05702
case STAR_ASSIGN:
05703
case DIV_ASSIGN:
05704
case MOD_ASSIGN:
05705
case SR_ASSIGN:
05706
case BSR_ASSIGN:
05707
case SL_ASSIGN:
05708
case BAND_ASSIGN:
05709
case BXOR_ASSIGN:
05710
case BOR_ASSIGN:
05711
case QUESTION:
05712
case LOR:
05713
case LAND:
05714
case BOR:
05715
case BXOR:
05716
case BAND:
05717
case NOT_EQUAL:
05718
case EQUAL:
05719
case LT_:
05720
case GT:
05721
case LE:
05722
case GE:
05723
case LITERAL_instanceof:
05724
case SL:
05725
case SR:
05726
case BSR:
05727
case PLUS:
05728
case MINUS:
05729
case DIV:
05730
case MOD:
05731
case INC:
05732
case DEC:
05733 {
05734
break;
05735 }
05736
default:
05737 {
05738
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05739 }
05740 }
05741 }
05742
break;
05743 }
05744
default:
05745 {
05746
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05747 }
05748 }
05749 }
05750 newExpression_AST = (currentAST.
root);
05751 }
05752
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05753
if( inputState->guessing == 0 ) {
05754
reportError(ex);
05755 consume();
05756 consumeUntil(
_tokenSet_39);
05757 }
else {
05758
throw;
05759 }
05760 }
05761
returnAST = newExpression_AST;
05762 }
05763
05768 void JavaRecognizer::identPrimary() {
05769
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05770
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05771
RefJavaAST identPrimary_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05772
ANTLR_USE_NAMESPACE(antlr)
RefToken lp =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05773
RefJavaAST lp_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05774
ANTLR_USE_NAMESPACE(antlr)
RefToken lbc =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05775
RefJavaAST lbc_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05776
05777
try {
05778
RefJavaAST tmp189_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05779
if ( inputState->guessing == 0 ) {
05780 tmp189_AST = astFactory->create(LT(1));
05781 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp189_AST.get()));
05782 }
05783 match(IDENT);
05784 {
05785
for (;;) {
05786
if ((LA(1) == DOT) && (LA(2) == IDENT)) {
05787
RefJavaAST tmp190_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05788
if ( inputState->guessing == 0 ) {
05789 tmp190_AST = astFactory->create(LT(1));
05790 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp190_AST.get()));
05791 }
05792 match(DOT);
05793
RefJavaAST tmp191_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05794
if ( inputState->guessing == 0 ) {
05795 tmp191_AST = astFactory->create(LT(1));
05796 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp191_AST.get()));
05797 }
05798 match(IDENT);
05799 }
05800
else {
05801
goto _loop181;
05802 }
05803
05804 }
05805 _loop181:;
05806 }
05807 {
05808
if ((LA(1) == LPAREN)) {
05809 {
05810 lp = LT(1);
05811
if ( inputState->guessing == 0 ) {
05812 lp_AST = astFactory->create(lp);
05813 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lp_AST.get()));
05814 }
05815 match(LPAREN);
05816
if ( inputState->guessing==0 ) {
05817
#line 933 "java.g"
05818
lp_AST->setType(METHOD_CALL);
05819
#line 5820 "JavaRecognizer.cpp"
05820
}
05821
argList();
05822
if (inputState->guessing==0) {
05823 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05824 }
05825 match(RPAREN);
05826 }
05827 }
05828
else if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
05829 {
05830
int _cnt185=0;
05831
for (;;) {
05832
if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
05833 lbc = LT(1);
05834
if ( inputState->guessing == 0 ) {
05835 lbc_AST = astFactory->create(lbc);
05836 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lbc_AST.get()));
05837 }
05838 match(LBRACK);
05839
if ( inputState->guessing==0 ) {
05840
#line 935 "java.g"
05841
lbc_AST->setType(ARRAY_DECLARATOR);
05842
#line 5843 "JavaRecognizer.cpp"
05843
}
05844 match(RBRACK);
05845 }
05846
else {
05847
if ( _cnt185>=1 ) {
goto _loop185; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
05848 }
05849
05850 _cnt185++;
05851 }
05852 _loop185:;
05853 }
05854 }
05855
else if ((
_tokenSet_39.member(LA(1))) && (
_tokenSet_64.member(LA(2)))) {
05856 }
05857
else {
05858
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05859 }
05860
05861 }
05862 identPrimary_AST = (currentAST.
root);
05863 }
05864
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05865
if( inputState->guessing == 0 ) {
05866
reportError(ex);
05867 consume();
05868 consumeUntil(
_tokenSet_39);
05869 }
else {
05870
throw;
05871 }
05872 }
05873
returnAST = identPrimary_AST;
05874 }
05875
05876 void JavaRecognizer::constant() {
05877
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05878
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05879
RefJavaAST constant_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05880
05881
try {
05882
switch ( LA(1)) {
05883
case NUM_INT:
05884 {
05885
RefJavaAST tmp194_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05886
if ( inputState->guessing == 0 ) {
05887 tmp194_AST = astFactory->create(LT(1));
05888 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp194_AST.get()));
05889 }
05890 match(NUM_INT);
05891 constant_AST = (currentAST.
root);
05892
break;
05893 }
05894
case CHAR_LITERAL:
05895 {
05896
RefJavaAST tmp195_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05897
if ( inputState->guessing == 0 ) {
05898 tmp195_AST = astFactory->create(LT(1));
05899 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp195_AST.get()));
05900 }
05901 match(CHAR_LITERAL);
05902 constant_AST = (currentAST.
root);
05903
break;
05904 }
05905
case STRING_LITERAL:
05906 {
05907
RefJavaAST tmp196_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05908
if ( inputState->guessing == 0 ) {
05909 tmp196_AST = astFactory->create(LT(1));
05910 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp196_AST.get()));
05911 }
05912 match(STRING_LITERAL);
05913 constant_AST = (currentAST.
root);
05914
break;
05915 }
05916
case NUM_FLOAT:
05917 {
05918
RefJavaAST tmp197_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05919
if ( inputState->guessing == 0 ) {
05920 tmp197_AST = astFactory->create(LT(1));
05921 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp197_AST.get()));
05922 }
05923 match(NUM_FLOAT);
05924 constant_AST = (currentAST.
root);
05925
break;
05926 }
05927
case NUM_LONG:
05928 {
05929
RefJavaAST tmp198_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05930
if ( inputState->guessing == 0 ) {
05931 tmp198_AST = astFactory->create(LT(1));
05932 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp198_AST.get()));
05933 }
05934 match(NUM_LONG);
05935 constant_AST = (currentAST.
root);
05936
break;
05937 }
05938
case NUM_DOUBLE:
05939 {
05940
RefJavaAST tmp199_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05941
if ( inputState->guessing == 0 ) {
05942 tmp199_AST = astFactory->create(LT(1));
05943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp199_AST.get()));
05944 }
05945 match(NUM_DOUBLE);
05946 constant_AST = (currentAST.
root);
05947
break;
05948 }
05949
default:
05950 {
05951
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05952 }
05953 }
05954 }
05955
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05956
if( inputState->guessing == 0 ) {
05957
reportError(ex);
05958 consume();
05959 consumeUntil(
_tokenSet_39);
05960 }
else {
05961
throw;
05962 }
05963 }
05964
returnAST = constant_AST;
05965 }
05966
05967 void JavaRecognizer::newArrayDeclarator() {
05968
returnAST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05969
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05970
RefJavaAST newArrayDeclarator_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05971
ANTLR_USE_NAMESPACE(antlr)
RefToken lb =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05972
RefJavaAST lb_AST = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05973
05974
try {
05975 {
05976
int _cnt195=0;
05977
for (;;) {
05978
if ((LA(1) == LBRACK) && (
_tokenSet_65.member(LA(2)))) {
05979 lb = LT(1);
05980
if ( inputState->guessing == 0 ) {
05981 lb_AST = astFactory->create(lb);
05982 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(lb_AST.get()));
05983 }
05984 match(LBRACK);
05985
if ( inputState->guessing==0 ) {
05986
#line 1023 "java.g"
05987
lb_AST->setType(ARRAY_DECLARATOR);
05988
#line 5989 "JavaRecognizer.cpp"
05989
}
05990 {
05991
switch ( LA(1)) {
05992
case LITERAL_void:
05993
case LITERAL_boolean:
05994
case LITERAL_byte:
05995
case LITERAL_char:
05996
case LITERAL_short:
05997
case LITERAL_int:
05998
case LITERAL_float:
05999
case LITERAL_long:
06000
case LITERAL_double:
06001
case IDENT:
06002
case LPAREN:
06003
case LITERAL_this:
06004
case LITERAL_super:
06005
case PLUS:
06006
case MINUS:
06007
case INC:
06008
case DEC:
06009
case BNOT:
06010
case LNOT:
06011
case LITERAL_true:
06012
case LITERAL_false:
06013
case LITERAL_null:
06014
case LITERAL_new:
06015
case NUM_INT:
06016
case CHAR_LITERAL:
06017
case STRING_LITERAL:
06018
case NUM_FLOAT:
06019
case NUM_LONG:
06020
case NUM_DOUBLE:
06021 {
06022
expression();
06023
if (inputState->guessing==0) {
06024 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06025 }
06026
break;
06027 }
06028
case RBRACK:
06029 {
06030
break;
06031 }
06032
default:
06033 {
06034
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06035 }
06036 }
06037 }
06038 match(RBRACK);
06039 }
06040
else {
06041
if ( _cnt195>=1 ) {
goto _loop195; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
06042 }
06043
06044 _cnt195++;
06045 }
06046 _loop195:;
06047 }
06048 newArrayDeclarator_AST = (currentAST.
root);
06049 }
06050
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06051
if( inputState->guessing == 0 ) {
06052
reportError(ex);
06053 consume();
06054 consumeUntil(
_tokenSet_66);
06055 }
else {
06056
throw;
06057 }
06058 }
06059
returnAST = newArrayDeclarator_AST;
06060 }
06061
06062 RefJavaAST JavaRecognizer::getAST()
06063 {
06064
return returnAST;
06065 }
06066
06067 void JavaRecognizer::initializeASTFactory(
ANTLR_USE_NAMESPACE(antlr)
ASTFactory& factory )
06068 {
06069 factory.setMaxNodeType(151);
06070 }
06071 const char*
JavaRecognizer::tokenNames[] = {
06072
"<0>",
06073
"EOF",
06074
"<2>",
06075
"NULL_TREE_LOOKAHEAD",
06076
"BLOCK",
06077
"MODIFIERS",
06078
"OBJBLOCK",
06079
"SLIST",
06080
"CTOR_DEF",
06081
"METHOD_DEF",
06082
"VARIABLE_DEF",
06083
"INSTANCE_INIT",
06084
"STATIC_INIT",
06085
"TYPE",
06086
"CLASS_DEF",
06087
"INTERFACE_DEF",
06088
"PACKAGE_DEF",
06089
"ARRAY_DECLARATOR",
06090
"EXTENDS_CLAUSE",
06091
"IMPLEMENTS_CLAUSE",
06092
"PARAMETERS",
06093
"PARAMETER_DEF",
06094
"LABELED_STAT",
06095
"TYPECAST",
06096
"INDEX_OP",
06097
"POST_INC",
06098
"POST_DEC",
06099
"METHOD_CALL",
06100
"EXPR",
06101
"ARRAY_INIT",
06102
"IMPORT",
06103
"UNARY_MINUS",
06104
"UNARY_PLUS",
06105
"CASE_GROUP",
06106
"ELIST",
06107
"FOR_INIT",
06108
"FOR_CONDITION",
06109
"FOR_ITERATOR",
06110
"EMPTY_STAT",
06111
"\"final\"",
06112
"\"abstract\"",
06113
"\"strictfp\"",
06114
"SUPER_CTOR_CALL",
06115
"CTOR_CALL",
06116
"\"package\"",
06117
"SEMI",
06118
"\"import\"",
06119
"LBRACK",
06120
"RBRACK",
06121
"\"void\"",
06122
"\"boolean\"",
06123
"\"byte\"",
06124
"\"char\"",
06125
"\"short\"",
06126
"\"int\"",
06127
"\"float\"",
06128
"\"long\"",
06129
"\"double\"",
06130
"IDENT",
06131
"DOT",
06132
"STAR",
06133
"\"private\"",
06134
"\"public\"",
06135
"\"protected\"",
06136
"\"static\"",
06137
"\"transient\"",
06138
"\"native\"",
06139
"\"threadsafe\"",
06140
"\"synchronized\"",
06141
"\"volatile\"",
06142
"\"class\"",
06143
"\"extends\"",
06144
"\"interface\"",
06145
"LCURLY",
06146
"RCURLY",
06147
"COMMA",
06148
"\"implements\"",
06149
"LPAREN",
06150
"RPAREN",
06151
"\"this\"",
06152
"\"super\"",
06153
"ASSIGN",
06154
"\"throws\"",
06155
"COLON",
06156
"\"if\"",
06157
"\"else\"",
06158
"\"for\"",
06159
"\"while\"",
06160
"\"do\"",
06161
"\"break\"",
06162
"\"continue\"",
06163
"\"return\"",
06164
"\"switch\"",
06165
"\"throw\"",
06166
"\"case\"",
06167
"\"default\"",
06168
"\"try\"",
06169
"\"finally\"",
06170
"\"catch\"",
06171
"PLUS_ASSIGN",
06172
"MINUS_ASSIGN",
06173
"STAR_ASSIGN",
06174
"DIV_ASSIGN",
06175
"MOD_ASSIGN",
06176
"SR_ASSIGN",
06177
"BSR_ASSIGN",
06178
"SL_ASSIGN",
06179
"BAND_ASSIGN",
06180
"BXOR_ASSIGN",
06181
"BOR_ASSIGN",
06182
"QUESTION",
06183
"LOR",
06184
"LAND",
06185
"BOR",
06186
"BXOR",
06187
"BAND",
06188
"NOT_EQUAL",
06189
"EQUAL",
06190
"LT_",
06191
"GT",
06192
"LE",
06193
"GE",
06194
"\"instanceof\"",
06195
"SL",
06196
"SR",
06197
"BSR",
06198
"PLUS",
06199
"MINUS",
06200
"DIV",
06201
"MOD",
06202
"INC",
06203
"DEC",
06204
"BNOT",
06205
"LNOT",
06206
"\"true\"",
06207
"\"false\"",
06208
"\"null\"",
06209
"\"new\"",
06210
"NUM_INT",
06211
"CHAR_LITERAL",
06212
"STRING_LITERAL",
06213
"NUM_FLOAT",
06214
"NUM_LONG",
06215
"NUM_DOUBLE",
06216
"WS",
06217
"SL_COMMENT",
06218
"ML_COMMENT",
06219
"ESC",
06220
"HEX_DIGIT",
06221
"VOCAB",
06222
"EXPONENT",
06223
"FLOAT_SUFFIX",
06224 0
06225 };
06226
06227 const unsigned long JavaRecognizer::_tokenSet_0_data_[] = { 0UL, 3758105472UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06228
06229
06230
06231
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_0(_tokenSet_0_data_,8);
06232 const
unsigned long JavaRecognizer::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06233
06234
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_1(_tokenSet_1_data_,6);
06235 const
unsigned long JavaRecognizer::_tokenSet_2_data_[] = { 2UL, 3758121856UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06236
06237
06238
06239
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_2(_tokenSet_2_data_,8);
06240 const
unsigned long JavaRecognizer::_tokenSet_3_data_[] = { 2UL, 3758105472UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06241
06242
06243
06244
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_3(_tokenSet_3_data_,8);
06245 const
unsigned long JavaRecognizer::_tokenSet_4_data_[] = { 0UL, 67215360UL, 687616UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
06246
06247
06248
06249
06250
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_4(_tokenSet_4_data_,8);
06251 const
unsigned long JavaRecognizer::_tokenSet_5_data_[] = { 0UL, 8192UL, 0UL, 0UL, 0UL, 0UL };
06252
06253
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_5(_tokenSet_5_data_,6);
06254 const
unsigned long JavaRecognizer::_tokenSet_6_data_[] = { 0UL, 3758097280UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06255
06256
06257
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_6(_tokenSet_6_data_,8);
06258 const
unsigned long JavaRecognizer::_tokenSet_7_data_[] = { 0UL, 134086656UL, 320UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06259
06260
06261
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_7(_tokenSet_7_data_,8);
06262 const
unsigned long JavaRecognizer::_tokenSet_8_data_[] = { 2UL, 3892192128UL, 4294027135UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06263
06264
06265
06266
06267
06268
06269
06270
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_8(_tokenSet_8_data_,12);
06271 const
unsigned long JavaRecognizer::_tokenSet_9_data_[] = { 2UL, 3892192128UL, 1919UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06272
06273
06274
06275
06276
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_9(_tokenSet_9_data_,8);
06277 const
unsigned long JavaRecognizer::_tokenSet_10_data_[] = { 0UL, 67182592UL, 674816UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
06278
06279
06280
06281
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_10(_tokenSet_10_data_,8);
06282 const
unsigned long JavaRecognizer::_tokenSet_11_data_[] = { 0UL, 201433088UL, 683008UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
06283
06284
06285
06286
06287
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_11(_tokenSet_11_data_,8);
06288 const
unsigned long JavaRecognizer::_tokenSet_12_data_[] = { 0UL, 32768UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06289
06290
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_12(_tokenSet_12_data_,8);
06291 const
unsigned long JavaRecognizer::_tokenSet_13_data_[] = { 0UL, 3892183936UL, 383UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06292
06293
06294
06295
06296
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_13(_tokenSet_13_data_,8);
06297 const
unsigned long JavaRecognizer::_tokenSet_14_data_[] = { 0UL, 0UL, 4608UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06298
06299
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_14(_tokenSet_14_data_,8);
06300 const
unsigned long JavaRecognizer::_tokenSet_15_data_[] = { 0UL, 0UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06301
06302
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_15(_tokenSet_15_data_,8);
06303 const
unsigned long JavaRecognizer::_tokenSet_16_data_[] = { 2UL, 4294943616UL, 4294700927UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06304
06305
06306
06307
06308
06309
06310
06311
06312
06313
06314
06315
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_16(_tokenSet_16_data_,12);
06316 const
unsigned long JavaRecognizer::_tokenSet_17_data_[] = { 0UL, 4026434432UL, 8575UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06317
06318
06319
06320
06321
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_17(_tokenSet_17_data_,8);
06322 const
unsigned long JavaRecognizer::_tokenSet_18_data_[] = { 0UL, 201359360UL, 0UL, 0UL, 0UL, 0UL };
06323
06324
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_18(_tokenSet_18_data_,6);
06325 const
unsigned long JavaRecognizer::_tokenSet_19_data_[] = { 0UL, 40960UL, 133120UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06326
06327
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_19(_tokenSet_19_data_,8);
06328 const
unsigned long JavaRecognizer::_tokenSet_20_data_[] = { 0UL, 3892192128UL, 1919UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06329
06330
06331
06332
06333
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_20(_tokenSet_20_data_,8);
06334 const
unsigned long JavaRecognizer::_tokenSet_21_data_[] = { 0UL, 3892192128UL, 1070704255UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06335
06336
06337
06338
06339
06340
06341
06342
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_21(_tokenSet_21_data_,12);
06343 const
unsigned long JavaRecognizer::_tokenSet_22_data_[] = { 0UL, 4294878080UL, 1071359871UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06344
06345
06346
06347
06348
06349
06350
06351
06352
06353
06354
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_22(_tokenSet_22_data_,12);
06355 const
unsigned long JavaRecognizer::_tokenSet_23_data_[] = { 0UL, 3892192128UL, 1070703231UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06356
06357
06358
06359
06360
06361
06362
06363
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_23(_tokenSet_23_data_,12);
06364 const
unsigned long JavaRecognizer::_tokenSet_24_data_[] = { 0UL, 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06365
06366
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_24(_tokenSet_24_data_,8);
06367 const
unsigned long JavaRecognizer::_tokenSet_25_data_[] = { 0UL, 8192UL, 412160UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06368
06369
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_25(_tokenSet_25_data_,8);
06370 const
unsigned long JavaRecognizer::_tokenSet_26_data_[] = { 0UL, 8192UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06371
06372
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_26(_tokenSet_26_data_,8);
06373 const
unsigned long JavaRecognizer::_tokenSet_27_data_[] = { 0UL, 3892192128UL, 4294027135UL, 3221225479UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06374
06375
06376
06377
06378
06379
06380
06381
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_27(_tokenSet_27_data_,12);
06382 const
unsigned long JavaRecognizer::_tokenSet_28_data_[] = { 0UL, 3892192128UL, 4294026879UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06383
06384
06385
06386
06387
06388
06389
06390
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_28(_tokenSet_28_data_,12);
06391 const
unsigned long JavaRecognizer::_tokenSet_29_data_[] = { 0UL, 4294878080UL, 4294682495UL, 4294967295UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06392
06393
06394
06395
06396
06397
06398
06399
06400
06401
06402
06403
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_29(_tokenSet_29_data_,12);
06404 const
unsigned long JavaRecognizer::_tokenSet_30_data_[] = { 0UL, 3892183936UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06405
06406
06407
06408
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_30(_tokenSet_30_data_,8);
06409 const
unsigned long JavaRecognizer::_tokenSet_31_data_[] = { 0UL, 4026434432UL, 63UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06410
06411
06412
06413
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_31(_tokenSet_31_data_,8);
06414 const
unsigned long JavaRecognizer::_tokenSet_32_data_[] = { 0UL, 134086656UL, 106496UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06415
06416
06417
06418
06419
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_32(_tokenSet_32_data_,12);
06420 const
unsigned long JavaRecognizer::_tokenSet_33_data_[] = { 0UL, 536780800UL, 237568UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06421
06422
06423
06424
06425
06426
06427
06428
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_33(_tokenSet_33_data_,12);
06429 const
unsigned long JavaRecognizer::_tokenSet_34_data_[] = { 0UL, 3758097280UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06430
06431
06432
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_34(_tokenSet_34_data_,8);
06433 const
unsigned long JavaRecognizer::_tokenSet_35_data_[] = { 0UL, 3825206144UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06434
06435
06436
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_35(_tokenSet_35_data_,8);
06437 const
unsigned long JavaRecognizer::_tokenSet_36_data_[] = { 0UL, 8192UL, 2048UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06438
06439
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_36(_tokenSet_36_data_,8);
06440 const
unsigned long JavaRecognizer::_tokenSet_37_data_[] = { 0UL, 8192UL, 3072UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06441
06442
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_37(_tokenSet_37_data_,8);
06443 const
unsigned long JavaRecognizer::_tokenSet_38_data_[] = { 0UL, 134086656UL, 107008UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06444
06445
06446
06447
06448
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_38(_tokenSet_38_data_,12);
06449 const
unsigned long JavaRecognizer::_tokenSet_39_data_[] = { 0UL, 402759680UL, 674816UL, 4294967288UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06450
06451
06452
06453
06454
06455
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_39(_tokenSet_39_data_,12);
06456 const
unsigned long JavaRecognizer::_tokenSet_40_data_[] = { 0UL, 73728UL, 543744UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06457
06458
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_40(_tokenSet_40_data_,8);
06459 const
unsigned long JavaRecognizer::_tokenSet_41_data_[] = { 0UL, 0UL, 18432UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06460
06461
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_41(_tokenSet_41_data_,8);
06462 const
unsigned long JavaRecognizer::_tokenSet_42_data_[] = { 0UL, 134086656UL, 0UL, 0UL, 0UL, 0UL };
06463
06464
06465
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_42(_tokenSet_42_data_,6);
06466 const
unsigned long JavaRecognizer::_tokenSet_43_data_[] = { 0UL, 536780800UL, 239616UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06467
06468
06469
06470
06471
06472
06473
06474
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_43(_tokenSet_43_data_,12);
06475 const
unsigned long JavaRecognizer::_tokenSet_44_data_[] = { 0UL, 134086656UL, 630784UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06476
06477
06478
06479
06480
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_44(_tokenSet_44_data_,12);
06481 const
unsigned long JavaRecognizer::_tokenSet_45_data_[] = { 0UL, 0UL, 3221226496UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06482
06483
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_45(_tokenSet_45_data_,8);
06484 const
unsigned long JavaRecognizer::_tokenSet_46_data_[] = { 0UL, 3892192128UL, 4291929727UL, 3221225473UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06485
06486
06487
06488
06489
06490
06491
06492
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_46(_tokenSet_46_data_,12);
06493 const
unsigned long JavaRecognizer::_tokenSet_47_data_[] = { 0UL, 8192UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06494
06495
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_47(_tokenSet_47_data_,8);
06496 const
unsigned long JavaRecognizer::_tokenSet_48_data_[] = { 0UL, 3892192128UL, 4294026879UL, 3221225479UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06497
06498
06499
06500
06501
06502
06503
06504
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_48(_tokenSet_48_data_,12);
06505 const
unsigned long JavaRecognizer::_tokenSet_49_data_[] = { 0UL, 73728UL, 674816UL, 16376UL, 0UL, 0UL, 0UL, 0UL };
06506
06507
06508
06509
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_49(_tokenSet_49_data_,8);
06510 const
unsigned long JavaRecognizer::_tokenSet_50_data_[] = { 0UL, 73728UL, 674816UL, 32760UL, 0UL, 0UL, 0UL, 0UL };
06511
06512
06513
06514
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_50(_tokenSet_50_data_,8);
06515 const
unsigned long JavaRecognizer::_tokenSet_51_data_[] = { 0UL, 73728UL, 674816UL, 65528UL, 0UL, 0UL, 0UL, 0UL };
06516
06517
06518
06519
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_51(_tokenSet_51_data_,8);
06520 const
unsigned long JavaRecognizer::_tokenSet_52_data_[] = { 0UL, 73728UL, 674816UL, 131064UL, 0UL, 0UL, 0UL, 0UL };
06521
06522
06523
06524
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_52(_tokenSet_52_data_,8);
06525 const
unsigned long JavaRecognizer::_tokenSet_53_data_[] = { 0UL, 73728UL, 674816UL, 262136UL, 0UL, 0UL, 0UL, 0UL };
06526
06527
06528
06529
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_53(_tokenSet_53_data_,8);
06530 const
unsigned long JavaRecognizer::_tokenSet_54_data_[] = { 0UL, 73728UL, 674816UL, 524280UL, 0UL, 0UL, 0UL, 0UL };
06531
06532
06533
06534
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_54(_tokenSet_54_data_,8);
06535 const
unsigned long JavaRecognizer::_tokenSet_55_data_[] = { 0UL, 73728UL, 674816UL, 1048568UL, 0UL, 0UL, 0UL, 0UL };
06536
06537
06538
06539
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_55(_tokenSet_55_data_,8);
06540 const
unsigned long JavaRecognizer::_tokenSet_56_data_[] = { 0UL, 73728UL, 674816UL, 4194296UL, 0UL, 0UL, 0UL, 0UL };
06541
06542
06543
06544
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_56(_tokenSet_56_data_,8);
06545 const
unsigned long JavaRecognizer::_tokenSet_57_data_[] = { 0UL, 73728UL, 674816UL, 134217720UL, 0UL, 0UL, 0UL, 0UL };
06546
06547
06548
06549
06550
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_57(_tokenSet_57_data_,8);
06551 const
unsigned long JavaRecognizer::_tokenSet_58_data_[] = { 0UL, 73728UL, 674816UL, 1073741816UL, 0UL, 0UL, 0UL, 0UL };
06552
06553
06554
06555
06556
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_58(_tokenSet_58_data_,8);
06557 const
unsigned long JavaRecognizer::_tokenSet_59_data_[] = { 0UL, 268435456UL, 0UL, 0UL, 3UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06558
06559
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_59(_tokenSet_59_data_,12);
06560 const
unsigned long JavaRecognizer::_tokenSet_60_data_[] = { 0UL, 73728UL, 674816UL, 4294967288UL, 0UL, 0UL, 0UL, 0UL };
06561
06562
06563
06564
06565
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_60(_tokenSet_60_data_,8);
06566 const
unsigned long JavaRecognizer::_tokenSet_61_data_[] = { 0UL, 268509184UL, 674816UL, 4294967288UL, 3UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06567
06568
06569
06570
06571
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_61(_tokenSet_61_data_,12);
06572 const
unsigned long JavaRecognizer::_tokenSet_62_data_[] = { 0UL, 134086656UL, 106496UL, 0UL, 65472UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06573
06574
06575
06576
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_62(_tokenSet_62_data_,12);
06577 const
unsigned long JavaRecognizer::_tokenSet_63_data_[] = { 0UL, 536846336UL, 781312UL, 4294967288UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06578
06579
06580
06581
06582
06583
06584
06585
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_63(_tokenSet_63_data_,12);
06586 const
unsigned long JavaRecognizer::_tokenSet_64_data_[] = { 0UL, 4294943616UL, 4294700927UL, 4294967289UL, 65535UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06587
06588
06589
06590
06591
06592
06593
06594
06595
06596
06597
06598
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_64(_tokenSet_64_data_,12);
06599 const
unsigned long JavaRecognizer::_tokenSet_65_data_[] = { 0UL, 134152192UL, 106496UL, 3221225472UL, 65532UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06600
06601
06602
06603
06604
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_65(_tokenSet_65_data_,12);
06605 const
unsigned long JavaRecognizer::_tokenSet_66_data_[] = { 0UL, 402759680UL, 675328UL, 4294967288UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
06606
06607
06608
06609
06610
06611
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaRecognizer::_tokenSet_66(_tokenSet_66_data_,12);
06612
06613