GPLIB++: SurfInvGaConfParser.cpp Source File

00001 /* $ANTLR 2.7.6 (20070220): "SurfInvGaConf.g" -> "SurfInvGaConfParser.cpp"$ */
00002 #include "SurfInvGaConfParser.hpp"
00003 #include <antlr/NoViableAltException.hpp>
00004 #include <antlr/SemanticException.hpp>
00005 #include <antlr/ASTFactory.hpp>
00006 #line 1 "SurfInvGaConf.g"
00007 #line 8 "SurfInvGaConfParser.cpp"
00008 SurfInvGaConfParser::SurfInvGaConfParser(antlr::TokenBuffer& tokenBuf, int k)
00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }
00012 
00013 SurfInvGaConfParser::SurfInvGaConfParser(antlr::TokenBuffer& tokenBuf)
00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }
00017 
00018 SurfInvGaConfParser::SurfInvGaConfParser(antlr::TokenStream& lexer, int k)
00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }
00022 
00023 SurfInvGaConfParser::SurfInvGaConfParser(antlr::TokenStream& lexer)
00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }
00027 
00028 SurfInvGaConfParser::SurfInvGaConfParser(const antlr::ParserSharedInputState& state)
00029 : antlr::LLkParser(state,10)
00030 {
00031 }
00032 
00033 void SurfInvGaConfParser::configentry() {
00034         
00035         try {      // for error handling
00036                 {
00037                 switch ( LA(1)) {
00038                 case VERBOSET:
00039                 {
00040                         match(VERBOSET);
00041                         match(EQUAL);
00042                         verbose=boolvalue();
00043                         break;
00044                 }
00045                 case USEVREFMODELT:
00046                 {
00047                         match(USEVREFMODELT);
00048                         match(EQUAL);
00049                         usevrefmodel=boolvalue();
00050                         break;
00051                 }
00052                 case VREFMODELT:
00053                 {
00054                         match(VREFMODELT);
00055                         match(EQUAL);
00056                         vrefmodel=stringvalue();
00057                         break;
00058                 }
00059                 case FITEXPONENTT:
00060                 {
00061                         match(FITEXPONENTT);
00062                         match(EQUAL);
00063                         fitexponent=numvalue();
00064                         break;
00065                 }
00066                 case POPSIZET:
00067                 {
00068                         match(POPSIZET);
00069                         match(EQUAL);
00070                         popsize=numvalue();
00071                         break;
00072                 }
00073                 case INITTEMPT:
00074                 {
00075                         match(INITTEMPT);
00076                         match(EQUAL);
00077                         inittemp=numvalue();
00078                         break;
00079                 }
00080                 case COOLINGRATIOT:
00081                 {
00082                         match(COOLINGRATIOT);
00083                         match(EQUAL);
00084                         coolingratio=numvalue();
00085                         break;
00086                 }
00087                 case GENERATIONST:
00088                 {
00089                         match(GENERATIONST);
00090                         match(EQUAL);
00091                         generations=numvalue();
00092                         break;
00093                 }
00094                 case MUTATIONPROBT:
00095                 {
00096                         match(MUTATIONPROBT);
00097                         match(EQUAL);
00098                         mutationprob=numvalue();
00099                         break;
00100                 }
00101                 case CROSSOVERPROBT:
00102                 {
00103                         match(CROSSOVERPROBT);
00104                         match(EQUAL);
00105                         crossoverprob=numvalue();
00106                         break;
00107                 }
00108                 case POISSONT:
00109                 {
00110                         match(POISSONT);
00111                         match(EQUAL);
00112                         poisson=numvalue();
00113                         break;
00114                 }
00115                 case THREADST:
00116                 {
00117                         match(THREADST);
00118                         match(EQUAL);
00119                         threads=numvalue();
00120                         break;
00121                 }
00122                 case ERRORLEVELT:
00123                 {
00124                         match(ERRORLEVELT);
00125                         match(EQUAL);
00126                         errorlevel=numvalue();
00127                         break;
00128                 }
00129                 case GATYPET:
00130                 {
00131                         match(GATYPET);
00132                         match(EQUAL);
00133                         gatype=stringvalue();
00134                         break;
00135                 }
00136                 case OUTPUTBASET:
00137                 {
00138                         match(OUTPUTBASET);
00139                         match(EQUAL);
00140                         outputbase=stringvalue();
00141                         break;
00142                 }
00143                 case INPUTDATAT:
00144                 {
00145                         match(INPUTDATAT);
00146                         match(EQUAL);
00147                         inputdata=stringvalue();
00148                         break;
00149                 }
00150                 case ANNEALINGGENERATIONT:
00151                 {
00152                         match(ANNEALINGGENERATIONT);
00153                         match(EQUAL);
00154                         annealinggeneration=numvalue();
00155                         break;
00156                 }
00157                 case ELITISTT:
00158                 {
00159                         match(ELITISTT);
00160                         match(EQUAL);
00161                         elitist=boolvalue();
00162                         break;
00163                 }
00164                 case THICKBASET:
00165                 {
00166                         match(THICKBASET);
00167                         match(EQUAL);
00168                         if ( inputState->guessing==0 ) {
00169 #line 70 "SurfInvGaConf.g"
00170                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00171 #line 172 "SurfInvGaConfParser.cpp"
00172                         }
00173                         { // ( ... )+
00174                         int _cnt74=0;
00175                         for (;;) {
00176                                 if ((LA(1) == NUMBER)) {
00177                                         dtemp=numvalue();
00178                                         if ( inputState->guessing==0 ) {
00179 #line 71 "SurfInvGaConf.g"
00180                                                 if (i < thickbase.size()) {thickbase.at(i) = dtemp;} else{thickbase.push_back(dtemp);}++i;
00181 #line 182 "SurfInvGaConfParser.cpp"
00182                                         }
00183                                 }
00184                                 else {
00185                                         if ( _cnt74>=1 ) { goto _loop74; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00186                                 }
00187                                 
00188                                 _cnt74++;
00189                         }
00190                         _loop74:;
00191                         }  // ( ... )+
00192                         break;
00193                 }
00194                 case THICKSTEPT:
00195                 {
00196                         match(THICKSTEPT);
00197                         match(EQUAL);
00198                         if ( inputState->guessing==0 ) {
00199 #line 72 "SurfInvGaConf.g"
00200                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00201 #line 202 "SurfInvGaConfParser.cpp"
00202                         }
00203                         { // ( ... )+
00204                         int _cnt80=0;
00205                         for (;;) {
00206                                 if ((LA(1) == NUMBER)) {
00207                                         dtemp=numvalue();
00208                                         if ( inputState->guessing==0 ) {
00209 #line 73 "SurfInvGaConf.g"
00210                                                 if (i < thickstep.size()) {thickstep.at(i) = dtemp;} else{thickstep.push_back(dtemp);}++i;
00211 #line 212 "SurfInvGaConfParser.cpp"
00212                                         }
00213                                 }
00214                                 else {
00215                                         if ( _cnt80>=1 ) { goto _loop80; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00216                                 }
00217                                 
00218                                 _cnt80++;
00219                         }
00220                         _loop80:;
00221                         }  // ( ... )+
00222                         break;
00223                 }
00224                 case THICKSIZEST:
00225                 {
00226                         match(THICKSIZEST);
00227                         match(EQUAL);
00228                         if ( inputState->guessing==0 ) {
00229 #line 74 "SurfInvGaConf.g"
00230                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00231 #line 232 "SurfInvGaConfParser.cpp"
00232                         }
00233                         { // ( ... )+
00234                         int _cnt86=0;
00235                         for (;;) {
00236                                 if ((LA(1) == NUMBER)) {
00237                                         itemp=numvalue();
00238                                         if ( inputState->guessing==0 ) {
00239 #line 75 "SurfInvGaConf.g"
00240                                                 if (i < thicksizes.size()) {thicksizes.at(i) = itemp;} else{thicksizes.push_back(itemp);}++i;
00241 #line 242 "SurfInvGaConfParser.cpp"
00242                                         }
00243                                 }
00244                                 else {
00245                                         if ( _cnt86>=1 ) { goto _loop86; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00246                                 }
00247                                 
00248                                 _cnt86++;
00249                         }
00250                         _loop86:;
00251                         }  // ( ... )+
00252                         break;
00253                 }
00254                 case SVELBASET:
00255                 {
00256                         match(SVELBASET);
00257                         match(EQUAL);
00258                         if ( inputState->guessing==0 ) {
00259 #line 76 "SurfInvGaConf.g"
00260                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00261 #line 262 "SurfInvGaConfParser.cpp"
00262                         }
00263                         { // ( ... )+
00264                         int _cnt92=0;
00265                         for (;;) {
00266                                 if ((LA(1) == NUMBER)) {
00267                                         dtemp=numvalue();
00268                                         if ( inputState->guessing==0 ) {
00269 #line 77 "SurfInvGaConf.g"
00270                                                 if (i < svelbase.size()) {svelbase.at(i) = dtemp;} else{svelbase.push_back(dtemp);}++i;
00271 #line 272 "SurfInvGaConfParser.cpp"
00272                                         }
00273                                 }
00274                                 else {
00275                                         if ( _cnt92>=1 ) { goto _loop92; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00276                                 }
00277                                 
00278                                 _cnt92++;
00279                         }
00280                         _loop92:;
00281                         }  // ( ... )+
00282                         break;
00283                 }
00284                 case SVELSTEPT:
00285                 {
00286                         match(SVELSTEPT);
00287                         match(EQUAL);
00288                         if ( inputState->guessing==0 ) {
00289 #line 78 "SurfInvGaConf.g"
00290                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00291 #line 292 "SurfInvGaConfParser.cpp"
00292                         }
00293                         { // ( ... )+
00294                         int _cnt98=0;
00295                         for (;;) {
00296                                 if ((LA(1) == NUMBER)) {
00297                                         dtemp=numvalue();
00298                                         if ( inputState->guessing==0 ) {
00299 #line 79 "SurfInvGaConf.g"
00300                                                 if (i < svelstep.size()) {svelstep.at(i) = dtemp;} else{svelstep.push_back(dtemp);}++i;
00301 #line 302 "SurfInvGaConfParser.cpp"
00302                                         }
00303                                 }
00304                                 else {
00305                                         if ( _cnt98>=1 ) { goto _loop98; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00306                                 }
00307                                 
00308                                 _cnt98++;
00309                         }
00310                         _loop98:;
00311                         }  // ( ... )+
00312                         break;
00313                 }
00314                 case SVELSIZEST:
00315                 {
00316                         match(SVELSIZEST);
00317                         match(EQUAL);
00318                         if ( inputState->guessing==0 ) {
00319 #line 80 "SurfInvGaConf.g"
00320                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00321 #line 322 "SurfInvGaConfParser.cpp"
00322                         }
00323                         { // ( ... )+
00324                         int _cnt104=0;
00325                         for (;;) {
00326                                 if ((LA(1) == NUMBER)) {
00327                                         itemp=numvalue();
00328                                         if ( inputState->guessing==0 ) {
00329 #line 81 "SurfInvGaConf.g"
00330                                                 if (i < svelsizes.size()) {svelsizes.at(i) = itemp;} else{svelsizes.push_back(itemp);}++i;
00331 #line 332 "SurfInvGaConfParser.cpp"
00332                                         }
00333                                 }
00334                                 else {
00335                                         if ( _cnt104>=1 ) { goto _loop104; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00336                                 }
00337                                 
00338                                 _cnt104++;
00339                         }
00340                         _loop104:;
00341                         }  // ( ... )+
00342                         break;
00343                 }
00344                 case WEIGHTST:
00345                 {
00346                         match(WEIGHTST);
00347                         match(EQUAL);
00348                         if ( inputState->guessing==0 ) {
00349 #line 82 "SurfInvGaConf.g"
00350                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00351 #line 352 "SurfInvGaConfParser.cpp"
00352                         }
00353                         { // ( ... )+
00354                         int _cnt110=0;
00355                         for (;;) {
00356                                 if ((LA(1) == NUMBER)) {
00357                                         dtemp=numvalue();
00358                                         if ( inputState->guessing==0 ) {
00359 #line 83 "SurfInvGaConf.g"
00360                                                 if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
00361 #line 362 "SurfInvGaConfParser.cpp"
00362                                         }
00363                                 }
00364                                 else {
00365                                         if ( _cnt110>=1 ) { goto _loop110; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00366                                 }
00367                                 
00368                                 _cnt110++;
00369                         }
00370                         _loop110:;
00371                         }  // ( ... )+
00372                         break;
00373                 }
00374                 default:
00375                 {
00376                         throw antlr::NoViableAltException(LT(1), getFilename());
00377                 }
00378                 }
00379                 }
00380         }
00381         catch (antlr::RecognitionException& ex) {
00382                 if( inputState->guessing == 0 ) {
00383                         reportError(ex);
00384                         recover(ex,_tokenSet_0);
00385                 } else {
00386                         throw;
00387                 }
00388         }
00389 }
00390 
00391 bool  SurfInvGaConfParser::boolvalue() {
00392 #line 97 "SurfInvGaConf.g"
00393         bool r;
00394 #line 395 "SurfInvGaConfParser.cpp"
00395         
00396         try {      // for error handling
00397                 {
00398                 switch ( LA(1)) {
00399                 case TRUE:
00400                 {
00401                         match(TRUE);
00402                         if ( inputState->guessing==0 ) {
00403 #line 98 "SurfInvGaConf.g"
00404                                 r = true;
00405 #line 406 "SurfInvGaConfParser.cpp"
00406                         }
00407                         break;
00408                 }
00409                 case FALSE:
00410                 {
00411                         match(FALSE);
00412                         if ( inputState->guessing==0 ) {
00413 #line 98 "SurfInvGaConf.g"
00414                                 r = false;
00415 #line 416 "SurfInvGaConfParser.cpp"
00416                         }
00417                         break;
00418                 }
00419                 default:
00420                 {
00421                         throw antlr::NoViableAltException(LT(1), getFilename());
00422                 }
00423                 }
00424                 }
00425         }
00426         catch (antlr::RecognitionException& ex) {
00427                 if( inputState->guessing == 0 ) {
00428                         reportError(ex);
00429                         recover(ex,_tokenSet_0);
00430                 } else {
00431                         throw;
00432                 }
00433         }
00434         return r;
00435 }
00436 
00437 std::string  SurfInvGaConfParser::stringvalue() {
00438 #line 101 "SurfInvGaConf.g"
00439         std::string r;
00440 #line 441 "SurfInvGaConfParser.cpp"
00441         antlr::RefToken  currvalue = antlr::nullToken;
00442         
00443         try {      // for error handling
00444                 currvalue = LT(1);
00445                 match(STRING);
00446                 if ( inputState->guessing==0 ) {
00447 #line 102 "SurfInvGaConf.g"
00448                         r = currvalue->getText();
00449 #line 450 "SurfInvGaConfParser.cpp"
00450                 }
00451         }
00452         catch (antlr::RecognitionException& ex) {
00453                 if( inputState->guessing == 0 ) {
00454                         reportError(ex);
00455                         recover(ex,_tokenSet_0);
00456                 } else {
00457                         throw;
00458                 }
00459         }
00460         return r;
00461 }
00462 
00463 double  SurfInvGaConfParser::numvalue() {
00464 #line 93 "SurfInvGaConf.g"
00465         double r;
00466 #line 467 "SurfInvGaConfParser.cpp"
00467         antlr::RefToken  currvalue = antlr::nullToken;
00468         
00469         try {      // for error handling
00470                 currvalue = LT(1);
00471                 match(NUMBER);
00472                 if ( inputState->guessing==0 ) {
00473 #line 94 "SurfInvGaConf.g"
00474                         r = atof(currvalue->getText().c_str());
00475 #line 476 "SurfInvGaConfParser.cpp"
00476                 }
00477         }
00478         catch (antlr::RecognitionException& ex) {
00479                 if( inputState->guessing == 0 ) {
00480                         reportError(ex);
00481                         recover(ex,_tokenSet_1);
00482                 } else {
00483                         throw;
00484                 }
00485         }
00486         return r;
00487 }
00488 
00489 void SurfInvGaConfParser::configfile() {
00490 #line 85 "SurfInvGaConf.g"
00491         
00492         verbose = false;
00493         usevrefmodel = false;
00494         fitexponent = 2;
00495         
00496 #line 497 "SurfInvGaConfParser.cpp"
00497         
00498         try {      // for error handling
00499                 { // ( ... )+
00500                 int _cnt114=0;
00501                 for (;;) {
00502                         if ((_tokenSet_2.member(LA(1)))) {
00503                                 configentry();
00504                                 {
00505                                 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)))) {
00506                                         match(COMMENT);
00507                                 }
00508                                 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)))) {
00509                                 }
00510                                 else {
00511                                         throw antlr::NoViableAltException(LT(1), getFilename());
00512                                 }
00513                                 
00514                                 }
00515                         }
00516                         else {
00517                                 if ( _cnt114>=1 ) { goto _loop114; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00518                         }
00519                         
00520                         _cnt114++;
00521                 }
00522                 _loop114:;
00523                 }  // ( ... )+
00524                 { // ( ... )*
00525                 for (;;) {
00526                         if ((LA(1) == COMMENT)) {
00527                                 match(COMMENT);
00528                         }
00529                         else {
00530                                 goto _loop116;
00531                         }
00532                         
00533                 }
00534                 _loop116:;
00535                 } // ( ... )*
00536                 match(antlr::Token::EOF_TYPE);
00537         }
00538         catch (antlr::RecognitionException& ex) {
00539                 if( inputState->guessing == 0 ) {
00540                         reportError(ex);
00541                         recover(ex,_tokenSet_6);
00542                 } else {
00543                         throw;
00544                 }
00545         }
00546 }
00547 
00548 void SurfInvGaConfParser::initializeASTFactory( antlr::ASTFactory& )
00549 {
00550 }
00551 const char* SurfInvGaConfParser::tokenNames[] = {
00552         "<0>",
00553         "EOF",
00554         "<2>",
00555         "NULL_TREE_LOOKAHEAD",
00556         "VERBOSET",
00557         "EQUAL",
00558         "USEVREFMODELT",
00559         "VREFMODELT",
00560         "STRING",
00561         "FITEXPONENTT",
00562         "NUMBER",
00563         "POPSIZET",
00564         "INITTEMPT",
00565         "COOLINGRATIOT",
00566         "GENERATIONST",
00567         "MUTATIONPROBT",
00568         "CROSSOVERPROBT",
00569         "POISSONT",
00570         "THREADST",
00571         "ERRORLEVELT",
00572         "GATYPET",
00573         "OUTPUTBASET",
00574         "INPUTDATAT",
00575         "ANNEALINGGENERATIONT",
00576         "ELITISTT",
00577         "THICKBASET",
00578         "THICKSTEPT",
00579         "THICKSIZEST",
00580         "SVELBASET",
00581         "SVELSTEPT",
00582         "SVELSIZEST",
00583         "WEIGHTST",
00584         "COMMENT",
00585         "TRUE",
00586         "FALSE",
00587         "WS",
00588         "NEWLINE",
00589         "REAL",
00590         "INT",
00591         "DIGIT",
00592         "CHAR",
00593         "OTHER",
00594         0
00595 };
00596 
00597 const unsigned long SurfInvGaConfParser::_tokenSet_0_data_[] = { 4294965970UL, 1UL, 0UL, 0UL };
00598 // EOF VERBOSET USEVREFMODELT VREFMODELT FITEXPONENTT POPSIZET INITTEMPT 
00599 // COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT POISSONT THREADST 
00600 // ERRORLEVELT GATYPET OUTPUTBASET INPUTDATAT ANNEALINGGENERATIONT ELITISTT 
00601 // THICKBASET THICKSTEPT THICKSIZEST SVELBASET SVELSTEPT SVELSIZEST WEIGHTST 
00602 // COMMENT 
00603 const antlr::BitSet SurfInvGaConfParser::_tokenSet_0(_tokenSet_0_data_,4);
00604 const unsigned long SurfInvGaConfParser::_tokenSet_1_data_[] = { 4294966994UL, 1UL, 0UL, 0UL };
00605 // EOF VERBOSET USEVREFMODELT VREFMODELT FITEXPONENTT NUMBER POPSIZET INITTEMPT 
00606 // COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT POISSONT THREADST 
00607 // ERRORLEVELT GATYPET OUTPUTBASET INPUTDATAT ANNEALINGGENERATIONT ELITISTT 
00608 // THICKBASET THICKSTEPT THICKSIZEST SVELBASET SVELSTEPT SVELSIZEST WEIGHTST 
00609 // COMMENT 
00610 const antlr::BitSet SurfInvGaConfParser::_tokenSet_1(_tokenSet_1_data_,4);
00611 const unsigned long SurfInvGaConfParser::_tokenSet_2_data_[] = { 4294965968UL, 0UL, 0UL, 0UL };
00612 // VERBOSET USEVREFMODELT VREFMODELT FITEXPONENTT POPSIZET INITTEMPT COOLINGRATIOT 
00613 // GENERATIONST MUTATIONPROBT CROSSOVERPROBT POISSONT THREADST ERRORLEVELT 
00614 // GATYPET OUTPUTBASET INPUTDATAT ANNEALINGGENERATIONT ELITISTT THICKBASET 
00615 // THICKSTEPT THICKSIZEST SVELBASET SVELSTEPT SVELSIZEST WEIGHTST 
00616 const antlr::BitSet SurfInvGaConfParser::_tokenSet_2(_tokenSet_2_data_,4);
00617 const unsigned long SurfInvGaConfParser::_tokenSet_3_data_[] = { 1282UL, 7UL, 0UL, 0UL };
00618 // EOF STRING NUMBER COMMENT TRUE FALSE 
00619 const antlr::BitSet SurfInvGaConfParser::_tokenSet_3(_tokenSet_3_data_,4);
00620 const unsigned long SurfInvGaConfParser::_tokenSet_4_data_[] = { 4294967026UL, 1UL, 0UL, 0UL };
00621 // EOF VERBOSET EQUAL USEVREFMODELT VREFMODELT FITEXPONENTT NUMBER POPSIZET 
00622 // INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT POISSONT 
00623 // THREADST ERRORLEVELT GATYPET OUTPUTBASET INPUTDATAT ANNEALINGGENERATIONT 
00624 // ELITISTT THICKBASET THICKSTEPT THICKSIZEST SVELBASET SVELSTEPT SVELSIZEST 
00625 // WEIGHTST COMMENT 
00626 const antlr::BitSet SurfInvGaConfParser::_tokenSet_4(_tokenSet_4_data_,4);
00627 const unsigned long SurfInvGaConfParser::_tokenSet_5_data_[] = { 4294967282UL, 7UL, 0UL, 0UL };
00628 // EOF VERBOSET EQUAL USEVREFMODELT VREFMODELT STRING FITEXPONENTT NUMBER 
00629 // POPSIZET INITTEMPT COOLINGRATIOT GENERATIONST MUTATIONPROBT CROSSOVERPROBT 
00630 // POISSONT THREADST ERRORLEVELT GATYPET OUTPUTBASET INPUTDATAT ANNEALINGGENERATIONT 
00631 // ELITISTT THICKBASET THICKSTEPT THICKSIZEST SVELBASET SVELSTEPT SVELSIZEST 
00632 // WEIGHTST COMMENT TRUE FALSE 
00633 const antlr::BitSet SurfInvGaConfParser::_tokenSet_5(_tokenSet_5_data_,4);
00634 const unsigned long SurfInvGaConfParser::_tokenSet_6_data_[] = { 2UL, 0UL, 0UL, 0UL };
00635 // EOF 
00636 const antlr::BitSet SurfInvGaConfParser::_tokenSet_6(_tokenSet_6_data_,4);
00637 
00638