CLevmarConfParser Class Reference

#include <CLevmarConfParser.hpp>

Inheritance diagram for CLevmarConfParser:

Inheritance graph
[legend]
Collaboration diagram for CLevmarConfParser:

Collaboration graph
[legend]
List of all members.

Public Member Functions

void initializeASTFactory (antlr::ASTFactory &factory)
 CLevmarConfParser (antlr::TokenBuffer &tokenBuf)
 CLevmarConfParser (antlr::TokenStream &lexer)
 CLevmarConfParser (const antlr::ParserSharedInputState &state)
int getNumTokens () const
const char * getTokenName (int type) const
const char *const * getTokenNames () const
void configentry ()
double numvalue ()
std::string stringvalue ()
void configfile ()
bool boolvalue ()
antlr::RefAST getAST ()

Public Attributes

int maxiter
std::string mode
std::string mtfit
std::string mtinputdata
std::string recinputdata
double slowness
double omega
double sigma
int shift
double wlevel
double poisson
double starttime
double endtime
double tensorerror
double phaseerror
double reserror
double recerror
std::vector< double > minres
std::vector< double > maxres
std::vector< double > startres
std::vector< double > minthick
std::vector< double > maxthick
std::vector< double > startthick
std::vector< double > minsvel
std::vector< double > maxsvel
std::vector< double > startsvel
std::vector< double > mindens
std::vector< double > maxdens
std::vector< double > startdens
std::vector< double > weights

Protected Member Functions

 CLevmarConfParser (antlr::TokenBuffer &tokenBuf, int k)
 CLevmarConfParser (antlr::TokenStream &lexer, int k)

Protected Attributes

antlr::RefAST returnAST

Detailed Description

Definition at line 18 of file CLevmarConfParser.hpp.

Constructor & Destructor Documentation

CLevmarConfParser::CLevmarConfParser ( antlr::TokenBuffer &  tokenBuf,
int  k 
) [protected]

Definition at line 8 of file CLevmarConfParser.cpp.

00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }

CLevmarConfParser::CLevmarConfParser ( antlr::TokenBuffer &  tokenBuf  ) 

Definition at line 13 of file CLevmarConfParser.cpp.

00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }

CLevmarConfParser::CLevmarConfParser ( antlr::TokenStream &  lexer,
int  k 
) [protected]

Definition at line 18 of file CLevmarConfParser.cpp.

00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }

CLevmarConfParser::CLevmarConfParser ( antlr::TokenStream &  lexer  ) 

Definition at line 23 of file CLevmarConfParser.cpp.

00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }

CLevmarConfParser::CLevmarConfParser ( const antlr::ParserSharedInputState &  state  ) 

Definition at line 28 of file CLevmarConfParser.cpp.

00029 : antlr::LLkParser(state,10)
00030 {
00031 }

Member Function Documentation

void CLevmarConfParser::initializeASTFactory ( antlr::ASTFactory &  factory  ) 

Definition at line 718 of file CLevmarConfParser.cpp.

00719 {
00720 }

int CLevmarConfParser::getNumTokens (  )  const [inline]

Definition at line 67 of file CLevmarConfParser.hpp.

00068         {
00069                 return CLevmarConfParser::NUM_TOKENS;
00070         }

const char* CLevmarConfParser::getTokenName ( int  type  )  const [inline]

Definition at line 71 of file CLevmarConfParser.hpp.

00072         {
00073                 if( type > getNumTokens() ) return 0;
00074                 return CLevmarConfParser::tokenNames[type];
00075         }

const char* const* CLevmarConfParser::getTokenNames (  )  const [inline]

Definition at line 76 of file CLevmarConfParser.hpp.

00077         {
00078                 return CLevmarConfParser::tokenNames;
00079         }

void CLevmarConfParser::configentry (  ) 

Definition at line 33 of file CLevmarConfParser.cpp.

