KDevelop API Documentation

languages/java/JavaStoreWalker.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "java.store.g" -> "JavaStoreWalker.cpp"$ */ 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 { // for error handling 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 // "final" "abstract" "private" "public" "protected" "static" "transient" 03438 // "native" "threadsafe" "synchronized" "volatile" "const" 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 // SLIST VARIABLE_DEF CLASS_DEF INTERFACE_DEF LABELED_STAT EXPR EMPTY_STAT 03442 // "synchronized" "if" "for" "while" "do" "break" "continue" "return" "switch" 03443 // "throw" "try" 03444 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaStoreWalker::_tokenSet_1(_tokenSet_1_data_,8); 03445 03446
KDE Logo
This file is part of the documentation for KDevelop Version 3.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Oct 6 17:39:03 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003