KDevelop API Documentation

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.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Feb 22 09:22:31 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003