00001
00002
#include "JavaStoreWalker.hpp"
00003
#include <antlr/Token.hpp>
00004
#include <antlr/AST.hpp>
00005
#include <antlr/NoViableAltException.hpp>
00006
#include <antlr/MismatchedTokenException.hpp>
00007
#include <antlr/SemanticException.hpp>
00008
#include <antlr/BitSet.hpp>
00009
#line 1 "java.store.g"
00010
#line 11 "JavaStoreWalker.cpp"
00011 JavaStoreWalker::JavaStoreWalker()
00012 :
ANTLR_USE_NAMESPACE(antlr)
TreeParser() {
00013 }
00014
00015 void JavaStoreWalker::compilationUnit(
RefJavaAST _t) {
00016
RefJavaAST compilationUnit_AST_in = _t;
00017
#line 75 "java.store.g"
00018
QString package;
QString imp;
QStringList imports;
00019
#line 20 "JavaStoreWalker.cpp"
00020
00021
try {
00022
#line 76 "java.store.g"
00023
init();
00024
#line 25 "JavaStoreWalker.cpp"
00025
{
00026
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00027 _t = ASTNULL;
00028
switch ( _t->getType()) {
00029
case PACKAGE_DEF:
00030 {
00031 package=
packageDefinition(_t);
00032 _t =
_retTree;
00033
break;
00034 }
00035
case 3:
00036
case CLASS_DEF:
00037
case INTERFACE_DEF:
00038
case IMPORT:
00039 {
00040
break;
00041 }
00042
default:
00043 {
00044
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00045 }
00046 }
00047 }
00048 {
00049
for (;;) {
00050
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00051 _t = ASTNULL;
00052
if ((_t->getType() == IMPORT)) {
00053 imp=
importDefinition(_t);
00054 _t =
_retTree;
00055
#line 78 "java.store.g"
00056
imports << imp;
00057
#line 58 "JavaStoreWalker.cpp"
00058
}
00059
else {
00060
goto _loop4;
00061 }
00062
00063 }
00064 _loop4:;
00065 }
00066 {
00067
for (;;) {
00068
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00069 _t = ASTNULL;
00070
if ((_t->getType() == CLASS_DEF || _t->getType() == INTERFACE_DEF)) {
00071
typeDefinition(_t);
00072 _t =
_retTree;
00073 }
00074
else {
00075
goto _loop6;
00076 }
00077
00078 }
00079 _loop6:;
00080 }
00081 }
00082
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00083 reportError(ex);
00084
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00085 _t = _t->getNextSibling();
00086 }
00087
_retTree = _t;
00088 }
00089
00090 QString JavaStoreWalker::packageDefinition(RefJavaAST _t) {
00091
#line 82 "java.store.g"
00092
QString id ;
00093
#line 94 "JavaStoreWalker.cpp"
00094
RefJavaAST packageDefinition_AST_in = _t;
00095
00096
try {
00097
RefJavaAST __t8 = _t;
00098
RefJavaAST tmp1_AST_in = _t;
00099 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PACKAGE_DEF);
00100 _t = _t->getFirstChild();
00101
id=
identifier(_t);
00102 _t =
_retTree;
00103 _t = __t8;
00104 _t = _t->getNextSibling();
00105 }
00106
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00107 reportError(ex);
00108
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00109 _t = _t->getNextSibling();
00110 }
00111
_retTree = _t;
00112
return id ;
00113 }
00114
00115 QString JavaStoreWalker::importDefinition(RefJavaAST _t) {
00116
#line 86 "java.store.g"
00117
QString id ;
00118
#line 119 "JavaStoreWalker.cpp"
00119
RefJavaAST importDefinition_AST_in = _t;
00120
00121
try {
00122
RefJavaAST __t10 = _t;
00123
RefJavaAST tmp2_AST_in = _t;
00124 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IMPORT);
00125 _t = _t->getFirstChild();
00126
id=
identifierStar(_t);
00127 _t =
_retTree;
00128 _t = __t10;
00129 _t = _t->getNextSibling();
00130 }
00131
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00132 reportError(ex);
00133
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00134 _t = _t->getNextSibling();
00135 }
00136
_retTree = _t;
00137
return id ;
00138 }
00139
00140 void JavaStoreWalker::typeDefinition(RefJavaAST _t) {
00141
RefJavaAST typeDefinition_AST_in = _t;
00142
#line 90 "java.store.g"
00143
QStringList bases;
QString className;
ClassDom klass;
QStringList m;
00144
#line 145 "JavaStoreWalker.cpp"
00145
00146
try {
00147
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00148 _t = ASTNULL;
00149
switch ( _t->getType()) {
00150
case CLASS_DEF:
00151 {
00152
RefJavaAST __t12 = _t;
00153
RefJavaAST tmp3_AST_in = _t;
00154 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CLASS_DEF);
00155 _t = _t->getFirstChild();
00156 m=
modifiers(_t);
00157 _t =
_retTree;
00158
RefJavaAST tmp4_AST_in = _t;
00159 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00160 _t = _t->getNextSibling();
00161
#line 92 "java.store.g"
00162
00163 klass =
m_model->
create<
ClassModel>();
00164
QString name = QString::fromUtf8( tmp4_AST_in->getText().c_str(), tmp4_AST_in->getText().length() );
00165
QStringList path = QStringList::split(
".", name );
00166 className = path.back();
00167
00168 klass->setName( path.back() );
00169 klass->setScope(
m_currentScope );
00170 klass->setStartPosition( tmp4_AST_in->getLine(), tmp4_AST_in->getColumn() );
00172
00173 klass->setFileName(
m_file->name() );
00174
if(
m_currentClass.top() )
00175
m_currentClass.top()->addClass( klass );
00176
else
00177
m_file->addClass( klass );
00178
00179
#line 180 "JavaStoreWalker.cpp"
00180
bases=
extendsClause(_t);
00181 _t = _retTree;
00182
#line 110 "java.store.g"
00183
00184
for( QStringList::Iterator it = bases.begin(); it != bases.end(); ++it )
00185 klass->addBaseClass( *it );
00186
00187
#line 188 "JavaStoreWalker.cpp"
00188
implementsClause(_t);
00189 _t = _retTree;
00190
#line 115 "java.store.g"
00191
00192
m_currentClass.push( klass );
00193
m_currentScope.push_back( className );
00194
00195
#line 196 "JavaStoreWalker.cpp"
00196
objBlock(_t,klass);
00197 _t = _retTree;
00198
#line 120 "java.store.g"
00199
00200
m_currentClass.pop();
00201
m_currentScope.pop_back();
00202
00203
#line 204 "JavaStoreWalker.cpp"
00204
_t = __t12;
00205 _t = _t->getNextSibling();
00206
break;
00207 }
00208
case INTERFACE_DEF:
00209 {
00210
RefJavaAST __t13 = _t;
00211
RefJavaAST tmp5_AST_in = _t;
00212 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INTERFACE_DEF);
00213 _t = _t->getFirstChild();
00214 m=
modifiers(_t);
00215 _t =
_retTree;
00216
RefJavaAST tmp6_AST_in = _t;
00217 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00218 _t = _t->getNextSibling();
00219
#line 126 "java.store.g"
00220
00221 klass =
m_model->
create<
ClassModel>();
00222
QString name = QString::fromUtf8( tmp6_AST_in->getText().c_str(), tmp6_AST_in->getText().length() );
00223
QStringList path = QStringList::split(
".", name );
00224 className = path.back();
00225
00226 klass->setName( path.back() );
00227 klass->setScope(
m_currentScope );
00228 klass->setStartPosition( tmp6_AST_in->getLine(), tmp6_AST_in->getColumn() );
00230
00231 klass->setFileName(
m_file->name() );
00232
00233
if(
m_currentClass.top() )
00234
m_currentClass.top()->addClass( klass );
00235
else
00236
m_file->addClass( klass );
00237
00238
#line 239 "JavaStoreWalker.cpp"
00239
bases=
extendsClause(_t);
00240 _t = _retTree;
00241
#line 145 "java.store.g"
00242
00243
m_currentClass.push( klass );
00244
m_currentScope.push_back( className );
00245
00246
#line 247 "JavaStoreWalker.cpp"
00247
interfaceBlock(_t,klass);
00248 _t = _retTree;
00249
#line 150 "java.store.g"
00250
00251
m_currentClass.pop();
00252
m_currentScope.pop_back();
00253
00254
#line 255 "JavaStoreWalker.cpp"
00255
_t = __t13;
00256 _t = _t->getNextSibling();
00257
break;
00258 }
00259
default:
00260 {
00261
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00262 }
00263 }
00264 }
00265
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00266 reportError(ex);
00267
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00268 _t = _t->getNextSibling();
00269 }
00270
_retTree = _t;
00271 }
00272
00273 QString JavaStoreWalker::identifier(RefJavaAST _t) {
00274
#line 363 "java.store.g"
00275
QString id ;
00276
#line 277 "JavaStoreWalker.cpp"
00277
RefJavaAST identifier_AST_in = _t;
00278
00279
try {
00280
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00281 _t = ASTNULL;
00282
switch ( _t->getType()) {
00283
case IDENT:
00284 {
00285
RefJavaAST tmp7_AST_in = _t;
00286 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00287 _t = _t->getNextSibling();
00288
#line 364 "java.store.g"
00289
00290
id = tmp7_AST_in->getText().c_str();
00291
00292
#line 293 "JavaStoreWalker.cpp"
00293
break;
00294 }
00295
case DOT:
00296 {
00297
RefJavaAST __t74 = _t;
00298
RefJavaAST tmp8_AST_in = _t;
00299 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOT);
00300 _t = _t->getFirstChild();
00301
id=
identifier(_t);
00302 _t =
_retTree;
00303
RefJavaAST tmp9_AST_in = _t;
00304 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00305 _t = _t->getNextSibling();
00306 _t = __t74;
00307 _t = _t->getNextSibling();
00308
#line 367 "java.store.g"
00309
00310
id +=
QString(
".") + tmp9_AST_in->getText().c_str();
00311
00312
#line 313 "JavaStoreWalker.cpp"
00313
break;
00314 }
00315
default:
00316 {
00317
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00318 }
00319 }
00320 }
00321
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00322 reportError(ex);
00323
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00324 _t = _t->getNextSibling();
00325 }
00326
_retTree = _t;
00327
return id ;
00328 }
00329
00330 QString JavaStoreWalker::identifierStar(RefJavaAST _t) {
00331
#line 372 "java.store.g"
00332
QString id ;
00333
#line 334 "JavaStoreWalker.cpp"
00334
RefJavaAST identifierStar_AST_in = _t;
00335
00336
try {
00337
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00338 _t = ASTNULL;
00339
switch ( _t->getType()) {
00340
case IDENT:
00341 {
00342
RefJavaAST tmp10_AST_in = _t;
00343 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00344 _t = _t->getNextSibling();
00345
#line 373 "java.store.g"
00346
00347
id = tmp10_AST_in->getText().c_str();
00348
00349
#line 350 "JavaStoreWalker.cpp"
00350
break;
00351 }
00352
case DOT:
00353 {
00354
RefJavaAST __t76 = _t;
00355
RefJavaAST tmp11_AST_in = _t;
00356 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOT);
00357 _t = _t->getFirstChild();
00358
id=
identifier(_t);
00359 _t =
_retTree;
00360 {
00361
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00362 _t = ASTNULL;
00363
switch ( _t->getType()) {
00364
case STAR:
00365 {
00366
RefJavaAST tmp12_AST_in = _t;
00367 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STAR);
00368 _t = _t->getNextSibling();
00369
#line 376 "java.store.g"
00370
id +=
QString(
".") + tmp12_AST_in->getText().c_str();
00371
#line 372 "JavaStoreWalker.cpp"
00372
break;
00373 }
00374
case IDENT:
00375 {
00376
RefJavaAST tmp13_AST_in = _t;
00377 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00378 _t = _t->getNextSibling();
00379
#line 377 "java.store.g"
00380
id +=
QString(
".") + tmp13_AST_in->getText().c_str();
00381
#line 382 "JavaStoreWalker.cpp"
00382
break;
00383 }
00384
default:
00385 {
00386
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00387 }
00388 }
00389 }
00390 _t = __t76;
00391 _t = _t->getNextSibling();
00392
break;
00393 }
00394
default:
00395 {
00396
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00397 }
00398 }
00399 }
00400
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00401 reportError(ex);
00402
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00403 _t = _t->getNextSibling();
00404 }
00405
_retTree = _t;
00406
return id ;
00407 }
00408
00409 QStringList JavaStoreWalker::modifiers(RefJavaAST _t) {
00410
#line 183 "java.store.g"
00411
QStringList l ;
00412
#line 413 "JavaStoreWalker.cpp"
00413
RefJavaAST modifiers_AST_in = _t;
00414
RefJavaAST m = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00415
00416
try {
00417
RefJavaAST __t21 = _t;
00418
RefJavaAST tmp14_AST_in = _t;
00419 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MODIFIERS);
00420 _t = _t->getFirstChild();
00421 {
00422
for (;;) {
00423
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00424 _t = ASTNULL;
00425
if ((
_tokenSet_0.member(_t->getType()))) {
00426 m = (_t == ASTNULL) ? static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) : _t;
00427
modifier(_t);
00428 _t =
_retTree;
00429
#line 184 "java.store.g"
00430
l << m->getText().c_str();
00431
#line 432 "JavaStoreWalker.cpp"
00432
}
00433
else {
00434
goto _loop23;
00435 }
00436
00437 }
00438 _loop23:;
00439 }
00440 _t = __t21;
00441 _t = _t->getNextSibling();
00442 }
00443
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00444 reportError(ex);
00445
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00446 _t = _t->getNextSibling();
00447 }
00448
_retTree = _t;
00449
return l ;
00450 }
00451
00452 QStringList JavaStoreWalker::extendsClause(RefJavaAST _t) {
00453
#line 202 "java.store.g"
00454
QStringList l ;
00455
#line 456 "JavaStoreWalker.cpp"
00456
RefJavaAST extendsClause_AST_in = _t;
00457
#line 202 "java.store.g"
00458
QString id;
00459
#line 460 "JavaStoreWalker.cpp"
00460
00461
try {
00462
RefJavaAST __t26 = _t;
00463
RefJavaAST tmp15_AST_in = _t;
00464 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EXTENDS_CLAUSE);
00465 _t = _t->getFirstChild();
00466 {
00467
for (;;) {
00468
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00469 _t = ASTNULL;
00470
if ((_t->getType() == IDENT || _t->getType() == DOT)) {
00471
id=
identifier(_t);
00472 _t =
_retTree;
00473
#line 203 "java.store.g"
00474
l <<
id;
00475
#line 476 "JavaStoreWalker.cpp"
00476
}
00477
else {
00478
goto _loop28;
00479 }
00480
00481 }
00482 _loop28:;
00483 }
00484 _t = __t26;
00485 _t = _t->getNextSibling();
00486 }
00487
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00488 reportError(ex);
00489
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00490 _t = _t->getNextSibling();
00491 }
00492
_retTree = _t;
00493
return l ;
00494 }
00495
00496 QStringList JavaStoreWalker::implementsClause(RefJavaAST _t) {
00497
#line 206 "java.store.g"
00498
QStringList l ;
00499
#line 500 "JavaStoreWalker.cpp"
00500
RefJavaAST implementsClause_AST_in = _t;
00501
#line 206 "java.store.g"
00502
QString id;
00503
#line 504 "JavaStoreWalker.cpp"
00504
00505
try {
00506
RefJavaAST __t30 = _t;
00507
RefJavaAST tmp16_AST_in = _t;
00508 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IMPLEMENTS_CLAUSE);
00509 _t = _t->getFirstChild();
00510 {
00511
for (;;) {
00512
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00513 _t = ASTNULL;
00514
if ((_t->getType() == IDENT || _t->getType() == DOT)) {
00515
id=
identifier(_t);
00516 _t =
_retTree;
00517
#line 207 "java.store.g"
00518
l <<
id;
00519
#line 520 "JavaStoreWalker.cpp"
00520
}
00521
else {
00522
goto _loop32;
00523 }
00524
00525 }
00526 _loop32:;
00527 }
00528 _t = __t30;
00529 _t = _t->getNextSibling();
00530 }
00531
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00532 reportError(ex);
00533
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00534 _t = _t->getNextSibling();
00535 }
00536
_retTree = _t;
00537
return l ;
00538 }
00539
00540 void JavaStoreWalker::objBlock(RefJavaAST _t,
00541
ClassDom klass
00542 ) {
00543
RefJavaAST objBlock_AST_in = _t;
00544
#line 221 "java.store.g"
00545
FunctionDom meth;
VariableDom attr;
00546
#line 547 "JavaStoreWalker.cpp"
00547
00548
try {
00549
RefJavaAST __t38 = _t;
00550
RefJavaAST tmp17_AST_in = _t;
00551 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),OBJBLOCK);
00552 _t = _t->getFirstChild();
00553 {
00554
for (;;) {
00555
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00556 _t = ASTNULL;
00557
switch ( _t->getType()) {
00558
case CTOR_DEF:
00559 {
00560 meth=
ctorDef(_t);
00561 _t =
_retTree;
00562
#line 223 "java.store.g"
00563
00564 klass->addFunction( meth );
00565
00566
#line 567 "JavaStoreWalker.cpp"
00567
break;
00568 }
00569
case METHOD_DEF:
00570 {
00571 meth=
methodDef(_t);
00572 _t =
_retTree;
00573
#line 226 "java.store.g"
00574
00575 klass->addFunction( meth );
00576
00577
#line 578 "JavaStoreWalker.cpp"
00578
break;
00579 }
00580
case VARIABLE_DEF:
00581 {
00582 attr=
variableDef(_t);
00583 _t =
_retTree;
00584
#line 229 "java.store.g"
00585
00586 klass->addVariable( attr );
00587
00588
#line 589 "JavaStoreWalker.cpp"
00589
break;
00590 }
00591
case CLASS_DEF:
00592
case INTERFACE_DEF:
00593 {
00594
typeDefinition(_t);
00595 _t =
_retTree;
00596
break;
00597 }
00598
case STATIC_INIT:
00599 {
00600
RefJavaAST __t40 = _t;
00601
RefJavaAST tmp18_AST_in = _t;
00602 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STATIC_INIT);
00603 _t = _t->getFirstChild();
00604
slist(_t);
00605 _t =
_retTree;
00606 _t = __t40;
00607 _t = _t->getNextSibling();
00608
break;
00609 }
00610
case INSTANCE_INIT:
00611 {
00612
RefJavaAST __t41 = _t;
00613
RefJavaAST tmp19_AST_in = _t;
00614 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INSTANCE_INIT);
00615 _t = _t->getFirstChild();
00616
slist(_t);
00617 _t =
_retTree;
00618 _t = __t41;
00619 _t = _t->getNextSibling();
00620
break;
00621 }
00622
default:
00623 {
00624
goto _loop42;
00625 }
00626 }
00627 }
00628 _loop42:;
00629 }
00630 _t = __t38;
00631 _t = _t->getNextSibling();
00632 }
00633
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00634 reportError(ex);
00635
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00636 _t = _t->getNextSibling();
00637 }
00638
_retTree = _t;
00639 }
00640
00641 void JavaStoreWalker::interfaceBlock(RefJavaAST _t,
00642
ClassDom klass
00643 ) {
00644
RefJavaAST interfaceBlock_AST_in = _t;
00645
#line 210 "java.store.g"
00646
FunctionDom meth;
VariableDom attr;
00647
#line 648 "JavaStoreWalker.cpp"
00648
00649
try {
00650
RefJavaAST __t34 = _t;
00651
RefJavaAST tmp20_AST_in = _t;
00652 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),OBJBLOCK);
00653 _t = _t->getFirstChild();
00654 {
00655
for (;;) {
00656
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00657 _t = ASTNULL;
00658
switch ( _t->getType()) {
00659
case METHOD_DEF:
00660 {
00661 meth=
methodDecl(_t);
00662 _t =
_retTree;
00663
#line 212 "java.store.g"
00664
00665
00666
#line 667 "JavaStoreWalker.cpp"
00667
break;
00668 }
00669
case VARIABLE_DEF:
00670 {
00671 attr=
variableDef(_t);
00672 _t =
_retTree;
00673
#line 215 "java.store.g"
00674
00675
00676
#line 677 "JavaStoreWalker.cpp"
00677
break;
00678 }
00679
default:
00680 {
00681
goto _loop36;
00682 }
00683 }
00684 }
00685 _loop36:;
00686 }
00687 _t = __t34;
00688 _t = _t->getNextSibling();
00689 }
00690
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00691 reportError(ex);
00692
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00693 _t = _t->getNextSibling();
00694 }
00695
_retTree = _t;
00696 }
00697
00698 QString JavaStoreWalker::typeSpec(RefJavaAST _t) {
00699
#line 157 "java.store.g"
00700
QString tp ;
00701
#line 702 "JavaStoreWalker.cpp"
00702
RefJavaAST typeSpec_AST_in = _t;
00703
00704
try {
00705
RefJavaAST __t15 = _t;
00706
RefJavaAST tmp21_AST_in = _t;
00707 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TYPE);
00708 _t = _t->getFirstChild();
00709 tp=
typeSpecArray(_t);
00710 _t =
_retTree;
00711 _t = __t15;
00712 _t = _t->getNextSibling();
00713 }
00714
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00715 reportError(ex);
00716
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00717 _t = _t->getNextSibling();
00718 }
00719
_retTree = _t;
00720
return tp ;
00721 }
00722
00723 QString JavaStoreWalker::typeSpecArray(RefJavaAST _t) {
00724
#line 161 "java.store.g"
00725
QString tp ;
00726
#line 727 "JavaStoreWalker.cpp"
00727
RefJavaAST typeSpecArray_AST_in = _t;
00728
00729
try {
00730
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00731 _t = ASTNULL;
00732
switch ( _t->getType()) {
00733
case ARRAY_DECLARATOR:
00734 {
00735
RefJavaAST __t17 = _t;
00736
RefJavaAST tmp22_AST_in = _t;
00737 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARRAY_DECLARATOR);
00738 _t = _t->getFirstChild();
00739 tp=
typeSpecArray(_t);
00740 _t =
_retTree;
00741 _t = __t17;
00742 _t = _t->getNextSibling();
00743
#line 162 "java.store.g"
00744
tp +=
"[]";
00745
#line 746 "JavaStoreWalker.cpp"
00746
break;
00747 }
00748
case LITERAL_void:
00749
case LITERAL_boolean:
00750
case LITERAL_byte:
00751
case LITERAL_char:
00752
case LITERAL_short:
00753
case LITERAL_int:
00754
case LITERAL_float:
00755
case LITERAL_long:
00756
case LITERAL_double:
00757
case IDENT:
00758
case DOT:
00759 {
00760 tp=
type(_t);
00761 _t =
_retTree;
00762
break;
00763 }
00764
default:
00765 {
00766
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00767 }
00768 }
00769 }
00770
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00771 reportError(ex);
00772
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00773 _t = _t->getNextSibling();
00774 }
00775
_retTree = _t;
00776
return tp ;
00777 }
00778
00779 QString JavaStoreWalker::type(RefJavaAST _t) {
00780
#line 166 "java.store.g"
00781
QString tp ;
00782
#line 783 "JavaStoreWalker.cpp"
00783
RefJavaAST type_AST_in = _t;
00784
RefJavaAST b = static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00785
00786
try {
00787
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00788 _t = ASTNULL;
00789
switch ( _t->getType()) {
00790
case IDENT:
00791
case DOT:
00792 {
00793 tp=
identifier(_t);
00794 _t =
_retTree;
00795
break;
00796 }
00797
case LITERAL_void:
00798
case LITERAL_boolean:
00799
case LITERAL_byte:
00800
case LITERAL_char:
00801
case LITERAL_short:
00802
case LITERAL_int:
00803
case LITERAL_float:
00804
case LITERAL_long:
00805
case LITERAL_double:
00806 {
00807 b = (_t == ASTNULL) ? static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) : _t;
00808
builtInType(_t);
00809 _t =
_retTree;
00810
#line 168 "java.store.g"
00811
tp = b->getText().c_str();
00812
#line 813 "JavaStoreWalker.cpp"
00813
break;
00814 }
00815
default:
00816 {
00817
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00818 }
00819 }
00820 }
00821
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00822 reportError(ex);
00823
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00824 _t = _t->getNextSibling();
00825 }
00826
_retTree = _t;
00827
return tp ;
00828 }
00829
00830 void JavaStoreWalker::builtInType(RefJavaAST _t) {
00831
RefJavaAST builtInType_AST_in = _t;
00832
00833
try {
00834
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00835 _t = ASTNULL;
00836
switch ( _t->getType()) {
00837
case LITERAL_void:
00838 {
00839
RefJavaAST tmp23_AST_in = _t;
00840 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_void);
00841 _t = _t->getNextSibling();
00842
break;
00843 }
00844
case LITERAL_boolean:
00845 {
00846
RefJavaAST tmp24_AST_in = _t;
00847 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_boolean);
00848 _t = _t->getNextSibling();
00849
break;
00850 }
00851
case LITERAL_byte:
00852 {
00853
RefJavaAST tmp25_AST_in = _t;
00854 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_byte);
00855 _t = _t->getNextSibling();
00856
break;
00857 }
00858
case LITERAL_char:
00859 {
00860
RefJavaAST tmp26_AST_in = _t;
00861 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_char);
00862 _t = _t->getNextSibling();
00863
break;
00864 }
00865
case LITERAL_short:
00866 {
00867
RefJavaAST tmp27_AST_in = _t;
00868 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_short);
00869 _t = _t->getNextSibling();
00870
break;
00871 }
00872
case LITERAL_int:
00873 {
00874
RefJavaAST tmp28_AST_in = _t;
00875 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_int);
00876 _t = _t->getNextSibling();
00877
break;
00878 }
00879
case LITERAL_float:
00880 {
00881
RefJavaAST tmp29_AST_in = _t;
00882 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_float);
00883 _t = _t->getNextSibling();
00884
break;
00885 }
00886
case LITERAL_long:
00887 {
00888
RefJavaAST tmp30_AST_in = _t;
00889 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_long);
00890 _t = _t->getNextSibling();
00891
break;
00892 }
00893
case LITERAL_double:
00894 {
00895
RefJavaAST tmp31_AST_in = _t;
00896 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_double);
00897 _t = _t->getNextSibling();
00898
break;
00899 }
00900
default:
00901 {
00902
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00903 }
00904 }
00905 }
00906
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00907 reportError(ex);
00908
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00909 _t = _t->getNextSibling();
00910 }
00911
_retTree = _t;
00912 }
00913
00914 void JavaStoreWalker::modifier(RefJavaAST _t) {
00915
RefJavaAST modifier_AST_in = _t;
00916
00917
try {
00918
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00919 _t = ASTNULL;
00920
switch ( _t->getType()) {
00921
case LITERAL_private:
00922 {
00923
RefJavaAST tmp32_AST_in = _t;
00924 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_private);
00925 _t = _t->getNextSibling();
00926
break;
00927 }
00928
case LITERAL_public:
00929 {
00930
RefJavaAST tmp33_AST_in = _t;
00931 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_public);
00932 _t = _t->getNextSibling();
00933
break;
00934 }
00935
case LITERAL_protected:
00936 {
00937
RefJavaAST tmp34_AST_in = _t;
00938 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_protected);
00939 _t = _t->getNextSibling();
00940
break;
00941 }
00942
case LITERAL_static:
00943 {
00944
RefJavaAST tmp35_AST_in = _t;
00945 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_static);
00946 _t = _t->getNextSibling();
00947
break;
00948 }
00949
case LITERAL_transient:
00950 {
00951
RefJavaAST tmp36_AST_in = _t;
00952 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_transient);
00953 _t = _t->getNextSibling();
00954
break;
00955 }
00956
case FINAL:
00957 {
00958
RefJavaAST tmp37_AST_in = _t;
00959 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FINAL);
00960 _t = _t->getNextSibling();
00961
break;
00962 }
00963
case ABSTRACT:
00964 {
00965
RefJavaAST tmp38_AST_in = _t;
00966 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ABSTRACT);
00967 _t = _t->getNextSibling();
00968
break;
00969 }
00970
case LITERAL_native:
00971 {
00972
RefJavaAST tmp39_AST_in = _t;
00973 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_native);
00974 _t = _t->getNextSibling();
00975
break;
00976 }
00977
case LITERAL_threadsafe:
00978 {
00979
RefJavaAST tmp40_AST_in = _t;
00980 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_threadsafe);
00981 _t = _t->getNextSibling();
00982
break;
00983 }
00984
case LITERAL_synchronized:
00985 {
00986
RefJavaAST tmp41_AST_in = _t;
00987 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_synchronized);
00988 _t = _t->getNextSibling();
00989
break;
00990 }
00991
case LITERAL_const:
00992 {
00993
RefJavaAST tmp42_AST_in = _t;
00994 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_const);
00995 _t = _t->getNextSibling();
00996
break;
00997 }
00998
case LITERAL_volatile:
00999 {
01000
RefJavaAST tmp43_AST_in = _t;
01001 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_volatile);
01002 _t = _t->getNextSibling();
01003
break;
01004 }
01005
default:
01006 {
01007
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01008 }
01009 }
01010 }
01011
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01012 reportError(ex);
01013
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01014 _t = _t->getNextSibling();
01015 }
01016
_retTree = _t;
01017 }
01018
01019 FunctionDom JavaStoreWalker::methodDecl(RefJavaAST _t) {
01020
#line 257 "java.store.g"
01021
FunctionDom meth ;
01022
#line 1023 "JavaStoreWalker.cpp"
01023
RefJavaAST methodDecl_AST_in = _t;
01024
#line 257 "java.store.g"
01025
01026
QStringList m;
01027
QString tp;
01028 meth =
m_model->
create<
FunctionModel>();
01029 meth->setFileName(
m_file->name() );
01030
01031
#line 1032 "JavaStoreWalker.cpp"
01032
01033
try {
01034
RefJavaAST __t46 = _t;
01035
RefJavaAST tmp44_AST_in = _t;
01036 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),METHOD_DEF);
01037 _t = _t->getFirstChild();
01038 m=
modifiers(_t);
01039 _t =
_retTree;
01040 tp=
typeSpec(_t);
01041 _t = _retTree;
01042
methodHead(_t,meth);
01043 _t = _retTree;
01044 _t = __t46;
01045 _t = _t->getNextSibling();
01046
#line 264 "java.store.g"
01047
01048 meth->setResultType( tp );
01049
if( m.contains(
"public") )
01050 meth->setAccess( CodeModelItem::Public );
01051
else if( m.contains(
"protected") )
01052 meth->setAccess( CodeModelItem::Protected );
01053
else
01054 meth->setAccess( CodeModelItem::Private );
01055
01056
#line 1057 "JavaStoreWalker.cpp"
01057
}
01058
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01059 reportError(ex);
01060
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01061 _t = _t->getNextSibling();
01062 }
01063
_retTree = _t;
01064
return meth ;
01065 }
01066
01067 VariableDom JavaStoreWalker::variableDef(RefJavaAST _t) {
01068
#line 293 "java.store.g"
01069
VariableDom attr ;
01070
#line 1071 "JavaStoreWalker.cpp"
01071
RefJavaAST variableDef_AST_in = _t;
01072
#line 293 "java.store.g"
01073
01074
QStringList m;
01075
QString tp;
01076 attr =
m_model->
create<
VariableModel>();
01077 attr->setFileName(
m_file->name() );
01078
01079
#line 1080 "JavaStoreWalker.cpp"
01080
01081
try {
01082
RefJavaAST __t51 = _t;
01083
RefJavaAST tmp45_AST_in = _t;
01084 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VARIABLE_DEF);
01085 _t = _t->getFirstChild();
01086 m=
modifiers(_t);
01087 _t =
_retTree;
01088 tp=
typeSpec(_t);
01089 _t = _retTree;
01090
variableDeclarator(_t,attr);
01091 _t = _retTree;
01092
varInitializer(_t);
01093 _t = _retTree;
01094 _t = __t51;
01095 _t = _t->getNextSibling();
01096
#line 300 "java.store.g"
01097
01098 attr->setType( tp );
01099
if( m.contains(
"public") )
01100 attr->setAccess( CodeModelItem::Public );
01101
else if( m.contains(
"protected") )
01102 attr->setAccess( CodeModelItem::Protected );
01103
else
01104 attr->setAccess( CodeModelItem::Private );
01105
01106 attr->setStatic( m.contains(
"static") );
01107
01108
#line 1109 "JavaStoreWalker.cpp"
01109
}
01110
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01111 reportError(ex);
01112
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01113 _t = _t->getNextSibling();
01114 }
01115
_retTree = _t;
01116
return attr ;
01117 }
01118
01119 FunctionDom JavaStoreWalker::ctorDef(RefJavaAST _t) {
01120
#line 239 "java.store.g"
01121
FunctionDom meth ;
01122
#line 1123 "JavaStoreWalker.cpp"
01123
RefJavaAST ctorDef_AST_in = _t;
01124
#line 239 "java.store.g"
01125
01126
QStringList m;
01127 meth =
m_model->
create<
FunctionModel>();
01128 meth->setFileName(
m_file->name() );
01129
01130
#line 1131 "JavaStoreWalker.cpp"
01131
01132
try {
01133
RefJavaAST __t44 = _t;
01134
RefJavaAST tmp46_AST_in = _t;
01135 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CTOR_DEF);
01136 _t = _t->getFirstChild();
01137 m=
modifiers(_t);
01138 _t =
_retTree;
01139
methodHead(_t,meth);
01140 _t = _retTree;
01141
slist(_t);
01142 _t = _retTree;
01143 _t = __t44;
01144 _t = _t->getNextSibling();
01145
#line 247 "java.store.g"
01146
01147
if( m.contains(
"public") )
01148 meth->setAccess( CodeModelItem::Public );
01149
else if( m.contains(
"protected") )
01150 meth->setAccess( CodeModelItem::Protected );
01151
else
01152 meth->setAccess( CodeModelItem::Private );
01153
01154
#line 1155 "JavaStoreWalker.cpp"
01155
}
01156
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01157 reportError(ex);
01158
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01159 _t = _t->getNextSibling();
01160 }
01161
_retTree = _t;
01162
return meth ;
01163 }
01164
01165 FunctionDom JavaStoreWalker::methodDef(RefJavaAST _t) {
01166
#line 275 "java.store.g"
01167
FunctionDom meth ;
01168
#line 1169 "JavaStoreWalker.cpp"
01169
RefJavaAST methodDef_AST_in = _t;
01170
#line 275 "java.store.g"
01171
01172
QStringList m;
01173
QString tp;
01174 meth =
m_model->
create<
FunctionModel>();
01175 meth->setFileName(
m_file->name() );
01176
01177
#line 1178 "JavaStoreWalker.cpp"
01178
01179
try {
01180
RefJavaAST __t48 = _t;
01181
RefJavaAST tmp47_AST_in = _t;
01182 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),METHOD_DEF);
01183 _t = _t->getFirstChild();
01184 m=
modifiers(_t);
01185 _t =
_retTree;
01186 tp=
typeSpec(_t);
01187 _t = _retTree;
01188
methodHead(_t,meth);
01189 _t = _retTree;
01190 {
01191
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01192 _t = ASTNULL;
01193
switch ( _t->getType()) {
01194
case SLIST:
01195 {
01196
slist(_t);
01197 _t = _retTree;
01198
break;
01199 }
01200
case 3:
01201 {
01202
break;
01203 }
01204
default:
01205 {
01206
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01207 }
01208 }
01209 }
01210 _t = __t48;
01211 _t = _t->getNextSibling();
01212
#line 282 "java.store.g"
01213
01214 meth->setResultType( tp );
01215
if( m.contains(
"public") )
01216 meth->setAccess( CodeModelItem::Public );
01217
else if( m.contains(
"protected") )
01218 meth->setAccess( CodeModelItem::Protected );
01219
else
01220 meth->setAccess( CodeModelItem::Private );
01221
01222
#line 1223 "JavaStoreWalker.cpp"
01223
}
01224
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01225 reportError(ex);
01226
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01227 _t = _t->getNextSibling();
01228 }
01229
_retTree = _t;
01230
return meth ;
01231 }
01232
01233 void JavaStoreWalker::slist(RefJavaAST _t) {
01234
RefJavaAST slist_AST_in = _t;
01235
01236
try {
01237
RefJavaAST __t79 = _t;
01238
RefJavaAST tmp48_AST_in = _t;
01239 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SLIST);
01240 _t = _t->getFirstChild();
01241 {
01242
for (;;) {
01243
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01244 _t = ASTNULL;
01245
if ((
_tokenSet_1.member(_t->getType()))) {
01246
stat(_t);
01247 _t =
_retTree;
01248 }
01249
else {
01250
goto _loop81;
01251 }
01252
01253 }
01254 _loop81:;
01255 }
01256 _t = __t79;
01257 _t = _t->getNextSibling();
01258 }
01259
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01260 reportError(ex);
01261
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01262 _t = _t->getNextSibling();
01263 }
01264
_retTree = _t;
01265 }
01266
01267 void JavaStoreWalker::methodHead(RefJavaAST _t,
01268
FunctionDom meth
01269 ) {
01270
RefJavaAST methodHead_AST_in = _t;
01271
#line 350 "java.store.g"
01272
ArgumentDom arg;
01273
#line 1274 "JavaStoreWalker.cpp"
01274
01275
try {
01276
RefJavaAST tmp49_AST_in = _t;
01277 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01278 _t = _t->getNextSibling();
01279
RefJavaAST __t65 = _t;
01280
RefJavaAST tmp50_AST_in = _t;
01281 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PARAMETERS);
01282 _t = _t->getFirstChild();
01283 {
01284
for (;;) {
01285
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01286 _t = ASTNULL;
01287
if ((_t->getType() == PARAMETER_DEF)) {
01288 arg=
parameterDef(_t);
01289 _t =
_retTree;
01290
#line 351 "java.store.g"
01291
meth->addArgument(arg);
01292
#line 1293 "JavaStoreWalker.cpp"
01293
}
01294
else {
01295
goto _loop67;
01296 }
01297
01298 }
01299 _loop67:;
01300 }
01301 _t = __t65;
01302 _t = _t->getNextSibling();
01303 {
01304
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01305 _t = ASTNULL;
01306
switch ( _t->getType()) {
01307
case LITERAL_throws:
01308 {
01309
throwsClause(_t);
01310 _t =
_retTree;
01311
break;
01312 }
01313
case 3:
01314
case SLIST:
01315 {
01316
break;
01317 }
01318
default:
01319 {
01320
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01321 }
01322 }
01323 }
01324
#line 352 "java.store.g"
01325
01326 meth->setName( tmp49_AST_in->getText().c_str() );
01327 meth->setScope(
m_currentScope );
01328 meth->setStartPosition( tmp49_AST_in->getLine(), tmp49_AST_in->getColumn() );
01329
01330
#line 1331 "JavaStoreWalker.cpp"
01331
}
01332
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01333 reportError(ex);
01334
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01335 _t = _t->getNextSibling();
01336 }
01337
_retTree = _t;
01338 }
01339
01340 void JavaStoreWalker::variableDeclarator(RefJavaAST _t,
01341
VariableDom attr
01342 ) {
01343
RefJavaAST variableDeclarator_AST_in = _t;
01344
01345
try {
01346
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01347 _t = ASTNULL;
01348
switch ( _t->getType()) {
01349
case IDENT:
01350 {
01351
RefJavaAST tmp51_AST_in = _t;
01352 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01353 _t = _t->getNextSibling();
01354
#line 329 "java.store.g"
01355
01356 attr->setName( tmp51_AST_in->getText().c_str() );
01357 attr->setStartPosition( tmp51_AST_in->getLine(), tmp51_AST_in->getColumn() );
01358
01359
#line 1360 "JavaStoreWalker.cpp"
01360
break;
01361 }
01362
case LBRACK:
01363 {
01364
RefJavaAST tmp52_AST_in = _t;
01365 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LBRACK);
01366 _t = _t->getNextSibling();
01367
variableDeclarator(_t,attr);
01368 _t =
_retTree;
01369
break;
01370 }
01371
default:
01372 {
01373
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01374 }
01375 }
01376 }
01377
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01378 reportError(ex);
01379
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01380 _t = _t->getNextSibling();
01381 }
01382
_retTree = _t;
01383 }
01384
01385 void JavaStoreWalker::varInitializer(RefJavaAST _t) {
01386
RefJavaAST varInitializer_AST_in = _t;
01387
01388
try {
01389
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01390 _t = ASTNULL;
01391
switch ( _t->getType()) {
01392
case ASSIGN:
01393 {
01394
RefJavaAST __t58 = _t;
01395
RefJavaAST tmp53_AST_in = _t;
01396 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ASSIGN);
01397 _t = _t->getFirstChild();
01398
initializer(_t);
01399 _t =
_retTree;
01400 _t = __t58;
01401 _t = _t->getNextSibling();
01402
break;
01403 }
01404
case 3:
01405 {
01406
break;
01407 }
01408
default:
01409 {
01410
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01411 }
01412 }
01413 }
01414
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01415 reportError(ex);
01416
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01417 _t = _t->getNextSibling();
01418 }
01419
_retTree = _t;
01420 }
01421
01422 ArgumentDom JavaStoreWalker::parameterDef(RefJavaAST _t) {
01423
#line 313 "java.store.g"
01424
ArgumentDom arg ;
01425
#line 1426 "JavaStoreWalker.cpp"
01426
RefJavaAST parameterDef_AST_in = _t;
01427
#line 313 "java.store.g"
01428
01429
QString tp;
01430 arg =
m_model->
create<
ArgumentModel>();
01431
01432
#line 1433 "JavaStoreWalker.cpp"
01433
01434
try {
01435
RefJavaAST __t53 = _t;
01436
RefJavaAST tmp54_AST_in = _t;
01437 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PARAMETER_DEF);
01438 _t = _t->getFirstChild();
01439
modifiers(_t);
01440 _t =
_retTree;
01441 tp=
typeSpec(_t);
01442 _t = _retTree;
01443
RefJavaAST tmp55_AST_in = _t;
01444 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01445 _t = _t->getNextSibling();
01446 _t = __t53;
01447 _t = _t->getNextSibling();
01448
#line 318 "java.store.g"
01449
01450 arg->setType( tp );
01451 arg->setName( tmp55_AST_in->getText().c_str() );
01452
01453
#line 1454 "JavaStoreWalker.cpp"
01454
}
01455
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01456 reportError(ex);
01457
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01458 _t = _t->getNextSibling();
01459 }
01460
_retTree = _t;
01461
return arg ;
01462 }
01463
01464 void JavaStoreWalker::objectinitializer(RefJavaAST _t) {
01465
RefJavaAST objectinitializer_AST_in = _t;
01466
01467
try {
01468
RefJavaAST __t55 = _t;
01469
RefJavaAST tmp56_AST_in = _t;
01470 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INSTANCE_INIT);
01471 _t = _t->getFirstChild();
01472
slist(_t);
01473 _t =
_retTree;
01474 _t = __t55;
01475 _t = _t->getNextSibling();
01476 }
01477
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01478 reportError(ex);
01479
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01480 _t = _t->getNextSibling();
01481 }
01482
_retTree = _t;
01483 }
01484
01485 void JavaStoreWalker::initializer(RefJavaAST _t) {
01486
RefJavaAST initializer_AST_in = _t;
01487
01488
try {
01489
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01490 _t = ASTNULL;
01491
switch ( _t->getType()) {
01492
case EXPR:
01493 {
01494
expression(_t);
01495 _t =
_retTree;
01496
break;
01497 }
01498
case ARRAY_INIT:
01499 {
01500
arrayInitializer(_t);
01501 _t =
_retTree;
01502
break;
01503 }
01504
default:
01505 {
01506
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01507 }
01508 }
01509 }
01510
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01511 reportError(ex);
01512
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01513 _t = _t->getNextSibling();
01514 }
01515
_retTree = _t;
01516 }
01517
01518 void JavaStoreWalker::expression(RefJavaAST _t) {
01519
RefJavaAST expression_AST_in = _t;
01520
01521
try {
01522
RefJavaAST __t124 = _t;
01523
RefJavaAST tmp57_AST_in = _t;
01524 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EXPR);
01525 _t = _t->getFirstChild();
01526
expr(_t);
01527 _t =
_retTree;
01528 _t = __t124;
01529 _t = _t->getNextSibling();
01530 }
01531
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01532 reportError(ex);
01533
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01534 _t = _t->getNextSibling();
01535 }
01536
_retTree = _t;
01537 }
01538
01539 void JavaStoreWalker::arrayInitializer(RefJavaAST _t) {
01540
RefJavaAST arrayInitializer_AST_in = _t;
01541
01542
try {
01543
RefJavaAST __t61 = _t;
01544
RefJavaAST tmp58_AST_in = _t;
01545 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARRAY_INIT);
01546 _t = _t->getFirstChild();
01547 {
01548
for (;;) {
01549
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01550 _t = ASTNULL;
01551
if ((_t->getType() == EXPR || _t->getType() == ARRAY_INIT)) {
01552
initializer(_t);
01553 _t =
_retTree;
01554 }
01555
else {
01556
goto _loop63;
01557 }
01558
01559 }
01560 _loop63:;
01561 }
01562 _t = __t61;
01563 _t = _t->getNextSibling();
01564 }
01565
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01566 reportError(ex);
01567
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01568 _t = _t->getNextSibling();
01569 }
01570
_retTree = _t;
01571 }
01572
01573 void JavaStoreWalker::throwsClause(RefJavaAST _t) {
01574
RefJavaAST throwsClause_AST_in = _t;
01575
01576
try {
01577
RefJavaAST __t70 = _t;
01578
RefJavaAST tmp59_AST_in = _t;
01579 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_throws);
01580 _t = _t->getFirstChild();
01581 {
01582
for (;;) {
01583
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01584 _t = ASTNULL;
01585
if ((_t->getType() == IDENT || _t->getType() == DOT)) {
01586
identifier(_t);
01587 _t =
_retTree;
01588 }
01589
else {
01590
goto _loop72;
01591 }
01592
01593 }
01594 _loop72:;
01595 }
01596 _t = __t70;
01597 _t = _t->getNextSibling();
01598 }
01599
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01600 reportError(ex);
01601
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01602 _t = _t->getNextSibling();
01603 }
01604
_retTree = _t;
01605 }
01606
01607 void JavaStoreWalker::stat(RefJavaAST _t) {
01608
RefJavaAST stat_AST_in = _t;
01609
01610
try {
01611
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01612 _t = ASTNULL;
01613
switch ( _t->getType()) {
01614
case CLASS_DEF:
01615
case INTERFACE_DEF:
01616 {
01617
typeDefinition(_t);
01618 _t =
_retTree;
01619
break;
01620 }
01621
case VARIABLE_DEF:
01622 {
01623
variableDef(_t);
01624 _t =
_retTree;
01625
break;
01626 }
01627
case EXPR:
01628 {
01629
expression(_t);
01630 _t =
_retTree;
01631
break;
01632 }
01633
case LABELED_STAT:
01634 {
01635
RefJavaAST __t83 = _t;
01636
RefJavaAST tmp60_AST_in = _t;
01637 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LABELED_STAT);
01638 _t = _t->getFirstChild();
01639
RefJavaAST tmp61_AST_in = _t;
01640 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01641 _t = _t->getNextSibling();
01642
stat(_t);
01643 _t =
_retTree;
01644 _t = __t83;
01645 _t = _t->getNextSibling();
01646
break;
01647 }
01648
case LITERAL_if:
01649 {
01650
RefJavaAST __t84 = _t;
01651
RefJavaAST tmp62_AST_in = _t;
01652 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_if);
01653 _t = _t->getFirstChild();
01654
expression(_t);
01655 _t =
_retTree;
01656
stat(_t);
01657 _t = _retTree;
01658 {
01659
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01660 _t = ASTNULL;
01661
switch ( _t->getType()) {
01662
case SLIST:
01663
case VARIABLE_DEF:
01664
case CLASS_DEF:
01665
case INTERFACE_DEF:
01666
case LABELED_STAT:
01667
case EXPR:
01668
case EMPTY_STAT:
01669
case LITERAL_synchronized:
01670
case LITERAL_if:
01671
case LITERAL_for:
01672
case LITERAL_while:
01673
case LITERAL_do:
01674
case LITERAL_break:
01675
case LITERAL_continue:
01676
case LITERAL_return:
01677
case LITERAL_switch:
01678
case LITERAL_throw:
01679
case LITERAL_try:
01680 {
01681
stat(_t);
01682 _t = _retTree;
01683
break;
01684 }
01685
case 3:
01686 {
01687
break;
01688 }
01689
default:
01690 {
01691
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01692 }
01693 }
01694 }
01695 _t = __t84;
01696 _t = _t->getNextSibling();
01697
break;
01698 }
01699
case LITERAL_for:
01700 {
01701
RefJavaAST __t86 = _t;
01702
RefJavaAST tmp63_AST_in = _t;
01703 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_for);
01704 _t = _t->getFirstChild();
01705
RefJavaAST __t87 = _t;
01706
RefJavaAST tmp64_AST_in = _t;
01707 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FOR_INIT);
01708 _t = _t->getFirstChild();
01709 {
01710
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01711 _t = ASTNULL;
01712
switch ( _t->getType()) {
01713
case VARIABLE_DEF:
01714 {
01715
variableDef(_t);
01716 _t =
_retTree;
01717
break;
01718 }
01719
case ELIST:
01720 {
01721
elist(_t);
01722 _t =
_retTree;
01723
break;
01724 }
01725
case 3:
01726 {
01727
break;
01728 }
01729
default:
01730 {
01731
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01732 }
01733 }
01734 }
01735 _t = __t87;
01736 _t = _t->getNextSibling();
01737
RefJavaAST __t89 = _t;
01738
RefJavaAST tmp65_AST_in = _t;
01739 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FOR_CONDITION);
01740 _t = _t->getFirstChild();
01741 {
01742
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01743 _t = ASTNULL;
01744
switch ( _t->getType()) {
01745
case EXPR:
01746 {
01747
expression(_t);
01748 _t =
_retTree;
01749
break;
01750 }
01751
case 3:
01752 {
01753
break;
01754 }
01755
default:
01756 {
01757
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01758 }
01759 }
01760 }
01761 _t = __t89;
01762 _t = _t->getNextSibling();
01763
RefJavaAST __t91 = _t;
01764
RefJavaAST tmp66_AST_in = _t;
01765 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FOR_ITERATOR);
01766 _t = _t->getFirstChild();
01767 {
01768
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01769 _t = ASTNULL;
01770
switch ( _t->getType()) {
01771
case ELIST:
01772 {
01773
elist(_t);
01774 _t =
_retTree;
01775
break;
01776 }
01777
case 3:
01778 {
01779
break;
01780 }
01781
default:
01782 {
01783
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01784 }
01785 }
01786 }
01787 _t = __t91;
01788 _t = _t->getNextSibling();
01789
stat(_t);
01790 _t =
_retTree;
01791 _t = __t86;
01792 _t = _t->getNextSibling();
01793
break;
01794 }
01795
case LITERAL_while:
01796 {
01797
RefJavaAST __t93 = _t;
01798
RefJavaAST tmp67_AST_in = _t;
01799 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_while);
01800 _t = _t->getFirstChild();
01801
expression(_t);
01802 _t =
_retTree;
01803
stat(_t);
01804 _t = _retTree;
01805 _t = __t93;
01806 _t = _t->getNextSibling();
01807
break;
01808 }
01809
case LITERAL_do:
01810 {
01811
RefJavaAST __t94 = _t;
01812
RefJavaAST tmp68_AST_in = _t;
01813 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_do);
01814 _t = _t->getFirstChild();
01815
stat(_t);
01816 _t =
_retTree;
01817
expression(_t);
01818 _t = _retTree;
01819 _t = __t94;
01820 _t = _t->getNextSibling();
01821
break;
01822 }
01823
case LITERAL_break:
01824 {
01825
RefJavaAST __t95 = _t;
01826
RefJavaAST tmp69_AST_in = _t;
01827 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_break);
01828 _t = _t->getFirstChild();
01829 {
01830
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01831 _t = ASTNULL;
01832
switch ( _t->getType()) {
01833
case IDENT:
01834 {
01835
RefJavaAST tmp70_AST_in = _t;
01836 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01837 _t = _t->getNextSibling();
01838
break;
01839 }
01840
case 3:
01841 {
01842
break;
01843 }
01844
default:
01845 {
01846
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01847 }
01848 }
01849 }
01850 _t = __t95;
01851 _t = _t->getNextSibling();
01852
break;
01853 }
01854
case LITERAL_continue:
01855 {
01856
RefJavaAST __t97 = _t;
01857
RefJavaAST tmp71_AST_in = _t;
01858 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_continue);
01859 _t = _t->getFirstChild();
01860 {
01861
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01862 _t = ASTNULL;
01863
switch ( _t->getType()) {
01864
case IDENT:
01865 {
01866
RefJavaAST tmp72_AST_in = _t;
01867 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01868 _t = _t->getNextSibling();
01869
break;
01870 }
01871
case 3:
01872 {
01873
break;
01874 }
01875
default:
01876 {
01877
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01878 }
01879 }
01880 }
01881 _t = __t97;
01882 _t = _t->getNextSibling();
01883
break;
01884 }
01885
case LITERAL_return:
01886 {
01887
RefJavaAST __t99 = _t;
01888
RefJavaAST tmp73_AST_in = _t;
01889 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_return);
01890 _t = _t->getFirstChild();
01891 {
01892
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01893 _t = ASTNULL;
01894
switch ( _t->getType()) {
01895
case EXPR:
01896 {
01897
expression(_t);
01898 _t =
_retTree;
01899
break;
01900 }
01901
case 3:
01902 {
01903
break;
01904 }
01905
default:
01906 {
01907
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01908 }
01909 }
01910 }
01911 _t = __t99;
01912 _t = _t->getNextSibling();
01913
break;
01914 }
01915
case LITERAL_switch:
01916 {
01917
RefJavaAST __t101 = _t;
01918
RefJavaAST tmp74_AST_in = _t;
01919 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_switch);
01920 _t = _t->getFirstChild();
01921
expression(_t);
01922 _t =
_retTree;
01923 {
01924
for (;;) {
01925
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01926 _t = ASTNULL;
01927
if ((_t->getType() == CASE_GROUP)) {
01928
caseGroup(_t);
01929 _t = _retTree;
01930 }
01931
else {
01932
goto _loop103;
01933 }
01934
01935 }
01936 _loop103:;
01937 }
01938 _t = __t101;
01939 _t = _t->getNextSibling();
01940
break;
01941 }
01942
case LITERAL_throw:
01943 {
01944
RefJavaAST __t104 = _t;
01945
RefJavaAST tmp75_AST_in = _t;
01946 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_throw);
01947 _t = _t->getFirstChild();
01948
expression(_t);
01949 _t =
_retTree;
01950 _t = __t104;
01951 _t = _t->getNextSibling();
01952
break;
01953 }
01954
case LITERAL_synchronized:
01955 {
01956
RefJavaAST __t105 = _t;
01957
RefJavaAST tmp76_AST_in = _t;
01958 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_synchronized);
01959 _t = _t->getFirstChild();
01960
expression(_t);
01961 _t =
_retTree;
01962
stat(_t);
01963 _t = _retTree;
01964 _t = __t105;
01965 _t = _t->getNextSibling();
01966
break;
01967 }
01968
case LITERAL_try:
01969 {
01970
tryBlock(_t);
01971 _t =
_retTree;
01972
break;
01973 }
01974
case SLIST:
01975 {
01976
slist(_t);
01977 _t =
_retTree;
01978
break;
01979 }
01980
case EMPTY_STAT:
01981 {
01982
RefJavaAST tmp77_AST_in = _t;
01983 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EMPTY_STAT);
01984 _t = _t->getNextSibling();
01985
break;
01986 }
01987
default:
01988 {
01989
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01990 }
01991 }
01992 }
01993
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01994 reportError(ex);
01995
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01996 _t = _t->getNextSibling();
01997 }
01998
_retTree = _t;
01999 }
02000
02001 void JavaStoreWalker::elist(RefJavaAST _t) {
02002
RefJavaAST elist_AST_in = _t;
02003
02004
try {
02005
RefJavaAST __t120 = _t;
02006
RefJavaAST tmp78_AST_in = _t;
02007 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ELIST);
02008 _t = _t->getFirstChild();
02009 {
02010
for (;;) {
02011
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02012 _t = ASTNULL;
02013
if ((_t->getType() == EXPR)) {
02014
expression(_t);
02015 _t =
_retTree;
02016 }
02017
else {
02018
goto _loop122;
02019 }
02020
02021 }
02022 _loop122:;
02023 }
02024 _t = __t120;
02025 _t = _t->getNextSibling();
02026 }
02027
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02028 reportError(ex);
02029
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02030 _t = _t->getNextSibling();
02031 }
02032
_retTree = _t;
02033 }
02034
02035 void JavaStoreWalker::caseGroup(RefJavaAST _t) {
02036
RefJavaAST caseGroup_AST_in = _t;
02037
02038
try {
02039
RefJavaAST __t107 = _t;
02040
RefJavaAST tmp79_AST_in = _t;
02041 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CASE_GROUP);
02042 _t = _t->getFirstChild();
02043 {
02044
int _cnt110=0;
02045
for (;;) {
02046
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02047 _t = ASTNULL;
02048
switch ( _t->getType()) {
02049
case LITERAL_case:
02050 {
02051
RefJavaAST __t109 = _t;
02052
RefJavaAST tmp80_AST_in = _t;
02053 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_case);
02054 _t = _t->getFirstChild();
02055
expression(_t);
02056 _t =
_retTree;
02057 _t = __t109;
02058 _t = _t->getNextSibling();
02059
break;
02060 }
02061
case LITERAL_default:
02062 {
02063
RefJavaAST tmp81_AST_in = _t;
02064 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_default);
02065 _t = _t->getNextSibling();
02066
break;
02067 }
02068
default:
02069 {
02070
if ( _cnt110>=1 ) {
goto _loop110; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
02071 }
02072 }
02073 _cnt110++;
02074 }
02075 _loop110:;
02076 }
02077
slist(_t);
02078 _t =
_retTree;
02079 _t = __t107;
02080 _t = _t->getNextSibling();
02081 }
02082
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02083 reportError(ex);
02084
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02085 _t = _t->getNextSibling();
02086 }
02087
_retTree = _t;
02088 }
02089
02090 void JavaStoreWalker::tryBlock(RefJavaAST _t) {
02091
RefJavaAST tryBlock_AST_in = _t;
02092
02093
try {
02094
RefJavaAST __t112 = _t;
02095
RefJavaAST tmp82_AST_in = _t;
02096 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_try);
02097 _t = _t->getFirstChild();
02098
slist(_t);
02099 _t =
_retTree;
02100 {
02101
for (;;) {
02102
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02103 _t = ASTNULL;
02104
if ((_t->getType() == LITERAL_catch)) {
02105
handler(_t);
02106 _t = _retTree;
02107 }
02108
else {
02109
goto _loop114;
02110 }
02111
02112 }
02113 _loop114:;
02114 }
02115 {
02116
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02117 _t = ASTNULL;
02118
switch ( _t->getType()) {
02119
case LITERAL_finally:
02120 {
02121
RefJavaAST __t116 = _t;
02122
RefJavaAST tmp83_AST_in = _t;
02123 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_finally);
02124 _t = _t->getFirstChild();
02125
slist(_t);
02126 _t = _retTree;
02127 _t = __t116;
02128 _t = _t->getNextSibling();
02129
break;
02130 }
02131
case 3:
02132 {
02133
break;
02134 }
02135
default:
02136 {
02137
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02138 }
02139 }
02140 }
02141 _t = __t112;
02142 _t = _t->getNextSibling();
02143 }
02144
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02145 reportError(ex);
02146
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02147 _t = _t->getNextSibling();
02148 }
02149
_retTree = _t;
02150 }
02151
02152 void JavaStoreWalker::handler(RefJavaAST _t) {
02153
RefJavaAST handler_AST_in = _t;
02154
02155
try {
02156
RefJavaAST __t118 = _t;
02157
RefJavaAST tmp84_AST_in = _t;
02158 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_catch);
02159 _t = _t->getFirstChild();
02160
parameterDef(_t);
02161 _t =
_retTree;
02162
slist(_t);
02163 _t = _retTree;
02164 _t = __t118;
02165 _t = _t->getNextSibling();
02166 }
02167
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02168 reportError(ex);
02169
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02170 _t = _t->getNextSibling();
02171 }
02172
_retTree = _t;
02173 }
02174
02175 void JavaStoreWalker::expr(RefJavaAST _t) {
02176
RefJavaAST expr_AST_in = _t;
02177
02178
try {
02179
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02180 _t = ASTNULL;
02181
switch ( _t->getType()) {
02182
case QUESTION:
02183 {
02184
RefJavaAST __t126 = _t;
02185
RefJavaAST tmp85_AST_in = _t;
02186 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),QUESTION);
02187 _t = _t->getFirstChild();
02188
expr(_t);
02189 _t =
_retTree;
02190
expr(_t);
02191 _t = _retTree;
02192
expr(_t);
02193 _t = _retTree;
02194 _t = __t126;
02195 _t = _t->getNextSibling();
02196
break;
02197 }
02198
case ASSIGN:
02199 {
02200
RefJavaAST __t127 = _t;
02201
RefJavaAST tmp86_AST_in = _t;
02202 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ASSIGN);
02203 _t = _t->getFirstChild();
02204
expr(_t);
02205 _t =
_retTree;
02206
expr(_t);
02207 _t = _retTree;
02208 _t = __t127;
02209 _t = _t->getNextSibling();
02210
break;
02211 }
02212
case PLUS_ASSIGN:
02213 {
02214
RefJavaAST __t128 = _t;
02215
RefJavaAST tmp87_AST_in = _t;
02216 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PLUS_ASSIGN);
02217 _t = _t->getFirstChild();
02218
expr(_t);
02219 _t =
_retTree;
02220
expr(_t);
02221 _t = _retTree;
02222 _t = __t128;
02223 _t = _t->getNextSibling();
02224
break;
02225 }
02226
case MINUS_ASSIGN:
02227 {
02228
RefJavaAST __t129 = _t;
02229
RefJavaAST tmp88_AST_in = _t;
02230 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MINUS_ASSIGN);
02231 _t = _t->getFirstChild();
02232
expr(_t);
02233 _t =
_retTree;
02234
expr(_t);
02235 _t = _retTree;
02236 _t = __t129;
02237 _t = _t->getNextSibling();
02238
break;
02239 }
02240
case STAR_ASSIGN:
02241 {
02242
RefJavaAST __t130 = _t;
02243
RefJavaAST tmp89_AST_in = _t;
02244 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STAR_ASSIGN);
02245 _t = _t->getFirstChild();
02246
expr(_t);
02247 _t =
_retTree;
02248
expr(_t);
02249 _t = _retTree;
02250 _t = __t130;
02251 _t = _t->getNextSibling();
02252
break;
02253 }
02254
case DIV_ASSIGN:
02255 {
02256
RefJavaAST __t131 = _t;
02257
RefJavaAST tmp90_AST_in = _t;
02258 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DIV_ASSIGN);
02259 _t = _t->getFirstChild();
02260
expr(_t);
02261 _t =
_retTree;
02262
expr(_t);
02263 _t = _retTree;
02264 _t = __t131;
02265 _t = _t->getNextSibling();
02266
break;
02267 }
02268
case MOD_ASSIGN:
02269 {
02270
RefJavaAST __t132 = _t;
02271
RefJavaAST tmp91_AST_in = _t;
02272 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MOD_ASSIGN);
02273 _t = _t->getFirstChild();
02274
expr(_t);
02275 _t =
_retTree;
02276
expr(_t);
02277 _t = _retTree;
02278 _t = __t132;
02279 _t = _t->getNextSibling();
02280
break;
02281 }
02282
case SR_ASSIGN:
02283 {
02284
RefJavaAST __t133 = _t;
02285
RefJavaAST tmp92_AST_in = _t;
02286 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SR_ASSIGN);
02287 _t = _t->getFirstChild();
02288
expr(_t);
02289 _t =
_retTree;
02290
expr(_t);
02291 _t = _retTree;
02292 _t = __t133;
02293 _t = _t->getNextSibling();
02294
break;
02295 }
02296
case BSR_ASSIGN:
02297 {
02298
RefJavaAST __t134 = _t;
02299
RefJavaAST tmp93_AST_in = _t;
02300 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BSR_ASSIGN);
02301 _t = _t->getFirstChild();
02302
expr(_t);
02303 _t =
_retTree;
02304
expr(_t);
02305 _t = _retTree;
02306 _t = __t134;
02307 _t = _t->getNextSibling();
02308
break;
02309 }
02310
case SL_ASSIGN:
02311 {
02312
RefJavaAST __t135 = _t;
02313
RefJavaAST tmp94_AST_in = _t;
02314 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SL_ASSIGN);
02315 _t = _t->getFirstChild();
02316
expr(_t);
02317 _t =
_retTree;
02318
expr(_t);
02319 _t = _retTree;
02320 _t = __t135;
02321 _t = _t->getNextSibling();
02322
break;
02323 }
02324
case BAND_ASSIGN:
02325 {
02326
RefJavaAST __t136 = _t;
02327
RefJavaAST tmp95_AST_in = _t;
02328 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BAND_ASSIGN);
02329 _t = _t->getFirstChild();
02330
expr(_t);
02331 _t =
_retTree;
02332
expr(_t);
02333 _t = _retTree;
02334 _t = __t136;
02335 _t = _t->getNextSibling();
02336
break;
02337 }
02338
case BXOR_ASSIGN:
02339 {
02340
RefJavaAST __t137 = _t;
02341
RefJavaAST tmp96_AST_in = _t;
02342 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BXOR_ASSIGN);
02343 _t = _t->getFirstChild();
02344
expr(_t);
02345 _t =
_retTree;
02346
expr(_t);
02347 _t = _retTree;
02348 _t = __t137;
02349 _t = _t->getNextSibling();
02350
break;
02351 }
02352
case BOR_ASSIGN:
02353 {
02354
RefJavaAST __t138 = _t;
02355
RefJavaAST tmp97_AST_in = _t;
02356 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BOR_ASSIGN);
02357 _t = _t->getFirstChild();
02358
expr(_t);
02359 _t =
_retTree;
02360
expr(_t);
02361 _t = _retTree;
02362 _t = __t138;
02363 _t = _t->getNextSibling();
02364
break;
02365 }
02366
case LOR:
02367 {
02368
RefJavaAST __t139 = _t;
02369
RefJavaAST tmp98_AST_in = _t;
02370 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LOR);
02371 _t = _t->getFirstChild();
02372
expr(_t);
02373 _t =
_retTree;
02374
expr(_t);
02375 _t = _retTree;
02376 _t = __t139;
02377 _t = _t->getNextSibling();
02378
break;
02379 }
02380
case LAND:
02381 {
02382
RefJavaAST __t140 = _t;
02383
RefJavaAST tmp99_AST_in = _t;
02384 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LAND);
02385 _t = _t->getFirstChild();
02386
expr(_t);
02387 _t =
_retTree;
02388
expr(_t);
02389 _t = _retTree;
02390 _t = __t140;
02391 _t = _t->getNextSibling();
02392
break;
02393 }
02394
case BOR:
02395 {
02396
RefJavaAST __t141 = _t;
02397
RefJavaAST tmp100_AST_in = _t;
02398 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BOR);
02399 _t = _t->getFirstChild();
02400
expr(_t);
02401 _t =
_retTree;
02402
expr(_t);
02403 _t = _retTree;
02404 _t = __t141;
02405 _t = _t->getNextSibling();
02406
break;
02407 }
02408
case BXOR:
02409 {
02410
RefJavaAST __t142 = _t;
02411
RefJavaAST tmp101_AST_in = _t;
02412 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BXOR);
02413 _t = _t->getFirstChild();
02414
expr(_t);
02415 _t =
_retTree;
02416
expr(_t);
02417 _t = _retTree;
02418 _t = __t142;
02419 _t = _t->getNextSibling();
02420
break;
02421 }
02422
case BAND:
02423 {
02424
RefJavaAST __t143 = _t;
02425
RefJavaAST tmp102_AST_in = _t;
02426 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BAND);
02427 _t = _t->getFirstChild();
02428
expr(_t);
02429 _t =
_retTree;
02430
expr(_t);
02431 _t = _retTree;
02432 _t = __t143;
02433 _t = _t->getNextSibling();
02434
break;
02435 }
02436
case NOT_EQUAL:
02437 {
02438
RefJavaAST __t144 = _t;
02439
RefJavaAST tmp103_AST_in = _t;
02440 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NOT_EQUAL);
02441 _t = _t->getFirstChild();
02442
expr(_t);
02443 _t =
_retTree;
02444
expr(_t);
02445 _t = _retTree;
02446 _t = __t144;
02447 _t = _t->getNextSibling();
02448
break;
02449 }
02450
case EQUAL:
02451 {
02452
RefJavaAST __t145 = _t;
02453
RefJavaAST tmp104_AST_in = _t;
02454 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EQUAL);
02455 _t = _t->getFirstChild();
02456
expr(_t);
02457 _t =
_retTree;
02458
expr(_t);
02459 _t = _retTree;
02460 _t = __t145;
02461 _t = _t->getNextSibling();
02462
break;
02463 }
02464
case LT_:
02465 {
02466
RefJavaAST __t146 = _t;
02467
RefJavaAST tmp105_AST_in = _t;
02468 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LT_);
02469 _t = _t->getFirstChild();
02470
expr(_t);
02471 _t =
_retTree;
02472
expr(_t);
02473 _t = _retTree;
02474 _t = __t146;
02475 _t = _t->getNextSibling();
02476
break;
02477 }
02478
case GT:
02479 {
02480
RefJavaAST __t147 = _t;
02481
RefJavaAST tmp106_AST_in = _t;
02482 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),GT);
02483 _t = _t->getFirstChild();
02484
expr(_t);
02485 _t =
_retTree;
02486
expr(_t);
02487 _t = _retTree;
02488 _t = __t147;
02489 _t = _t->getNextSibling();
02490
break;
02491 }
02492
case LE:
02493 {
02494
RefJavaAST __t148 = _t;
02495
RefJavaAST tmp107_AST_in = _t;
02496 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LE);
02497 _t = _t->getFirstChild();
02498
expr(_t);
02499 _t =
_retTree;
02500
expr(_t);
02501 _t = _retTree;
02502 _t = __t148;
02503 _t = _t->getNextSibling();
02504
break;
02505 }
02506
case GE:
02507 {
02508
RefJavaAST __t149 = _t;
02509
RefJavaAST tmp108_AST_in = _t;
02510 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),GE);
02511 _t = _t->getFirstChild();
02512
expr(_t);
02513 _t =
_retTree;
02514
expr(_t);
02515 _t = _retTree;
02516 _t = __t149;
02517 _t = _t->getNextSibling();
02518
break;
02519 }
02520
case SL:
02521 {
02522
RefJavaAST __t150 = _t;
02523
RefJavaAST tmp109_AST_in = _t;
02524 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SL);
02525 _t = _t->getFirstChild();
02526
expr(_t);
02527 _t =
_retTree;
02528
expr(_t);
02529 _t = _retTree;
02530 _t = __t150;
02531 _t = _t->getNextSibling();
02532
break;
02533 }
02534
case SR:
02535 {
02536
RefJavaAST __t151 = _t;
02537
RefJavaAST tmp110_AST_in = _t;
02538 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SR);
02539 _t = _t->getFirstChild();
02540
expr(_t);
02541 _t =
_retTree;
02542
expr(_t);
02543 _t = _retTree;
02544 _t = __t151;
02545 _t = _t->getNextSibling();
02546
break;
02547 }
02548
case BSR:
02549 {
02550
RefJavaAST __t152 = _t;
02551
RefJavaAST tmp111_AST_in = _t;
02552 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BSR);
02553 _t = _t->getFirstChild();
02554
expr(_t);
02555 _t =
_retTree;
02556
expr(_t);
02557 _t = _retTree;
02558 _t = __t152;
02559 _t = _t->getNextSibling();
02560
break;
02561 }
02562
case PLUS:
02563 {
02564
RefJavaAST __t153 = _t;
02565
RefJavaAST tmp112_AST_in = _t;
02566 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PLUS);
02567 _t = _t->getFirstChild();
02568
expr(_t);
02569 _t =
_retTree;
02570
expr(_t);
02571 _t = _retTree;
02572 _t = __t153;
02573 _t = _t->getNextSibling();
02574
break;
02575 }
02576
case MINUS:
02577 {
02578
RefJavaAST __t154 = _t;
02579
RefJavaAST tmp113_AST_in = _t;
02580 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MINUS);
02581 _t = _t->getFirstChild();
02582
expr(_t);
02583 _t =
_retTree;
02584
expr(_t);
02585 _t = _retTree;
02586 _t = __t154;
02587 _t = _t->getNextSibling();
02588
break;
02589 }
02590
case DIV:
02591 {
02592
RefJavaAST __t155 = _t;
02593
RefJavaAST tmp114_AST_in = _t;
02594 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DIV);
02595 _t = _t->getFirstChild();
02596
expr(_t);
02597 _t =
_retTree;
02598
expr(_t);
02599 _t = _retTree;
02600 _t = __t155;
02601 _t = _t->getNextSibling();
02602
break;
02603 }
02604
case MOD:
02605 {
02606
RefJavaAST __t156 = _t;
02607
RefJavaAST tmp115_AST_in = _t;
02608 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MOD);
02609 _t = _t->getFirstChild();
02610
expr(_t);
02611 _t =
_retTree;
02612
expr(_t);
02613 _t = _retTree;
02614 _t = __t156;
02615 _t = _t->getNextSibling();
02616
break;
02617 }
02618
case STAR:
02619 {
02620
RefJavaAST __t157 = _t;
02621
RefJavaAST tmp116_AST_in = _t;
02622 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STAR);
02623 _t = _t->getFirstChild();
02624
expr(_t);
02625 _t =
_retTree;
02626
expr(_t);
02627 _t = _retTree;
02628 _t = __t157;
02629 _t = _t->getNextSibling();
02630
break;
02631 }
02632
case INC:
02633 {
02634
RefJavaAST __t158 = _t;
02635
RefJavaAST tmp117_AST_in = _t;
02636 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INC);
02637 _t = _t->getFirstChild();
02638
expr(_t);
02639 _t =
_retTree;
02640 _t = __t158;
02641 _t = _t->getNextSibling();
02642
break;
02643 }
02644
case DEC:
02645 {
02646
RefJavaAST __t159 = _t;
02647
RefJavaAST tmp118_AST_in = _t;
02648 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DEC);
02649 _t = _t->getFirstChild();
02650
expr(_t);
02651 _t =
_retTree;
02652 _t = __t159;
02653 _t = _t->getNextSibling();
02654
break;
02655 }
02656
case POST_INC:
02657 {
02658
RefJavaAST __t160 = _t;
02659
RefJavaAST tmp119_AST_in = _t;
02660 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),POST_INC);
02661 _t = _t->getFirstChild();
02662
expr(_t);
02663 _t =
_retTree;
02664 _t = __t160;
02665 _t = _t->getNextSibling();
02666
break;
02667 }
02668
case POST_DEC:
02669 {
02670
RefJavaAST __t161 = _t;
02671
RefJavaAST tmp120_AST_in = _t;
02672 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),POST_DEC);
02673 _t = _t->getFirstChild();
02674
expr(_t);
02675 _t =
_retTree;
02676 _t = __t161;
02677 _t = _t->getNextSibling();
02678
break;
02679 }
02680
case BNOT:
02681 {
02682
RefJavaAST __t162 = _t;
02683
RefJavaAST tmp121_AST_in = _t;
02684 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BNOT);
02685 _t = _t->getFirstChild();
02686
expr(_t);
02687 _t =
_retTree;
02688 _t = __t162;
02689 _t = _t->getNextSibling();
02690
break;
02691 }
02692
case LNOT:
02693 {
02694
RefJavaAST __t163 = _t;
02695
RefJavaAST tmp122_AST_in = _t;
02696 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LNOT);
02697 _t = _t->getFirstChild();
02698
expr(_t);
02699 _t =
_retTree;
02700 _t = __t163;
02701 _t = _t->getNextSibling();
02702
break;
02703 }
02704
case LITERAL_instanceof:
02705 {
02706
RefJavaAST __t164 = _t;
02707
RefJavaAST tmp123_AST_in = _t;
02708 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_instanceof);
02709 _t = _t->getFirstChild();
02710
expr(_t);
02711 _t =
_retTree;
02712
expr(_t);
02713 _t = _retTree;
02714 _t = __t164;
02715 _t = _t->getNextSibling();
02716
break;
02717 }
02718
case UNARY_MINUS:
02719 {
02720
RefJavaAST __t165 = _t;
02721
RefJavaAST tmp124_AST_in = _t;
02722 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),UNARY_MINUS);
02723 _t = _t->getFirstChild();
02724
expr(_t);
02725 _t =
_retTree;
02726 _t = __t165;
02727 _t = _t->getNextSibling();
02728
break;
02729 }
02730
case UNARY_PLUS:
02731 {
02732
RefJavaAST __t166 = _t;
02733
RefJavaAST tmp125_AST_in = _t;
02734 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),UNARY_PLUS);
02735 _t = _t->getFirstChild();
02736
expr(_t);
02737 _t =
_retTree;
02738 _t = __t166;
02739 _t = _t->getNextSibling();
02740
break;
02741 }
02742
case TYPE:
02743
case TYPECAST:
02744
case INDEX_OP:
02745
case METHOD_CALL:
02746
case IDENT:
02747
case DOT:
02748
case LITERAL_this:
02749
case LITERAL_super:
02750
case LITERAL_true:
02751
case LITERAL_false:
02752
case LITERAL_null:
02753
case LITERAL_new:
02754
case NUM_INT:
02755
case CHAR_LITERAL:
02756
case STRING_LITERAL:
02757
case NUM_FLOAT:
02758 {
02759
primaryExpression(_t);
02760 _t =
_retTree;
02761
break;
02762 }
02763
default:
02764 {
02765
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02766 }
02767 }
02768 }
02769
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02770 reportError(ex);
02771
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02772 _t = _t->getNextSibling();
02773 }
02774
_retTree = _t;
02775 }
02776
02777 void JavaStoreWalker::primaryExpression(RefJavaAST _t) {
02778
RefJavaAST primaryExpression_AST_in = _t;
02779
02780
try {
02781
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02782 _t = ASTNULL;
02783
switch ( _t->getType()) {
02784
case IDENT:
02785 {
02786
RefJavaAST tmp126_AST_in = _t;
02787 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02788 _t = _t->getNextSibling();
02789
break;
02790 }
02791
case DOT:
02792 {
02793
RefJavaAST __t168 = _t;
02794
RefJavaAST tmp127_AST_in = _t;
02795 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOT);
02796 _t = _t->getFirstChild();
02797 {
02798
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02799 _t = ASTNULL;
02800
switch ( _t->getType()) {
02801
case TYPE:
02802
case TYPECAST:
02803
case INDEX_OP:
02804
case POST_INC:
02805
case POST_DEC:
02806
case METHOD_CALL:
02807
case UNARY_MINUS:
02808
case UNARY_PLUS:
02809
case IDENT:
02810
case DOT:
02811
case STAR:
02812
case LITERAL_this:
02813
case LITERAL_super:
02814
case ASSIGN:
02815
case PLUS_ASSIGN:
02816
case MINUS_ASSIGN:
02817
case STAR_ASSIGN:
02818
case DIV_ASSIGN:
02819
case MOD_ASSIGN:
02820
case SR_ASSIGN:
02821
case BSR_ASSIGN:
02822
case SL_ASSIGN:
02823
case BAND_ASSIGN:
02824
case BXOR_ASSIGN:
02825
case BOR_ASSIGN:
02826
case QUESTION:
02827
case LOR:
02828
case LAND:
02829
case BOR:
02830
case BXOR:
02831
case BAND:
02832
case NOT_EQUAL:
02833
case EQUAL:
02834
case LT_:
02835
case GT:
02836
case LE:
02837
case GE:
02838
case LITERAL_instanceof:
02839
case SL:
02840
case SR:
02841
case BSR:
02842
case PLUS:
02843
case MINUS:
02844
case DIV:
02845
case MOD:
02846
case INC:
02847
case DEC:
02848
case BNOT:
02849
case LNOT:
02850
case LITERAL_true:
02851
case LITERAL_false:
02852
case LITERAL_null:
02853
case LITERAL_new:
02854
case NUM_INT:
02855
case CHAR_LITERAL:
02856
case STRING_LITERAL:
02857
case NUM_FLOAT:
02858 {
02859
expr(_t);
02860 _t =
_retTree;
02861 {
02862
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02863 _t = ASTNULL;
02864
switch ( _t->getType()) {
02865
case IDENT:
02866 {
02867
RefJavaAST tmp128_AST_in = _t;
02868 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02869 _t = _t->getNextSibling();
02870
break;
02871 }
02872
case INDEX_OP:
02873 {
02874
arrayIndex(_t);
02875 _t = _retTree;
02876
break;
02877 }
02878
case LITERAL_this:
02879 {
02880
RefJavaAST tmp129_AST_in = _t;
02881 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_this);
02882 _t = _t->getNextSibling();
02883
break;
02884 }
02885
case LITERAL_class:
02886 {
02887
RefJavaAST tmp130_AST_in = _t;
02888 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_class);
02889 _t = _t->getNextSibling();
02890
break;
02891 }
02892
case LITERAL_new:
02893 {
02894
RefJavaAST __t171 = _t;
02895
RefJavaAST tmp131_AST_in = _t;
02896 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_new);
02897 _t = _t->getFirstChild();
02898
RefJavaAST tmp132_AST_in = _t;
02899 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02900 _t = _t->getNextSibling();
02901
elist(_t);
02902 _t = _retTree;
02903 _t = __t171;
02904 _t = _t->getNextSibling();
02905
break;
02906 }
02907
default:
02908 {
02909
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02910 }
02911 }
02912 }
02913
break;
02914 }
02915
case ARRAY_DECLARATOR:
02916 {
02917
RefJavaAST __t172 = _t;
02918
RefJavaAST tmp133_AST_in = _t;
02919 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARRAY_DECLARATOR);
02920 _t = _t->getFirstChild();
02921
type(_t);
02922 _t =
_retTree;
02923 _t = __t172;
02924 _t = _t->getNextSibling();
02925
break;
02926 }
02927
case LITERAL_void:
02928
case LITERAL_boolean:
02929
case LITERAL_byte:
02930
case LITERAL_char:
02931
case LITERAL_short:
02932
case LITERAL_int:
02933
case LITERAL_float:
02934
case LITERAL_long:
02935
case LITERAL_double:
02936 {
02937
builtInType(_t);
02938 _t =
_retTree;
02939 {
02940
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02941 _t = ASTNULL;
02942
switch ( _t->getType()) {
02943
case LITERAL_class:
02944 {
02945
RefJavaAST tmp134_AST_in = _t;
02946 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_class);
02947 _t = _t->getNextSibling();
02948
break;
02949 }
02950
case 3:
02951 {
02952
break;
02953 }
02954
default:
02955 {
02956
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02957 }
02958 }
02959 }
02960
break;
02961 }
02962
default:
02963 {
02964
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02965 }
02966 }
02967 }
02968 _t = __t168;
02969 _t = _t->getNextSibling();
02970
break;
02971 }
02972
case INDEX_OP:
02973 {
02974
arrayIndex(_t);
02975 _t =
_retTree;
02976
break;
02977 }
02978
case METHOD_CALL:
02979 {
02980
RefJavaAST __t174 = _t;
02981
RefJavaAST tmp135_AST_in = _t;
02982 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),METHOD_CALL);
02983 _t = _t->getFirstChild();
02984
primaryExpression(_t);
02985 _t =
_retTree;
02986
elist(_t);
02987 _t = _retTree;
02988 _t = __t174;
02989 _t = _t->getNextSibling();
02990
break;
02991 }
02992
case TYPECAST:
02993 {
02994
RefJavaAST __t175 = _t;
02995
RefJavaAST tmp136_AST_in = _t;
02996 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TYPECAST);
02997 _t = _t->getFirstChild();
02998
typeSpec(_t);
02999 _t =
_retTree;
03000
expr(_t);
03001 _t = _retTree;
03002 _t = __t175;
03003 _t = _t->getNextSibling();
03004
break;
03005 }
03006
case LITERAL_new:
03007 {
03008
newExpression(_t);
03009 _t =
_retTree;
03010
break;
03011 }
03012
case NUM_INT:
03013
case CHAR_LITERAL:
03014
case STRING_LITERAL:
03015
case NUM_FLOAT:
03016 {
03017
constant(_t);
03018 _t =
_retTree;
03019
break;
03020 }
03021
case LITERAL_super:
03022 {
03023
RefJavaAST tmp137_AST_in = _t;
03024 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_super);
03025 _t = _t->getNextSibling();
03026
break;
03027 }
03028
case LITERAL_true:
03029 {
03030
RefJavaAST tmp138_AST_in = _t;
03031 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_true);
03032 _t = _t->getNextSibling();
03033
break;
03034 }
03035
case LITERAL_false:
03036 {
03037
RefJavaAST tmp139_AST_in = _t;
03038 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_false);
03039 _t = _t->getNextSibling();
03040
break;
03041 }
03042
case LITERAL_this:
03043 {
03044
RefJavaAST tmp140_AST_in = _t;
03045 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_this);
03046 _t = _t->getNextSibling();
03047
break;
03048 }
03049
case LITERAL_null:
03050 {
03051
RefJavaAST tmp141_AST_in = _t;
03052 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_null);
03053 _t = _t->getNextSibling();
03054
break;
03055 }
03056
case TYPE:
03057 {
03058
typeSpec(_t);
03059 _t =
_retTree;
03060
break;
03061 }
03062
default:
03063 {
03064
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03065 }
03066 }
03067 }
03068
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03069 reportError(ex);
03070
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03071 _t = _t->getNextSibling();
03072 }
03073
_retTree = _t;
03074 }
03075
03076 void JavaStoreWalker::arrayIndex(RefJavaAST _t) {
03077
RefJavaAST arrayIndex_AST_in = _t;
03078
03079
try {
03080
RefJavaAST __t177 = _t;
03081
RefJavaAST tmp142_AST_in = _t;
03082 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INDEX_OP);
03083 _t = _t->getFirstChild();
03084
primaryExpression(_t);
03085 _t =
_retTree;
03086
expression(_t);
03087 _t = _retTree;
03088 _t = __t177;
03089 _t = _t->getNextSibling();
03090 }
03091
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03092 reportError(ex);
03093
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03094 _t = _t->getNextSibling();
03095 }
03096
_retTree = _t;
03097 }
03098
03099 void JavaStoreWalker::newExpression(RefJavaAST _t) {
03100
RefJavaAST newExpression_AST_in = _t;
03101
03102
try {
03103
RefJavaAST __t180 = _t;
03104
RefJavaAST tmp143_AST_in = _t;
03105 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LITERAL_new);
03106 _t = _t->getFirstChild();
03107
type(_t);
03108 _t =
_retTree;
03109 {
03110
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03111 _t = ASTNULL;
03112
switch ( _t->getType()) {
03113
case ARRAY_DECLARATOR:
03114 {
03115
newArrayDeclarator(_t);
03116 _t = _retTree;
03117 {
03118
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03119 _t = ASTNULL;
03120
switch ( _t->getType()) {
03121
case ARRAY_INIT:
03122 {
03123
arrayInitializer(_t);
03124 _t = _retTree;
03125
break;
03126 }
03127
case 3:
03128 {
03129
break;
03130 }
03131
default:
03132 {
03133
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03134 }
03135 }
03136 }
03137
break;
03138 }
03139
case ELIST:
03140 {
03141
elist(_t);
03142 _t = _retTree;
03143
break;
03144 }
03145
default:
03146 {
03147
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03148 }
03149 }
03150 }
03151 _t = __t180;
03152 _t = _t->getNextSibling();
03153 }
03154
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03155 reportError(ex);
03156
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03157 _t = _t->getNextSibling();
03158 }
03159
_retTree = _t;
03160 }
03161
03162 void JavaStoreWalker::constant(RefJavaAST _t) {
03163
RefJavaAST constant_AST_in = _t;
03164
03165
try {
03166
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03167 _t = ASTNULL;
03168
switch ( _t->getType()) {
03169
case NUM_INT:
03170 {
03171
RefJavaAST tmp144_AST_in = _t;
03172 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
03173 _t = _t->getNextSibling();
03174
break;
03175 }
03176
case CHAR_LITERAL:
03177 {
03178
RefJavaAST tmp145_AST_in = _t;
03179 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CHAR_LITERAL);
03180 _t = _t->getNextSibling();
03181
break;
03182 }
03183
case STRING_LITERAL:
03184 {
03185
RefJavaAST tmp146_AST_in = _t;
03186 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STRING_LITERAL);
03187 _t = _t->getNextSibling();
03188
break;
03189 }
03190
case NUM_FLOAT:
03191 {
03192
RefJavaAST tmp147_AST_in = _t;
03193 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_FLOAT);
03194 _t = _t->getNextSibling();
03195
break;
03196 }
03197
default:
03198 {
03199
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03200 }
03201 }
03202 }
03203
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03204 reportError(ex);
03205
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03206 _t = _t->getNextSibling();
03207 }
03208
_retTree = _t;
03209 }
03210
03211 void JavaStoreWalker::newArrayDeclarator(RefJavaAST _t) {
03212
RefJavaAST newArrayDeclarator_AST_in = _t;
03213
03214
try {
03215
RefJavaAST __t184 = _t;
03216
RefJavaAST tmp148_AST_in = _t;
03217 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARRAY_DECLARATOR);
03218 _t = _t->getFirstChild();
03219 {
03220
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03221 _t = ASTNULL;
03222
switch ( _t->getType()) {
03223
case ARRAY_DECLARATOR:
03224 {
03225
newArrayDeclarator(_t);
03226 _t =
_retTree;
03227
break;
03228 }
03229
case 3:
03230
case EXPR:
03231 {
03232
break;
03233 }
03234
default:
03235 {
03236
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03237 }
03238 }
03239 }
03240 {
03241
if (_t == static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03242 _t = ASTNULL;
03243
switch ( _t->getType()) {
03244
case EXPR:
03245 {
03246
expression(_t);
03247 _t =
_retTree;
03248
break;
03249 }
03250
case 3:
03251 {
03252
break;
03253 }
03254
default:
03255 {
03256
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03257 }
03258 }
03259 }
03260 _t = __t184;
03261 _t = _t->getNextSibling();
03262 }
03263
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03264 reportError(ex);
03265
if ( _t != static_cast<RefJavaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03266 _t = _t->getNextSibling();
03267 }
03268
_retTree = _t;
03269 }
03270
03271 RefJavaAST JavaStoreWalker::getAST()
03272 {
03273
return returnAST;
03274 }
03275
03276 void JavaStoreWalker::initializeASTFactory(
ANTLR_USE_NAMESPACE(antlr)
ASTFactory& factory )
03277 {
03278 }
03279 const char*
JavaStoreWalker::tokenNames[] = {
03280
"<0>",
03281
"EOF",
03282
"<2>",
03283
"NULL_TREE_LOOKAHEAD",
03284
"BLOCK",
03285
"MODIFIERS",
03286
"OBJBLOCK",
03287
"SLIST",
03288
"CTOR_DEF",
03289
"METHOD_DEF",
03290
"VARIABLE_DEF",
03291
"INSTANCE_INIT",
03292
"STATIC_INIT",
03293
"TYPE",
03294
"CLASS_DEF",
03295
"INTERFACE_DEF",
03296
"PACKAGE_DEF",
03297
"ARRAY_DECLARATOR",
03298
"EXTENDS_CLAUSE",
03299
"IMPLEMENTS_CLAUSE",
03300
"PARAMETERS",
03301
"PARAMETER_DEF",
03302
"LABELED_STAT",
03303
"TYPECAST",
03304
"INDEX_OP",
03305
"POST_INC",
03306
"POST_DEC",
03307
"METHOD_CALL",
03308
"EXPR",
03309
"ARRAY_INIT",
03310
"IMPORT",
03311
"UNARY_MINUS",
03312
"UNARY_PLUS",
03313
"CASE_GROUP",
03314
"ELIST",
03315
"FOR_INIT",
03316
"FOR_CONDITION",
03317
"FOR_ITERATOR",
03318
"EMPTY_STAT",
03319
"\"final\"",
03320
"\"abstract\"",
03321
"\"strictfp\"",
03322
"SUPER_CTOR_CALL",
03323
"CTOR_CALL",
03324
"\"package\"",
03325
"SEMI",
03326
"\"import\"",
03327
"LBRACK",
03328
"RBRACK",
03329
"\"void\"",
03330
"\"boolean\"",
03331
"\"byte\"",
03332
"\"char\"",
03333
"\"short\"",
03334
"\"int\"",
03335
"\"float\"",
03336
"\"long\"",
03337
"\"double\"",
03338
"IDENT",
03339
"DOT",
03340
"STAR",
03341
"\"private\"",
03342
"\"public\"",
03343
"\"protected\"",
03344
"\"static\"",
03345
"\"transient\"",
03346
"\"native\"",
03347
"\"threadsafe\"",
03348
"\"synchronized\"",
03349
"\"volatile\"",
03350
"\"class\"",
03351
"\"extends\"",
03352
"\"interface\"",
03353
"LCURLY",
03354
"RCURLY",
03355
"COMMA",
03356
"\"implements\"",
03357
"LPAREN",
03358
"RPAREN",
03359
"\"this\"",
03360
"\"super\"",
03361
"ASSIGN",
03362
"\"throws\"",
03363
"COLON",
03364
"\"if\"",
03365
"\"else\"",
03366
"\"for\"",
03367
"\"while\"",
03368
"\"do\"",
03369
"\"break\"",
03370
"\"continue\"",
03371
"\"return\"",
03372
"\"switch\"",
03373
"\"throw\"",
03374
"\"case\"",
03375
"\"default\"",
03376
"\"try\"",
03377
"\"finally\"",
03378
"\"catch\"",
03379
"PLUS_ASSIGN",
03380
"MINUS_ASSIGN",
03381
"STAR_ASSIGN",
03382
"DIV_ASSIGN",
03383
"MOD_ASSIGN",
03384
"SR_ASSIGN",
03385
"BSR_ASSIGN",
03386
"SL_ASSIGN",
03387
"BAND_ASSIGN",
03388
"BXOR_ASSIGN",
03389
"BOR_ASSIGN",
03390
"QUESTION",
03391
"LOR",
03392
"LAND",
03393
"BOR",
03394
"BXOR",
03395
"BAND",
03396
"NOT_EQUAL",
03397
"EQUAL",
03398
"LT_",
03399
"GT",
03400
"LE",
03401
"GE",
03402
"\"instanceof\"",
03403
"SL",
03404
"SR",
03405
"BSR",
03406
"PLUS",
03407
"MINUS",
03408
"DIV",
03409
"MOD",
03410
"INC",
03411
"DEC",
03412
"BNOT",
03413
"LNOT",
03414
"\"true\"",
03415
"\"false\"",
03416
"\"null\"",
03417
"\"new\"",
03418
"NUM_INT",
03419
"CHAR_LITERAL",
03420
"STRING_LITERAL",
03421
"NUM_FLOAT",
03422
"NUM_LONG",
03423
"NUM_DOUBLE",
03424
"WS",
03425
"SL_COMMENT",
03426
"ML_COMMENT",
03427
"ESC",
03428
"HEX_DIGIT",
03429
"VOCAB",
03430
"EXPONENT",
03431
"FLOAT_SUFFIX",
03432
"\"const\"",
03433 0
03434 };
03435
03436 const unsigned long JavaStoreWalker::_tokenSet_0_data_[] = { 0UL, 3758096768UL, 63UL, 0UL, 16777216UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03437
03438
03439
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaStoreWalker::_tokenSet_0(_tokenSet_0_data_,12);
03440 const
unsigned long JavaStoreWalker::_tokenSet_1_data_[] = { 272680064UL, 64UL, 1070596112UL, 1UL, 0UL, 0UL, 0UL, 0UL };
03441
03442
03443
03444
const ANTLR_USE_NAMESPACE(antlr)
BitSet JavaStoreWalker::_tokenSet_1(_tokenSet_1_data_,8);
03445
03446