GPLIB++: CLevanisoConfParser.cpp Source File

00001 /* $ANTLR 2.7.6 (20070220): "CLevanisoConf.g" -> "CLevanisoConfParser.cpp"$ */
00002 #include "CLevanisoConfParser.hpp"
00003 #include <antlr/NoViableAltException.hpp>
00004 #include <antlr/SemanticException.hpp>
00005 #include <antlr/ASTFactory.hpp>
00006 #line 1 "CLevanisoConf.g"
00007 #line 8 "CLevanisoConfParser.cpp"
00008 CLevanisoConfParser::CLevanisoConfParser(antlr::TokenBuffer& tokenBuf, int k)
00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }
00012 
00013 CLevanisoConfParser::CLevanisoConfParser(antlr::TokenBuffer& tokenBuf)
00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }
00017 
00018 CLevanisoConfParser::CLevanisoConfParser(antlr::TokenStream& lexer, int k)
00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }
00022 
00023 CLevanisoConfParser::CLevanisoConfParser(antlr::TokenStream& lexer)
00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }
00027 
00028 CLevanisoConfParser::CLevanisoConfParser(const antlr::ParserSharedInputState& state)
00029 : antlr::LLkParser(state,10)
00030 {
00031 }
00032 
00033 void CLevanisoConfParser::configentry() {
00034         
00035         try {      // for error handling
00036                 {
00037                 switch ( LA(1)) {
00038                 case MAXITERT:
00039                 {
00040                         match(MAXITERT);
00041                         match(EQUAL);
00042                         maxiter=numvalue();
00043                         break;
00044                 }
00045                 case MODET:
00046                 {
00047                         match(MODET);
00048                         match(EQUAL);
00049                         mode=stringvalue();
00050                         break;
00051                 }
00052                 case MTFITT:
00053                 {
00054                         match(MTFITT);
00055                         match(EQUAL);
00056                         mtfit=stringvalue();
00057                         break;
00058                 }
00059                 case MTINPUTDATAT:
00060                 {
00061                         match(MTINPUTDATAT);
00062                         match(EQUAL);
00063                         mtinputdata=stringvalue();
00064                         break;
00065                 }
00066                 case PTENSORDATAT:
00067                 {
00068                         match(PTENSORDATAT);
00069                         match(EQUAL);
00070                         ptensordata=stringvalue();
00071                         break;
00072                 }
00073                 case TENSORERRORT:
00074                 {
00075                         match(TENSORERRORT);
00076                         match(EQUAL);
00077                         tensorerror=numvalue();
00078                         break;
00079                 }
00080                 case PHASEERRORT:
00081                 {
00082                         match(PHASEERRORT);
00083                         match(EQUAL);
00084                         phaseerror=numvalue();
00085                         break;
00086                 }
00087                 case RESERRORT:
00088                 {
00089                         match(RESERRORT);
00090                         match(EQUAL);
00091                         reserror=numvalue();
00092                         break;
00093                 }
00094                 case MINREST:
00095                 {
00096                         match(MINREST);
00097                         match(EQUAL);
00098                         if ( inputState->guessing==0 ) {
00099 #line 56 "CLevanisoConf.g"
00100                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00101 #line 102 "CLevanisoConfParser.cpp"
00102                         }
00103                         { // ( ... )+
00104                         int _cnt40=0;
00105                         for (;;) {
00106                                 if ((LA(1) == NUMBER)) {
00107                                         dtemp=numvalue();
00108                                         if ( inputState->guessing==0 ) {
00109 #line 57 "CLevanisoConf.g"
00110                                                 if (i < minres.size()) {minres.at(i) = dtemp;} else{minres.push_back(dtemp);}++i;
00111 #line 112 "CLevanisoConfParser.cpp"
00112                                         }
00113                                 }
00114                                 else {
00115                                         if ( _cnt40>=1 ) { goto _loop40; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00116                                 }
00117                                 
00118                                 _cnt40++;
00119                         }
00120                         _loop40:;
00121                         }  // ( ... )+
00122                         break;
00123                 }
00124                 case MAXREST:
00125                 {
00126                         match(MAXREST);
00127                         match(EQUAL);
00128                         if ( inputState->guessing==0 ) {
00129 #line 58 "CLevanisoConf.g"
00130                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00131 #line 132 "CLevanisoConfParser.cpp"
00132                         }
00133                         { // ( ... )+
00134                         int _cnt46=0;
00135                         for (;;) {
00136                                 if ((LA(1) == NUMBER)) {
00137                                         dtemp=numvalue();
00138                                         if ( inputState->guessing==0 ) {
00139 #line 59 "CLevanisoConf.g"
00140                                                 if (i < maxres.size()) {maxres.at(i) = dtemp;} else{maxres.push_back(dtemp);}++i;
00141 #line 142 "CLevanisoConfParser.cpp"
00142                                         }
00143                                 }
00144                                 else {
00145                                         if ( _cnt46>=1 ) { goto _loop46; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00146                                 }
00147                                 
00148                                 _cnt46++;
00149                         }
00150                         _loop46:;
00151                         }  // ( ... )+
00152                         break;
00153                 }
00154                 case STARTREST:
00155                 {
00156                         match(STARTREST);
00157                         match(EQUAL);
00158                         if ( inputState->guessing==0 ) {
00159 #line 60 "CLevanisoConf.g"
00160                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00161 #line 162 "CLevanisoConfParser.cpp"
00162                         }
00163                         { // ( ... )+
00164                         int _cnt52=0;
00165                         for (;;) {
00166                                 if ((LA(1) == NUMBER)) {
00167                                         dtemp=numvalue();
00168                                         if ( inputState->guessing==0 ) {
00169 #line 61 "CLevanisoConf.g"
00170                                                 if (i < startres.size()) {startres.at(i) = dtemp;} else{startres.push_back(dtemp);}++i;
00171 #line 172 "CLevanisoConfParser.cpp"
00172                                         }
00173                                 }
00174                                 else {
00175                                         if ( _cnt52>=1 ) { goto _loop52; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00176                                 }
00177                                 
00178                                 _cnt52++;
00179                         }
00180                         _loop52:;
00181                         }  // ( ... )+
00182                         break;
00183                 }
00184                 case MINTHICKT:
00185                 {
00186                         match(MINTHICKT);
00187                         match(EQUAL);
00188                         if ( inputState->guessing==0 ) {
00189 #line 62 "CLevanisoConf.g"
00190                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00191 #line 192 "CLevanisoConfParser.cpp"
00192                         }
00193                         { // ( ... )+
00194                         int _cnt58=0;
00195                         for (;;) {
00196                                 if ((LA(1) == NUMBER)) {
00197                                         dtemp=numvalue();
00198                                         if ( inputState->guessing==0 ) {
00199 #line 63 "CLevanisoConf.g"
00200                                                 if (i < minthick.size()) {minthick.at(i) = dtemp;} else{minthick.push_back(dtemp);}++i;
00201 #line 202 "CLevanisoConfParser.cpp"
00202                                         }
00203                                 }
00204                                 else {
00205                                         if ( _cnt58>=1 ) { goto _loop58; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00206                                 }
00207                                 
00208                                 _cnt58++;
00209                         }
00210                         _loop58:;
00211                         }  // ( ... )+
00212                         break;
00213                 }
00214                 case MAXTHICKT:
00215                 {
00216                         match(MAXTHICKT);
00217                         match(EQUAL);
00218                         if ( inputState->guessing==0 ) {
00219 #line 64 "CLevanisoConf.g"
00220                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00221 #line 222 "CLevanisoConfParser.cpp"
00222                         }
00223                         { // ( ... )+
00224                         int _cnt64=0;
00225                         for (;;) {
00226                                 if ((LA(1) == NUMBER)) {
00227                                         dtemp=numvalue();
00228                                         if ( inputState->guessing==0 ) {
00229 #line 65 "CLevanisoConf.g"
00230                                                 if (i < maxthick.size()) {maxthick.at(i) = dtemp;} else{maxthick.push_back(dtemp);}++i;
00231 #line 232 "CLevanisoConfParser.cpp"
00232                                         }
00233                                 }
00234                                 else {
00235                                         if ( _cnt64>=1 ) { goto _loop64; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00236                                 }
00237                                 
00238                                 _cnt64++;
00239                         }
00240                         _loop64:;
00241                         }  // ( ... )+
00242                         break;
00243                 }
00244                 case STARTTHICKT:
00245                 {
00246                         match(STARTTHICKT);
00247                         match(EQUAL);
00248                         if ( inputState->guessing==0 ) {
00249 #line 66 "CLevanisoConf.g"
00250                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00251 #line 252 "CLevanisoConfParser.cpp"
00252                         }
00253                         { // ( ... )+
00254                         int _cnt70=0;
00255                         for (;;) {
00256                                 if ((LA(1) == NUMBER)) {
00257                                         dtemp=numvalue();
00258                                         if ( inputState->guessing==0 ) {
00259 #line 67 "CLevanisoConf.g"
00260                                                 if (i < startthick.size()) {startthick.at(i) = dtemp;} else{startthick.push_back(dtemp);}++i;
00261 #line 262 "CLevanisoConfParser.cpp"
00262                                         }
00263                                 }
00264                                 else {
00265                                         if ( _cnt70>=1 ) { goto _loop70; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00266                                 }
00267                                 
00268                                 _cnt70++;
00269                         }
00270                         _loop70:;
00271                         }  // ( ... )+
00272                         break;
00273                 }
00274                 case MINANISOT:
00275                 {
00276                         match(MINANISOT);
00277                         match(EQUAL);
00278                         if ( inputState->guessing==0 ) {
00279 #line 68 "CLevanisoConf.g"
00280                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00281 #line 282 "CLevanisoConfParser.cpp"
00282                         }
00283                         { // ( ... )+
00284                         int _cnt76=0;
00285                         for (;;) {
00286                                 if ((LA(1) == NUMBER)) {
00287                                         dtemp=numvalue();
00288                                         if ( inputState->guessing==0 ) {
00289 #line 69 "CLevanisoConf.g"
00290                                                 if (i < minaniso.size()) {minaniso.at(i) = dtemp;} else{minaniso.push_back(dtemp);}++i;
00291 #line 292 "CLevanisoConfParser.cpp"
00292                                         }
00293                                 }
00294                                 else {
00295                                         if ( _cnt76>=1 ) { goto _loop76; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00296                                 }
00297                                 
00298                                 _cnt76++;
00299                         }
00300                         _loop76:;
00301                         }  // ( ... )+
00302                         break;
00303                 }
00304                 case MAXANISOT:
00305                 {
00306                         match(MAXANISOT);
00307                         match(EQUAL);
00308                         if ( inputState->guessing==0 ) {
00309 #line 70 "CLevanisoConf.g"
00310                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00311 #line 312 "CLevanisoConfParser.cpp"
00312                         }
00313                         { // ( ... )+
00314                         int _cnt82=0;
00315                         for (;;) {
00316                                 if ((LA(1) == NUMBER)) {
00317                                         dtemp=numvalue();
00318                                         if ( inputState->guessing==0 ) {
00319 #line 71 "CLevanisoConf.g"
00320                                                 if (i < maxaniso.size()) {maxaniso.at(i) = dtemp;} else{maxaniso.push_back(dtemp);}++i;
00321 #line 322 "CLevanisoConfParser.cpp"
00322                                         }
00323                                 }
00324                                 else {
00325                                         if ( _cnt82>=1 ) { goto _loop82; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00326                                 }
00327                                 
00328                                 _cnt82++;
00329                         }
00330                         _loop82:;
00331                         }  // ( ... )+
00332                         break;
00333                 }
00334                 case STARTANISOT:
00335                 {
00336                         match(STARTANISOT);
00337                         match(EQUAL);
00338                         if ( inputState->guessing==0 ) {
00339 #line 72 "CLevanisoConf.g"
00340                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00341 #line 342 "CLevanisoConfParser.cpp"
00342                         }
00343                         { // ( ... )+
00344                         int _cnt88=0;
00345                         for (;;) {
00346                                 if ((LA(1) == NUMBER)) {
00347                                         dtemp=numvalue();
00348                                         if ( inputState->guessing==0 ) {
00349 #line 73 "CLevanisoConf.g"
00350                                                 if (i < startaniso.size()) {startaniso.at(i) = dtemp;} else{startaniso.push_back(dtemp);}++i;
00351 #line 352 "CLevanisoConfParser.cpp"
00352                                         }
00353                                 }
00354                                 else {
00355                                         if ( _cnt88>=1 ) { goto _loop88; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00356                                 }
00357                                 
00358                                 _cnt88++;
00359                         }
00360                         _loop88:;
00361                         }  // ( ... )+
00362                         break;
00363                 }
00364                 case MINSTRIKET:
00365                 {
00366                         match(MINSTRIKET);
00367                         match(EQUAL);
00368                         if ( inputState->guessing==0 ) {
00369 #line 74 "CLevanisoConf.g"
00370                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00371 #line 372 "CLevanisoConfParser.cpp"
00372                         }
00373                         { // ( ... )+
00374                         int _cnt94=0;
00375                         for (;;) {
00376                                 if ((LA(1) == NUMBER)) {
00377                                         dtemp=numvalue();
00378                                         if ( inputState->guessing==0 ) {
00379 #line 75 "CLevanisoConf.g"
00380                                                 if (i < minstrike.size()) {minstrike.at(i) = dtemp;} else{minstrike.push_back(dtemp);}++i;
00381 #line 382 "CLevanisoConfParser.cpp"
00382                                         }
00383                                 }
00384                                 else {
00385                                         if ( _cnt94>=1 ) { goto _loop94; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00386                                 }
00387                                 
00388                                 _cnt94++;
00389                         }
00390                         _loop94:;
00391                         }  // ( ... )+
00392                         break;
00393                 }
00394                 case MAXSTRIKET:
00395                 {
00396                         match(MAXSTRIKET);
00397                         match(EQUAL);
00398                         if ( inputState->guessing==0 ) {
00399 #line 76 "CLevanisoConf.g"
00400                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00401 #line 402 "CLevanisoConfParser.cpp"
00402                         }
00403                         { // ( ... )+
00404                         int _cnt100=0;
00405                         for (;;) {
00406                                 if ((LA(1) == NUMBER)) {
00407                                         dtemp=numvalue();
00408                                         if ( inputState->guessing==0 ) {
00409 #line 77 "CLevanisoConf.g"
00410                                                 if (i < maxstrike.size()) {maxstrike.at(i) = dtemp;} else{maxstrike.push_back(dtemp);}++i;
00411 #line 412 "CLevanisoConfParser.cpp"
00412                                         }
00413                                 }
00414                                 else {
00415                                         if ( _cnt100>=1 ) { goto _loop100; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00416                                 }
00417                                 
00418                                 _cnt100++;
00419                         }
00420                         _loop100:;
00421                         }  // ( ... )+
00422                         break;
00423                 }
00424                 case STARTSTRIKET:
00425                 {
00426                         match(STARTSTRIKET);
00427                         match(EQUAL);
00428                         if ( inputState->guessing==0 ) {
00429 #line 78 "CLevanisoConf.g"
00430                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00431 #line 432 "CLevanisoConfParser.cpp"
00432                         }
00433                         { // ( ... )+
00434                         int _cnt106=0;
00435                         for (;;) {
00436                                 if ((LA(1) == NUMBER)) {
00437                                         dtemp=numvalue();
00438                                         if ( inputState->guessing==0 ) {
00439 #line 79 "CLevanisoConf.g"
00440                                                 if (i < startstrike.size()) {startstrike.at(i) = dtemp;} else{startstrike.push_back(dtemp);}++i;
00441 #line 442 "CLevanisoConfParser.cpp"
00442                                         }
00443                                 }
00444                                 else {
00445                                         if ( _cnt106>=1 ) { goto _loop106; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00446                                 }
00447                                 
00448                                 _cnt106++;
00449                         }
00450                         _loop106:;
00451                         }  // ( ... )+
00452                         break;
00453                 }
00454                 case WEIGHTST:
00455                 {
00456                         match(WEIGHTST);
00457                         match(EQUAL);
00458                         if ( inputState->guessing==0 ) {
00459 #line 80 "CLevanisoConf.g"
00460                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00461 #line 462 "CLevanisoConfParser.cpp"
00462                         }
00463                         { // ( ... )+
00464                         int _cnt112=0;
00465                         for (;;) {
00466                                 if ((LA(1) == NUMBER)) {
00467                                         dtemp=numvalue();
00468                                         if ( inputState->guessing==0 ) {
00469 #line 81 "CLevanisoConf.g"
00470                                                 if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
00471 #line 472 "CLevanisoConfParser.cpp"
00472                                         }
00473                                 }
00474                                 else {
00475                                         if ( _cnt112>=1 ) { goto _loop112; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00476                                 }
00477                                 
00478                                 _cnt112++;
00479                         }
00480                         _loop112:;
00481                         }  // ( ... )+
00482                         break;
00483                 }
00484                 default:
00485                 {
00486                         throw antlr::NoViableAltException(LT(1), getFilename());
00487                 }
00488                 }
00489                 }
00490         }
00491         catch (antlr::RecognitionException& ex) {
00492                 if( inputState->guessing == 0 ) {
00493                         reportError(ex);
00494                         recover(ex,_tokenSet_0);
00495                 } else {
00496                         throw;
00497                 }
00498         }
00499 }
00500 
00501 double  CLevanisoConfParser::numvalue() {
00502 #line 88 "CLevanisoConf.g"
00503         double r;
00504 #line 505 "CLevanisoConfParser.cpp"
00505         antlr::RefToken  currvalue = antlr::nullToken;
00506         
00507         try {      // for error handling
00508                 currvalue = LT(1);
00509                 match(NUMBER);
00510                 if ( inputState->guessing==0 ) {
00511 #line 89 "CLevanisoConf.g"
00512                         r = atof(currvalue->getText().c_str());
00513 #line 514 "CLevanisoConfParser.cpp"
00514                 }
00515         }
00516         catch (antlr::RecognitionException& ex) {
00517                 if( inputState->guessing == 0 ) {
00518                         reportError(ex);
00519                         recover(ex,_tokenSet_1);
00520                 } else {
00521                         throw;
00522                 }
00523         }
00524         return r;
00525 }
00526 
00527 std::string  CLevanisoConfParser::stringvalue() {
00528 #line 96 "CLevanisoConf.g"
00529         std::string r;
00530 #line 531 "CLevanisoConfParser.cpp"
00531         antlr::RefToken  currvalue = antlr::nullToken;
00532         
00533         try {      // for error handling
00534                 currvalue = LT(1);
00535                 match(STRING);
00536                 if ( inputState->guessing==0 ) {
00537 #line 97 "CLevanisoConf.g"
00538                         r = currvalue->getText();
00539 #line 540 "CLevanisoConfParser.cpp"
00540                 }
00541         }
00542         catch (antlr::RecognitionException& ex) {
00543                 if( inputState->guessing == 0 ) {
00544                         reportError(ex);
00545                         recover(ex,_tokenSet_0);
00546                 } else {
00547                         throw;
00548                 }
00549         }
00550         return r;
00551 }
00552 
00553 void CLevanisoConfParser::configfile() {
00554 #line 83 "CLevanisoConf.g"
00555         
00556         
00557 #line 558 "CLevanisoConfParser.cpp"
00558         
00559         try {      // for error handling
00560                 { // ( ... )+
00561                 int _cnt116=0;
00562                 for (;;) {
00563                         if ((_tokenSet_2.member(LA(1)))) {
00564                                 configentry();
00565                                 {
00566                                 if ((LA(1) == COMMENT) && (_tokenSet_0.member(LA(2))) && (LA(3) == antlr::Token::EOF_TYPE || LA(3) == EQUAL || LA(3) == COMMENT) && (_tokenSet_3.member(LA(4))) && (_tokenSet_1.member(LA(5))) && (_tokenSet_4.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
00567                                         match(COMMENT);
00568                                 }
00569                                 else if ((_tokenSet_0.member(LA(1))) && (LA(2) == antlr::Token::EOF_TYPE || LA(2) == EQUAL || LA(2) == COMMENT) && (_tokenSet_3.member(LA(3))) && (_tokenSet_1.member(LA(4))) && (_tokenSet_4.member(LA(5))) && (_tokenSet_5.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
00570                                 }
00571                                 else {
00572                                         throw antlr::NoViableAltException(LT(1), getFilename());
00573                                 }
00574                                 
00575                                 }
00576                         }
00577                         else {
00578                                 if ( _cnt116>=1 ) { goto _loop116; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00579                         }
00580                         
00581                         _cnt116++;
00582                 }
00583                 _loop116:;
00584                 }  // ( ... )+
00585                 { // ( ... )*
00586                 for (;;) {
00587                         if ((LA(1) == COMMENT)) {
00588                                 match(COMMENT);
00589                         }
00590                         else {
00591                                 goto _loop118;
00592                         }
00593                         
00594                 }
00595                 _loop118:;
00596                 } // ( ... )*
00597                 match(antlr::Token::EOF_TYPE);
00598         }
00599         catch (antlr::RecognitionException& ex) {
00600                 if( inputState->guessing == 0 ) {
00601                         reportError(ex);
00602                         recover(ex,_tokenSet_6);
00603                 } else {
00604                         throw;
00605                 }
00606         }
00607 }
00608 
00609 bool  CLevanisoConfParser::boolvalue() {
00610 #line 92 "CLevanisoConf.g"
00611         bool r;
00612 #line 613 "CLevanisoConfParser.cpp"
00613         
00614         try {      // for error handling
00615                 {
00616                 switch ( LA(1)) {
00617                 case TRUE:
00618                 {
00619                         match(TRUE);
00620                         if ( inputState->guessing==0 ) {
00621 #line 93 "CLevanisoConf.g"
00622                                 r = true;
00623 #line 624 "CLevanisoConfParser.cpp"
00624                         }
00625                         break;
00626                 }
00627                 case FALSE:
00628                 {
00629                         match(FALSE);
00630                         if ( inputState->guessing==0 ) {
00631 #line 93 "CLevanisoConf.g"
00632                                 r = false;
00633 #line 634 "CLevanisoConfParser.cpp"
00634                         }
00635                         break;
00636                 }
00637                 default:
00638                 {
00639                         throw antlr::NoViableAltException(LT(1), getFilename());
00640                 }
00641                 }
00642                 }
00643         }
00644         catch (antlr::RecognitionException& ex) {
00645                 if( inputState->guessing == 0 ) {
00646                         reportError(ex);
00647                         recover(ex,_tokenSet_6);
00648                 } else {
00649                         throw;
00650                 }
00651         }
00652         return r;
00653 }
00654 
00655 void CLevanisoConfParser::initializeASTFactory( antlr::ASTFactory& )
00656 {
00657 }
00658 const char* CLevanisoConfParser::tokenNames[] = {
00659         "<0>",
00660         "EOF",
00661         "<2>",
00662         "NULL_TREE_LOOKAHEAD",
00663         "MAXITERT",
00664         "EQUAL",
00665         "NUMBER",
00666         "MODET",
00667         "STRING",
00668         "MTFITT",
00669         "MTINPUTDATAT",
00670         "PTENSORDATAT",
00671         "TENSORERRORT",
00672         "PHASEERRORT",
00673         "RESERRORT",
00674         "MINREST",
00675         "MAXREST",
00676         "STARTREST",
00677         "MINTHICKT",
00678         "MAXTHICKT",
00679         "STARTTHICKT",
00680         "MINANISOT",
00681         "MAXANISOT",
00682         "STARTANISOT",
00683         "MINSTRIKET",
00684         "MAXSTRIKET",
00685         "STARTSTRIKET",
00686         "WEIGHTST",
00687         "COMMENT",
00688         "TRUE",
00689         "FALSE",
00690         "WS",
00691         "NEWLINE",
00692         "REAL",
00693         "INT",
00694         "DIGIT",
00695         "CHAR",
00696         "OTHER",
00697         0
00698 };
00699 
00700 const unsigned long CLevanisoConfParser::_tokenSet_0_data_[] = { 536870546UL, 0UL, 0UL, 0UL };
00701 // EOF MAXITERT MODET MTFITT MTINPUTDATAT PTENSORDATAT TENSORERRORT PHASEERRORT 
00702 // RESERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT STARTTHICKT 
00703 // MINANISOT MAXANISOT STARTANISOT MINSTRIKET MAXSTRIKET STARTSTRIKET WEIGHTST 
00704 // COMMENT 
00705 const antlr::BitSet CLevanisoConfParser::_tokenSet_0(_tokenSet_0_data_,4);
00706 const unsigned long CLevanisoConfParser::_tokenSet_1_data_[] = { 536870610UL, 0UL, 0UL, 0UL };
00707 // EOF MAXITERT NUMBER MODET MTFITT MTINPUTDATAT PTENSORDATAT TENSORERRORT 
00708 // PHASEERRORT RESERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT 
00709 // STARTTHICKT MINANISOT MAXANISOT STARTANISOT MINSTRIKET MAXSTRIKET STARTSTRIKET 
00710 // WEIGHTST COMMENT 
00711 const antlr::BitSet CLevanisoConfParser::_tokenSet_1(_tokenSet_1_data_,4);
00712 const unsigned long CLevanisoConfParser::_tokenSet_2_data_[] = { 268435088UL, 0UL, 0UL, 0UL };
00713 // MAXITERT MODET MTFITT MTINPUTDATAT PTENSORDATAT TENSORERRORT PHASEERRORT 
00714 // RESERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT STARTTHICKT 
00715 // MINANISOT MAXANISOT STARTANISOT MINSTRIKET MAXSTRIKET STARTSTRIKET WEIGHTST 
00716 const antlr::BitSet CLevanisoConfParser::_tokenSet_2(_tokenSet_2_data_,4);
00717 const unsigned long CLevanisoConfParser::_tokenSet_3_data_[] = { 268435778UL, 0UL, 0UL, 0UL };
00718 // EOF NUMBER STRING COMMENT 
00719 const antlr::BitSet CLevanisoConfParser::_tokenSet_3(_tokenSet_3_data_,4);
00720 const unsigned long CLevanisoConfParser::_tokenSet_4_data_[] = { 536870642UL, 0UL, 0UL, 0UL };
00721 // EOF MAXITERT EQUAL NUMBER MODET MTFITT MTINPUTDATAT PTENSORDATAT TENSORERRORT 
00722 // PHASEERRORT RESERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT 
00723 // STARTTHICKT MINANISOT MAXANISOT STARTANISOT MINSTRIKET MAXSTRIKET STARTSTRIKET 
00724 // WEIGHTST COMMENT 
00725 const antlr::BitSet CLevanisoConfParser::_tokenSet_4(_tokenSet_4_data_,4);
00726 const unsigned long CLevanisoConfParser::_tokenSet_5_data_[] = { 536870898UL, 0UL, 0UL, 0UL };
00727 // EOF MAXITERT EQUAL NUMBER MODET STRING MTFITT MTINPUTDATAT PTENSORDATAT 
00728 // TENSORERRORT PHASEERRORT RESERRORT MINREST MAXREST STARTREST MINTHICKT 
00729 // MAXTHICKT STARTTHICKT MINANISOT MAXANISOT STARTANISOT MINSTRIKET MAXSTRIKET 
00730 // STARTSTRIKET WEIGHTST COMMENT 
00731 const antlr::BitSet CLevanisoConfParser::_tokenSet_5(_tokenSet_5_data_,4);
00732 const unsigned long CLevanisoConfParser::_tokenSet_6_data_[] = { 2UL, 0UL, 0UL, 0UL };
00733 // EOF 
00734 const antlr::BitSet CLevanisoConfParser::_tokenSet_6(_tokenSet_6_data_,4);
00735 
00736