KDevelop API Documentation

JavaRecognizer.cpp

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