References endtime, ENDTIMET, EQUAL, maxiter, MAXITERT, maxres, MAXREST, minres, MINREST, minthick, MINTHICKT, mode, MODET, mtfit, MTFITT, mtinputdata, MTINPUTDATAT, NUMBER, numvalue(), omega, OMEGAT, phaseerror, PHASEERRORT, poisson, POISSONT, recerror, RECERRORT, recinputdata, RECINPUTDATAT, reserror, RESERRORT, shift, SHIFTT, sigma, SIGMAT, slowness, SLOWNESST, startres, STARTREST, starttime, STARTTIMET, stringvalue(), tensorerror, TENSORERRORT, wlevel, and WLEVELT.

Referenced by configfile().

00033                                     {
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 RECINPUTDATAT:
00067                 {
00068                         match(RECINPUTDATAT);
00069                         match(EQUAL);
00070                         recinputdata=stringvalue();
00071                         break;
00072                 }
00073                 case SLOWNESST:
00074                 {
00075                         match(SLOWNESST);
00076                         match(EQUAL);
00077                         slowness=numvalue();
00078                         break;
00079                 }
00080                 case OMEGAT:
00081                 {
00082                         match(OMEGAT);
00083                         match(EQUAL);
00084                         omega=numvalue();
00085                         break;
00086                 }
00087                 case SIGMAT:
00088                 {
00089                         match(SIGMAT);
00090                         match(EQUAL);
00091                         sigma=numvalue();
00092                         break;
00093                 }
00094                 case SHIFTT:
00095                 {
00096                         match(SHIFTT);
00097                         match(EQUAL);
00098                         shift=numvalue();
00099                         break;
00100                 }
00101                 case WLEVELT:
00102                 {
00103                         match(WLEVELT);
00104                         match(EQUAL);
00105                         wlevel=numvalue();
00106                         break;
00107                 }
00108                 case POISSONT:
00109                 {
00110                         match(POISSONT);
00111                         match(EQUAL);
00112                         poisson=numvalue();
00113                         break;
00114                 }
00115                 case STARTTIMET:
00116                 {
00117                         match(STARTTIMET);
00118                         match(EQUAL);
00119                         starttime=numvalue();
00120                         break;
00121                 }
00122                 case ENDTIMET:
00123                 {
00124                         match(ENDTIMET);
00125                         match(EQUAL);
00126                         endtime=numvalue();
00127                         break;
00128                 }
00129                 case TENSORERRORT:
00130                 {
00131                         match(TENSORERRORT);
00132                         match(EQUAL);
00133                         tensorerror=numvalue();
00134                         break;
00135                 }
00136                 case PHASEERRORT:
00137                 {
00138                         match(PHASEERRORT);
00139                         match(EQUAL);
00140                         phaseerror=numvalue();
00141                         break;
00142                 }
00143                 case RESERRORT:
00144                 {
00145                         match(RESERRORT);
00146                         match(EQUAL);
00147                         reserror=numvalue();
00148                         break;
00149                 }
00150                 case RECERRORT:
00151                 {
00152                         match(RECERRORT);
00153                         match(EQUAL);
00154                         recerror=numvalue();
00155                         break;
00156                 }
00157                 case MINREST:
00158                 {
00159                         match(MINREST);
00160                         match(EQUAL);
00161                         if ( inputState->guessing==0 ) {
00162 #line 74 "CLevmarConf.g"
00163                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00164 #line 165 "CLevmarConfParser.cpp"
00165                         }
00166                         { // ( ... )+
00167                         int _cnt76=0;
00168                         for (;;) {
00169                                 if ((LA(1) == NUMBER)) {
00170                                         dtemp=numvalue();
00171                                         if ( inputState->guessing==0 ) {
00172 #line 75 "CLevmarConf.g"
00173                                                 if (i < minres.size()) {minres.at(i) = dtemp;} else{minres.push_back(dtemp);}++i;
00174 #line 175 "CLevmarConfParser.cpp"
00175                                         }
00176                                 }
00177                                 else {
00178                                         if ( _cnt76>=1 ) { goto _loop76; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00179                                 }
00180                                 
00181                                 _cnt76++;
00182                         }
00183                         _loop76:;
00184                         }  // ( ... )+
00185                         break;
00186                 }
00187                 case MAXREST:
00188                 {
00189                         match(MAXREST);
00190                         match(EQUAL);
00191                         if ( inputState->guessing==0 ) {
00192 #line 76 "CLevmarConf.g"
00193                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00194 #line 195 "CLevmarConfParser.cpp"
00195                         }
00196                         { // ( ... )+
00197                         int _cnt82=0;
00198                         for (;;) {
00199                                 if ((LA(1) == NUMBER)) {
00200                                         dtemp=numvalue();
00201                                         if ( inputState->guessing==0 ) {
00202 #line 77 "CLevmarConf.g"
00203                                                 if (i < maxres.size()) {maxres.at(i) = dtemp;} else{maxres.push_back(dtemp);}++i;
00204 #line 205 "CLevmarConfParser.cpp"
00205                                         }
00206                                 }
00207                                 else {
00208                                         if ( _cnt82>=1 ) { goto _loop82; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00209                                 }
00210                                 
00211                                 _cnt82++;
00212                         }
00213                         _loop82:;
00214                         }  // ( ... )+
00215                         break;
00216                 }
00217                 case STARTREST:
00218                 {
00219                         match(STARTREST);
00220                         match(EQUAL);
00221                         if ( inputState->guessing==0 ) {
00222 #line 78 "CLevmarConf.g"
00223                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00224 #line 225 "CLevmarConfParser.cpp"
00225                         }
00226                         { // ( ... )+
00227                         int _cnt88=0;
00228                         for (;;) {
00229                                 if ((LA(1) == NUMBER)) {
00230                                         dtemp=numvalue();
00231                                         if ( inputState->guessing==0 ) {
00232 #line 79 "CLevmarConf.g"
00233                                                 if (i < startres.size()) {startres.at(i) = dtemp;} else{startres.push_back(dtemp);}++i;
00234 #line 235 "CLevmarConfParser.cpp"
00235                                         }
00236                                 }
00237                                 else {
00238                                         if ( _cnt88>=1 ) { goto _loop88; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00239                                 }
00240                                 
00241                                 _cnt88++;
00242                         }
00243                         _loop88:;
00244                         }  // ( ... )+
00245                         break;
00246                 }
00247                 case MINTHICKT:
00248                 {
00249                         match(MINTHICKT);
00250                         match(EQUAL);
00251                         if ( inputState->guessing==0 ) {
00252 #line 80 "CLevmarConf.g"
00253                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00254 #line 255 "CLevmarConfParser.cpp"
00255                         }
00256                         { // ( ... )+
00257                         int _cnt94=0;
00258                         for (;;) {
00259                                 if ((LA(1) == NUMBER)) {
00260                                         dtemp=numvalue();
00261                                         if ( inputState->guessing==0 ) {
00262 #line 81 "CLevmarConf.g"
00263                                                 if (i < minthick.size()) {minthick.at(i) = dtemp;} else{minthick.push_back(dtemp);}++i;
00264 #line 265 "CLevmarConfParser.cpp"
00265                                         }
00266                                 }
00267                                 else {
00268                                         if ( _cnt94>=1 ) { goto _loop94; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00269                                 }
00270                                 
00271                                 _cnt94++;
00272                         }
00273                         _loop94:;
00274                         }  // ( ... )+
00275                         break;
00276                 }
00277                 case MAXTHICKT:
00278                 {
00279                         match(MAXTHICKT);
00280                         match(EQUAL);
00281                         if ( inputState->guessing==0 ) {
00282 #line 82 "CLevmarConf.g"
00283                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00284 #line 285 "CLevmarConfParser.cpp"
00285                         }
00286                         { // ( ... )+
00287                         int _cnt100=0;
00288                         for (;;) {
00289                                 if ((LA(1) == NUMBER)) {
00290                                         dtemp=numvalue();
00291                                         if ( inputState->guessing==0 ) {
00292 #line 83 "CLevmarConf.g"
00293                                                 if (i < maxthick.size()) {maxthick.at(i) = dtemp;} else{maxthick.push_back(dtemp);}++i;
00294 #line 295 "CLevmarConfParser.cpp"
00295                                         }
00296                                 }
00297                                 else {
00298                                         if ( _cnt100>=1 ) { goto _loop100; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00299                                 }
00300                                 
00301                                 _cnt100++;
00302                         }
00303                         _loop100:;
00304                         }  // ( ... )+
00305                         break;
00306                 }
00307                 case STARTTHICKT:
00308                 {
00309                         match(STARTTHICKT);
00310                         match(EQUAL);
00311                         if ( inputState->guessing==0 ) {
00312 #line 84 "CLevmarConf.g"
00313                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00314 #line 315 "CLevmarConfParser.cpp"
00315                         }
00316                         { // ( ... )+
00317                         int _cnt106=0;
00318                         for (;;) {
00319                                 if ((LA(1) == NUMBER)) {
00320                                         dtemp=numvalue();
00321                                         if ( inputState->guessing==0 ) {
00322 #line 85 "CLevmarConf.g"
00323                                                 if (i < startthick.size()) {startthick.at(i) = dtemp;} else{startthick.push_back(dtemp);}++i;
00324 #line 325 "CLevmarConfParser.cpp"
00325                                         }
00326                                 }
00327                                 else {
00328                                         if ( _cnt106>=1 ) { goto _loop106; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00329                                 }
00330                                 
00331                                 _cnt106++;
00332                         }
00333                         _loop106:;
00334                         }  // ( ... )+
00335                         break;
00336                 }
00337                 case MINSVELT:
00338                 {
00339                         match(MINSVELT);
00340                         match(EQUAL);
00341                         if ( inputState->guessing==0 ) {
00342 #line 86 "CLevmarConf.g"
00343                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00344 #line 345 "CLevmarConfParser.cpp"
00345                         }
00346                         { // ( ... )+
00347                         int _cnt112=0;
00348                         for (;;) {
00349                                 if ((LA(1) == NUMBER)) {
00350                                         dtemp=numvalue();
00351                                         if ( inputState->guessing==0 ) {
00352 #line 87 "CLevmarConf.g"
00353                                                 if (i < minsvel.size()) {minsvel.at(i) = dtemp;} else{minsvel.push_back(dtemp);}++i;
00354 #line 355 "CLevmarConfParser.cpp"
00355                                         }
00356                                 }
00357                                 else {
00358                                         if ( _cnt112>=1 ) { goto _loop112; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00359                                 }
00360                                 
00361                                 _cnt112++;
00362                         }
00363                         _loop112:;
00364                         }  // ( ... )+
00365                         break;
00366                 }
00367                 case MAXSVELT:
00368                 {
00369                         match(MAXSVELT);
00370                         match(EQUAL);
00371                         if ( inputState->guessing==0 ) {
00372 #line 88 "CLevmarConf.g"
00373                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00374 #line 375 "CLevmarConfParser.cpp"
00375                         }
00376                         { // ( ... )+
00377                         int _cnt118=0;
00378                         for (;;) {
00379                                 if ((LA(1) == NUMBER)) {
00380                                         dtemp=numvalue();
00381                                         if ( inputState->guessing==0 ) {
00382 #line 89 "CLevmarConf.g"
00383                                                 if (i < maxsvel.size()) {maxsvel.at(i) = dtemp;} else{maxsvel.push_back(dtemp);}++i;
00384 #line 385 "CLevmarConfParser.cpp"
00385                                         }
00386                                 }
00387                                 else {
00388                                         if ( _cnt118>=1 ) { goto _loop118; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00389                                 }
00390                                 
00391                                 _cnt118++;
00392                         }
00393                         _loop118:;
00394                         }  // ( ... )+
00395                         break;
00396                 }
00397                 case STARTSVELT:
00398                 {
00399                         match(STARTSVELT);
00400                         match(EQUAL);
00401                         if ( inputState->guessing==0 ) {
00402 #line 90 "CLevmarConf.g"
00403                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00404 #line 405 "CLevmarConfParser.cpp"
00405                         }
00406                         { // ( ... )+
00407                         int _cnt124=0;
00408                         for (;;) {
00409                                 if ((LA(1) == NUMBER)) {
00410                                         dtemp=numvalue();
00411                                         if ( inputState->guessing==0 ) {
00412 #line 91 "CLevmarConf.g"
00413                                                 if (i < startsvel.size()) {startsvel.at(i) = dtemp;} else{startsvel.push_back(dtemp);}++i;
00414 #line 415 "CLevmarConfParser.cpp"
00415                                         }
00416                                 }
00417                                 else {
00418                                         if ( _cnt124>=1 ) { goto _loop124; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00419                                 }
00420                                 
00421                                 _cnt124++;
00422                         }
00423                         _loop124:;
00424                         }  // ( ... )+
00425                         break;
00426                 }
00427                 case MINDENST:
00428                 {
00429                         match(MINDENST);
00430                         match(EQUAL);
00431                         if ( inputState->guessing==0 ) {
00432 #line 92 "CLevmarConf.g"
00433                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00434 #line 435 "CLevmarConfParser.cpp"
00435                         }
00436                         { // ( ... )+
00437                         int _cnt130=0;
00438                         for (;;) {
00439                                 if ((LA(1) == NUMBER)) {
00440                                         dtemp=numvalue();
00441                                         if ( inputState->guessing==0 ) {
00442 #line 93 "CLevmarConf.g"
00443                                                 if (i < mindens.size()) {mindens.at(i) = dtemp;} else{mindens.push_back(dtemp);}++i;
00444 #line 445 "CLevmarConfParser.cpp"
00445                                         }
00446                                 }
00447                                 else {
00448                                         if ( _cnt130>=1 ) { goto _loop130; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00449                                 }
00450                                 
00451                                 _cnt130++;
00452                         }
00453                         _loop130:;
00454                         }  // ( ... )+
00455                         break;
00456                 }
00457                 case MAXDENST:
00458                 {
00459                         match(MAXDENST);
00460                         match(EQUAL);
00461                         if ( inputState->guessing==0 ) {
00462 #line 94 "CLevmarConf.g"
00463                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00464 #line 465 "CLevmarConfParser.cpp"
00465                         }
00466                         { // ( ... )+
00467                         int _cnt136=0;
00468                         for (;;) {
00469                                 if ((LA(1) == NUMBER)) {
00470                                         dtemp=numvalue();
00471                                         if ( inputState->guessing==0 ) {
00472 #line 95 "CLevmarConf.g"
00473                                                 if (i < maxdens.size()) {maxdens.at(i) = dtemp;} else{maxdens.push_back(dtemp);}++i;
00474 #line 475 "CLevmarConfParser.cpp"
00475                                         }
00476                                 }
00477                                 else {
00478                                         if ( _cnt136>=1 ) { goto _loop136; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00479                                 }
00480                                 
00481                                 _cnt136++;
00482                         }
00483                         _loop136:;
00484                         }  // ( ... )+
00485                         break;
00486                 }
00487                 case STARTDENST:
00488                 {
00489                         match(STARTDENST);
00490                         match(EQUAL);
00491                         if ( inputState->guessing==0 ) {
00492 #line 96 "CLevmarConf.g"
00493                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00494 #line 495 "CLevmarConfParser.cpp"
00495                         }
00496                         { // ( ... )+
00497                         int _cnt142=0;
00498                         for (;;) {
00499                                 if ((LA(1) == NUMBER)) {
00500                                         dtemp=numvalue();
00501                                         if ( inputState->guessing==0 ) {
00502 #line 97 "CLevmarConf.g"
00503                                                 if (i < startdens.size()) {startdens.at(i) = dtemp;} else{startdens.push_back(dtemp);}++i;
00504 #line 505 "CLevmarConfParser.cpp"
00505                                         }
00506                                 }
00507                                 else {
00508                                         if ( _cnt142>=1 ) { goto _loop142; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00509                                 }
00510                                 
00511                                 _cnt142++;
00512                         }
00513                         _loop142:;
00514                         }  // ( ... )+
00515                         break;
00516                 }
00517                 case WEIGHTST:
00518                 {
00519                         match(WEIGHTST);
00520                         match(EQUAL);
00521                         if ( inputState->guessing==0 ) {
00522 #line 98 "CLevmarConf.g"
00523                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00524 #line 525 "CLevmarConfParser.cpp"
00525                         }
00526                         { // ( ... )+
00527                         int _cnt148=0;
00528                         for (;;) {
00529                                 if ((LA(1) == NUMBER)) {
00530                                         dtemp=numvalue();
00531                                         if ( inputState->guessing==0 ) {
00532 #line 99 "CLevmarConf.g"
00533                                                 if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
00534 #line 535 "CLevmarConfParser.cpp"
00535                                         }
00536                                 }
00537                                 else {
00538                                         if ( _cnt148>=1 ) { goto _loop148; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00539                                 }
00540                                 
00541                                 _cnt148++;
00542                         }
00543                         _loop148:;
00544                         }  // ( ... )+
00545                         break;
00546                 }
00547                 default:
00548                 {
00549                         throw antlr::NoViableAltException(LT(1), getFilename());
00550                 }
00551                 }
00552                 }
00553         }
00554         catch (antlr::RecognitionException& ex) {
00555                 if( inputState->guessing == 0 ) {
00556                         reportError(ex);
00557                         recover(ex,_tokenSet_0);
00558                 } else {
00559                         throw;
00560                 }
00561         }
00562 }

Here is the call graph for this function:

double CLevmarConfParser::numvalue (  ) 

Definition at line 564 of file CLevmarConfParser.cpp.

References NUMBER.

Referenced by configentry().

00564                                     {
00565 #line 106 "CLevmarConf.g"
00566         double r;
00567 #line 568 "CLevmarConfParser.cpp"
00568         antlr::RefToken  currvalue = antlr::nullToken;
00569         
00570         try {      // for error handling
00571                 currvalue = LT(1);
00572                 match(NUMBER);
00573                 if ( inputState->guessing==0 ) {
00574 #line 107 "CLevmarConf.g"
00575                         r = atof(currvalue->getText().c_str());
00576 #line 577 "CLevmarConfParser.cpp"
00577                 }
00578         }
00579         catch (antlr::RecognitionException& ex) {
00580                 if( inputState->guessing == 0 ) {
00581                         reportError(ex);
00582                         recover(ex,_tokenSet_1);
00583                 } else {
00584                         throw;
00585                 }
00586         }
00587         return r;
00588 }

std::string CLevmarConfParser::stringvalue (  ) 

Definition at line 590 of file CLevmarConfParser.cpp.

References STRING.

Referenced by configentry().

00590                                           {
00591 #line 114 "CLevmarConf.g"
00592         std::string r;
00593 #line 594 "CLevmarConfParser.cpp"
00594         antlr::RefToken  currvalue = antlr::nullToken;
00595         
00596         try {      // for error handling
00597                 currvalue = LT(1);
00598                 match(STRING);
00599                 if ( inputState->guessing==0 ) {
00600 #line 115 "CLevmarConf.g"
00601                         r = currvalue->getText();
00602 #line 603 "CLevmarConfParser.cpp"
00603                 }
00604         }
00605         catch (antlr::RecognitionException& ex) {
00606                 if( inputState->guessing == 0 ) {
00607                         reportError(ex);
00608                         recover(ex,_tokenSet_0);
00609                 } else {
00610                         throw;
00611                 }
00612         }
00613         return r;
00614 }

void CLevmarConfParser::configfile (  ) 

Definition at line 616 of file CLevmarConfParser.cpp.

References COMMENT, configentry(), and EQUAL.

Referenced by CLevmarConf::GetData().

00616                                    {
00617 #line 101 "CLevmarConf.g"
00618         
00619         
00620 #line 621 "CLevmarConfParser.cpp"
00621         
00622         try {      // for error handling
00623                 { // ( ... )+
00624                 int _cnt152=0;
00625                 for (;;) {
00626                         if ((_tokenSet_2.member(LA(1)))) {
00627                                 configentry();
00628                                 {
00629                                 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)))) {
00630                                         match(COMMENT);
00631                                 }
00632                                 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)))) {
00633                                 }
00634                                 else {
00635                                         throw antlr::NoViableAltException(LT(1), getFilename());
00636                                 }
00637                                 
00638                                 }
00639                         }
00640                         else {
00641                                 if ( _cnt152>=1 ) { goto _loop152; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00642                         }
00643                         
00644                         _cnt152++;
00645                 }
00646                 _loop152:;
00647                 }  // ( ... )+
00648                 { // ( ... )*
00649                 for (;;) {
00650                         if ((LA(1) == COMMENT)) {
00651                                 match(COMMENT);
00652                         }
00653                         else {
00654                                 goto _loop154;
00655                         }
00656                         
00657                 }
00658                 _loop154:;
00659                 } // ( ... )*
00660                 match(antlr::Token::EOF_TYPE);
00661         }
00662         catch (antlr::RecognitionException& ex) {
00663                 if( inputState->guessing == 0 ) {
00664                         reportError(ex);
00665                         recover(ex,_tokenSet_6);
00666                 } else {
00667                         throw;
00668                 }
00669         }
00670 }

Here is the call graph for this function:

bool CLevmarConfParser::boolvalue (  ) 

Definition at line 672 of file CLevmarConfParser.cpp.

References FALSE, and TRUE.

00672                                    {
00673 #line 110 "CLevmarConf.g"
00674         bool r;
00675 #line 676 "CLevmarConfParser.cpp"
00676         
00677         try {      // for error handling
00678                 {
00679                 switch ( LA(1)) {
00680                 case TRUE:
00681                 {
00682                         match(TRUE);
00683                         if ( inputState->guessing==0 ) {
00684 #line 111 "CLevmarConf.g"
00685                                 r = true;
00686 #line 687 "CLevmarConfParser.cpp"
00687                         }
00688                         break;
00689                 }
00690                 case FALSE:
00691                 {
00692                         match(FALSE);
00693                         if ( inputState->guessing==0 ) {
00694 #line 111 "CLevmarConf.g"
00695                                 r = false;
00696 #line 697 "CLevmarConfParser.cpp"
00697                         }
00698                         break;
00699                 }
00700                 default:
00701                 {
00702                         throw antlr::NoViableAltException(LT(1), getFilename());
00703                 }
00704                 }
00705                 }
00706         }
00707         catch (antlr::RecognitionException& ex) {
00708                 if( inputState->guessing == 0 ) {
00709                         reportError(ex);
00710                         recover(ex,_tokenSet_6);
00711                 } else {
00712                         throw;
00713                 }
00714         }
00715         return r;
00716 }

antlr::RefAST CLevmarConfParser::getAST (  )  [inline]

Definition at line 86 of file CLevmarConfParser.hpp.

00087         {
00088                 return returnAST;
00089         }

Member Data Documentation

int CLevmarConfParser::maxiter

Definition at line 25 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::string CLevmarConfParser::mode

Definition at line 26 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::string CLevmarConfParser::mtfit

Definition at line 27 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::string CLevmarConfParser::mtinputdata

Definition at line 28 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::string CLevmarConfParser::recinputdata

Definition at line 29 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::slowness

Definition at line 30 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::omega

Definition at line 31 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::sigma

Definition at line 32 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

int CLevmarConfParser::shift

Definition at line 33 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::wlevel

Definition at line 34 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::poisson

Definition at line 35 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::starttime

Definition at line 36 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::endtime

Definition at line 37 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::tensorerror

Definition at line 38 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::phaseerror

Definition at line 39 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::reserror

Definition at line 40 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

double CLevmarConfParser::recerror

Definition at line 41 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::minres

Definition at line 42 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::maxres

Definition at line 43 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::startres

Definition at line 44 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::minthick

Definition at line 45 of file CLevmarConfParser.hpp.

Referenced by configentry(), and CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::maxthick

Definition at line 46 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::startthick

Definition at line 47 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::minsvel

Definition at line 48 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::maxsvel

Definition at line 49 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::startsvel

Definition at line 50 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::mindens

Definition at line 51 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::maxdens

Definition at line 52 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::startdens

Definition at line 53 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

std::vector< double > CLevmarConfParser::weights

Definition at line 54 of file CLevmarConfParser.hpp.

Referenced by CLevmarConf::GetData().

antlr::RefAST CLevmarConfParser::returnAST [protected]

Definition at line 92 of file CLevmarConfParser.hpp.

The documentation for this class was generated from the following files:
Generated on Thu Nov 22 14:07:35 2007 for GPLIB++ by  doxygen 1.5.1