KDevelop API Documentation

languages/java/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.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Oct 6 17:39:03 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003