CLevmarConfParser.cpp

Go to the documentation of this file.

/* $ANTLR 2.7.6 (20070220): "CLevmarConf.g" -> "CLevmarConfParser.cpp"$ */
#include "CLevmarConfParser.hpp"
#include <antlr/NoViableAltException.hpp>
#include <antlr/SemanticException.hpp>
#include <antlr/ASTFactory.hpp>
#line 1 "CLevmarConf.g"
#line 8 "CLevmarConfParser.cpp"
CLevmarConfParser::CLevmarConfParser(antlr::TokenBuffer& tokenBuf, int k)
: antlr::LLkParser(tokenBuf,k)
{
}

CLevmarConfParser::CLevmarConfParser(antlr::TokenBuffer& tokenBuf)
: antlr::LLkParser(tokenBuf,10)
{
}

CLevmarConfParser::CLevmarConfParser(antlr::TokenStream& lexer, int k)
: antlr::LLkParser(lexer,k)
{
}

CLevmarConfParser::CLevmarConfParser(antlr::TokenStream& lexer)
: antlr::LLkParser(lexer,10)
{
}

CLevmarConfParser::CLevmarConfParser(const antlr::ParserSharedInputState& state)
: antlr::LLkParser(state,10)
{
}

void CLevmarConfParser::configentry() {
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case MAXITERT:
                {
                        match(MAXITERT);
                        match(EQUAL);
                        maxiter=numvalue();
                        break;
                }
                case MODET:
                {
                        match(MODET);
                        match(EQUAL);
                        mode=stringvalue();
                        break;
                }
                case MTFITT:
                {
                        match(MTFITT);
                        match(EQUAL);
                        mtfit=stringvalue();
                        break;
                }
                case MTINPUTDATAT:
                {
                        match(MTINPUTDATAT);
                        match(EQUAL);
                        mtinputdata=stringvalue();
                        break;
                }
                case RECINPUTDATAT:
                {
                        match(RECINPUTDATAT);
                        match(EQUAL);
                        recinputdata=stringvalue();
                        break;
                }
                case SLOWNESST:
                {
                        match(SLOWNESST);
                        match(EQUAL);
                        slowness=numvalue();
                        break;
                }
                case OMEGAT:
                {
                        match(OMEGAT);
                        match(EQUAL);
                        omega=numvalue();
                        break;
                }
                case SIGMAT:
                {
                        match(SIGMAT);
                        match(EQUAL);
                        sigma=numvalue();
                        break;
                }
                case SHIFTT:
                {
                        match(SHIFTT);
                        match(EQUAL);
                        shift=numvalue();
                        break;
                }
                case WLEVELT:
                {
                        match(WLEVELT);
                        match(EQUAL);
                        wlevel=numvalue();
                        break;
                }
                case POISSONT:
                {
                        match(POISSONT);
                        match(EQUAL);
                        poisson=numvalue();
                        break;
                }
                case STARTTIMET:
                {
                        match(STARTTIMET);
                        match(EQUAL);
                        starttime=numvalue();
                        break;
                }
                case ENDTIMET:
                {
                        match(ENDTIMET);
                        match(EQUAL);
                        endtime=numvalue();
                        break;
                }
                case TENSORERRORT:
                {
                        match(TENSORERRORT);
                        match(EQUAL);
                        tensorerror=numvalue();
                        break;
                }
                case PHASEERRORT:
                {
                        match(PHASEERRORT);
                        match(EQUAL);
                        phaseerror=numvalue();
                        break;
                }
                case RESERRORT:
                {
                        match(RESERRORT);
                        match(EQUAL);
                        reserror=numvalue();
                        break;
                }
                case RECERRORT:
                {
                        match(RECERRORT);
                        match(EQUAL);
                        recerror=numvalue();
                        break;
                }
                case MINREST:
                {
                        match(MINREST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 74 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 165 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt76=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 75 "CLevmarConf.g"
                                                if (i < minres.size()) {minres.at(i) = dtemp;} else{minres.push_back(dtemp);}++i;
#line 175 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt76>=1 ) { goto _loop76; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt76++;
                        }
                        _loop76:;
                        }  // ( ... )+
                        break;
                }
                case MAXREST:
                {
                        match(MAXREST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 76 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 195 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt82=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 77 "CLevmarConf.g"
                                                if (i < maxres.size()) {maxres.at(i) = dtemp;} else{maxres.push_back(dtemp);}++i;
#line 205 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt82>=1 ) { goto _loop82; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt82++;
                        }
                        _loop82:;
                        }  // ( ... )+
                        break;
                }
                case STARTREST:
                {
                        match(STARTREST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 78 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 225 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt88=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 79 "CLevmarConf.g"
                                                if (i < startres.size()) {startres.at(i) = dtemp;} else{startres.push_back(dtemp);}++i;
#line 235 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt88>=1 ) { goto _loop88; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt88++;
                        }
                        _loop88:;
                        }  // ( ... )+
                        break;
                }
                case MINTHICKT:
                {
                        match(MINTHICKT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 80 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 255 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt94=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 81 "CLevmarConf.g"
                                                if (i < minthick.size()) {minthick.at(i) = dtemp;} else{minthick.push_back(dtemp);}++i;
#line 265 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt94>=1 ) { goto _loop94; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt94++;
                        }
                        _loop94:;
                        }  // ( ... )+
                        break;
                }
                case MAXTHICKT:
                {
                        match(MAXTHICKT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 82 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 285 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt100=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 83 "CLevmarConf.g"
                                                if (i < maxthick.size()) {maxthick.at(i) = dtemp;} else{maxthick.push_back(dtemp);}++i;
#line 295 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt100>=1 ) { goto _loop100; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt100++;
                        }
                        _loop100:;
                        }  // ( ... )+
                        break;
                }
                case STARTTHICKT:
                {
                        match(STARTTHICKT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 84 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 315 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt106=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 85 "CLevmarConf.g"
                                                if (i < startthick.size()) {startthick.at(i) = dtemp;} else{startthick.push_back(dtemp);}++i;
#line 325 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt106>=1 ) { goto _loop106; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt106++;
                        }
                        _loop106:;
                        }  // ( ... )+
                        break;
                }
                case MINSVELT:
                {
                        match(MINSVELT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 86 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 345 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt112=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 87 "CLevmarConf.g"
                                                if (i < minsvel.size()) {minsvel.at(i) = dtemp;} else{minsvel.push_back(dtemp);}++i;
#line 355 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt112>=1 ) { goto _loop112; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt112++;
                        }
                        _loop112:;
                        }  // ( ... )+
                        break;
                }
                case MAXSVELT:
                {
                        match(MAXSVELT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 88 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 375 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt118=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 89 "CLevmarConf.g"
                                                if (i < maxsvel.size()) {maxsvel.at(i) = dtemp;} else{maxsvel.push_back(dtemp);}++i;
#line 385 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt118>=1 ) { goto _loop118; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt118++;
                        }
                        _loop118:;
                        }  // ( ... )+
                        break;
                }
                case STARTSVELT:
                {
                        match(STARTSVELT);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 90 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 405 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt124=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 91 "CLevmarConf.g"
                                                if (i < startsvel.size()) {startsvel.at(i) = dtemp;} else{startsvel.push_back(dtemp);}++i;
#line 415 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt124>=1 ) { goto _loop124; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt124++;
                        }
                        _loop124:;
                        }  // ( ... )+
                        break;
                }
                case MINDENST:
                {
                        match(MINDENST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 92 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 435 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt130=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 93 "CLevmarConf.g"
                                                if (i < mindens.size()) {mindens.at(i) = dtemp;} else{mindens.push_back(dtemp);}++i;
#line 445 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt130>=1 ) { goto _loop130; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt130++;
                        }
                        _loop130:;
                        }  // ( ... )+
                        break;
                }
                case MAXDENST:
                {
                        match(MAXDENST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 94 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 465 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt136=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 95 "CLevmarConf.g"
                                                if (i < maxdens.size()) {maxdens.at(i) = dtemp;} else{maxdens.push_back(dtemp);}++i;
#line 475 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt136>=1 ) { goto _loop136; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt136++;
                        }
                        _loop136:;
                        }  // ( ... )+
                        break;
                }
                case STARTDENST:
                {
                        match(STARTDENST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 96 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 495 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt142=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 97 "CLevmarConf.g"
                                                if (i < startdens.size()) {startdens.at(i) = dtemp;} else{startdens.push_back(dtemp);}++i;
#line 505 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt142>=1 ) { goto _loop142; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt142++;
                        }
                        _loop142:;
                        }  // ( ... )+
                        break;
                }
                case WEIGHTST:
                {
                        match(WEIGHTST);
                        match(EQUAL);
                        if ( inputState->guessing==0 ) {
#line 98 "CLevmarConf.g"
                                i = 0; dtemp = 0; stemp = ""; btemp = false;
#line 525 "CLevmarConfParser.cpp"
                        }
                        { // ( ... )+
                        int _cnt148=0;
                        for (;;) {
                                if ((LA(1) == NUMBER)) {
                                        dtemp=numvalue();
                                        if ( inputState->guessing==0 ) {
#line 99 "CLevmarConf.g"
                                                if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
#line 535 "CLevmarConfParser.cpp"
                                        }
                                }
                                else {
                                        if ( _cnt148>=1 ) { goto _loop148; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                                }
                                
                                _cnt148++;
                        }
                        _loop148:;
                        }  // ( ... )+
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
}

double  CLevmarConfParser::numvalue() {
#line 106 "CLevmarConf.g"
        double r;
#line 568 "CLevmarConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(NUMBER);
                if ( inputState->guessing==0 ) {
#line 107 "CLevmarConf.g"
                        r = atof(currvalue->getText().c_str());
#line 577 "CLevmarConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_1);
                } else {
                        throw;
                }
        }
        return r;
}

std::string  CLevmarConfParser::stringvalue() {
#line 114 "CLevmarConf.g"
        std::string r;
#line 594 "CLevmarConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(STRING);
                if ( inputState->guessing==0 ) {
#line 115 "CLevmarConf.g"
                        r = currvalue->getText();
#line 603 "CLevmarConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

void CLevmarConfParser::configfile() {
#line 101 "CLevmarConf.g"
        
        
#line 621 "CLevmarConfParser.cpp"
        
        try {      // for error handling
                { // ( ... )+
                int _cnt152=0;
                for (;;) {
                        if ((_tokenSet_2.member(LA(1)))) {
                                configentry();
                                {
                                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)))) {
                                        match(COMMENT);
                                }
                                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)))) {
                                }
                                else {
                                        throw antlr::NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                        }
                        else {
                                if ( _cnt152>=1 ) { goto _loop152; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt152++;
                }
                _loop152:;
                }  // ( ... )+
                { // ( ... )*
                for (;;) {
                        if ((LA(1) == COMMENT)) {
                                match(COMMENT);
                        }
                        else {
                                goto _loop154;
                        }
                        
                }
                _loop154:;
                } // ( ... )*
                match(antlr::Token::EOF_TYPE);
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_6);
                } else {
                        throw;
                }
        }
}

bool  CLevmarConfParser::boolvalue() {
#line 110 "CLevmarConf.g"
        bool r;
#line 676 "CLevmarConfParser.cpp"
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case TRUE:
                {
                        match(TRUE);
                        if ( inputState->guessing==0 ) {
#line 111 "CLevmarConf.g"
                                r = true;
#line 687 "CLevmarConfParser.cpp"
                        }
                        break;
                }
                case FALSE:
                {
                        match(FALSE);
                        if ( inputState->guessing==0 ) {
#line 111 "CLevmarConf.g"
                                r = false;
#line 697 "CLevmarConfParser.cpp"
                        }
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_6);
                } else {
                        throw;
                }
        }
        return r;
}

void CLevmarConfParser::initializeASTFactory( antlr::ASTFactory& )
{
}
const char* CLevmarConfParser::tokenNames[] = {
        "<0>",
        "EOF",
        "<2>",
        "NULL_TREE_LOOKAHEAD",
        "MAXITERT",
        "EQUAL",
        "NUMBER",
        "MODET",
        "STRING",
        "MTFITT",
        "MTINPUTDATAT",
        "RECINPUTDATAT",
        "SLOWNESST",
        "OMEGAT",
        "SIGMAT",
        "SHIFTT",
        "WLEVELT",
        "POISSONT",
        "STARTTIMET",
        "ENDTIMET",
        "TENSORERRORT",
        "PHASEERRORT",
        "RESERRORT",
        "RECERRORT",
        "MINREST",
        "MAXREST",
        "STARTREST",
        "MINTHICKT",
        "MAXTHICKT",
        "STARTTHICKT",
        "MINSVELT",
        "MAXSVELT",
        "STARTSVELT",
        "MINDENST",
        "MAXDENST",
        "STARTDENST",
        "WEIGHTST",
        "COMMENT",
        "TRUE",
        "FALSE",
        "WS",
        "NEWLINE",
        "REAL",
        "INT",
        "DIGIT",
        "CHAR",
        "OTHER",
        0
};

const unsigned long CLevmarConfParser::_tokenSet_0_data_[] = { 4294966930UL, 63UL, 0UL, 0UL };
// EOF MAXITERT MODET MTFITT MTINPUTDATAT RECINPUTDATAT SLOWNESST OMEGAT 
// SIGMAT SHIFTT WLEVELT POISSONT STARTTIMET ENDTIMET TENSORERRORT PHASEERRORT 
// RESERRORT RECERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT STARTTHICKT 
// MINSVELT MAXSVELT STARTSVELT MINDENST MAXDENST STARTDENST WEIGHTST COMMENT 
const antlr::BitSet CLevmarConfParser::_tokenSet_0(_tokenSet_0_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_1_data_[] = { 4294966994UL, 63UL, 0UL, 0UL };
// EOF MAXITERT NUMBER MODET MTFITT MTINPUTDATAT RECINPUTDATAT SLOWNESST 
// OMEGAT SIGMAT SHIFTT WLEVELT POISSONT STARTTIMET ENDTIMET TENSORERRORT 
// PHASEERRORT RESERRORT RECERRORT MINREST MAXREST STARTREST MINTHICKT 
// MAXTHICKT STARTTHICKT MINSVELT MAXSVELT STARTSVELT MINDENST MAXDENST 
// STARTDENST WEIGHTST COMMENT 
const antlr::BitSet CLevmarConfParser::_tokenSet_1(_tokenSet_1_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_2_data_[] = { 4294966928UL, 31UL, 0UL, 0UL };
// MAXITERT MODET MTFITT MTINPUTDATAT RECINPUTDATAT SLOWNESST OMEGAT SIGMAT 
// SHIFTT WLEVELT POISSONT STARTTIMET ENDTIMET TENSORERRORT PHASEERRORT 
// RESERRORT RECERRORT MINREST MAXREST STARTREST MINTHICKT MAXTHICKT STARTTHICKT 
// MINSVELT MAXSVELT STARTSVELT MINDENST MAXDENST STARTDENST WEIGHTST 
const antlr::BitSet CLevmarConfParser::_tokenSet_2(_tokenSet_2_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_3_data_[] = { 322UL, 32UL, 0UL, 0UL };
// EOF NUMBER STRING COMMENT 
const antlr::BitSet CLevmarConfParser::_tokenSet_3(_tokenSet_3_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_4_data_[] = { 4294967026UL, 63UL, 0UL, 0UL };
// EOF MAXITERT EQUAL NUMBER MODET MTFITT MTINPUTDATAT RECINPUTDATAT SLOWNESST 
// OMEGAT SIGMAT SHIFTT WLEVELT POISSONT STARTTIMET ENDTIMET TENSORERRORT 
// PHASEERRORT RESERRORT RECERRORT MINREST MAXREST STARTREST MINTHICKT 
// MAXTHICKT STARTTHICKT MINSVELT MAXSVELT STARTSVELT MINDENST MAXDENST 
// STARTDENST WEIGHTST COMMENT 
const antlr::BitSet CLevmarConfParser::_tokenSet_4(_tokenSet_4_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_5_data_[] = { 4294967282UL, 63UL, 0UL, 0UL };
// EOF MAXITERT EQUAL NUMBER MODET STRING MTFITT MTINPUTDATAT RECINPUTDATAT 
// SLOWNESST OMEGAT SIGMAT SHIFTT WLEVELT POISSONT STARTTIMET ENDTIMET 
// TENSORERRORT PHASEERRORT RESERRORT RECERRORT MINREST MAXREST STARTREST 
// MINTHICKT MAXTHICKT STARTTHICKT MINSVELT MAXSVELT STARTSVELT MINDENST 
// MAXDENST STARTDENST WEIGHTST COMMENT 
const antlr::BitSet CLevmarConfParser::_tokenSet_5(_tokenSet_5_data_,4);
const unsigned long CLevmarConfParser::_tokenSet_6_data_[] = { 2UL, 0UL, 0UL, 0UL };
// EOF 
const antlr::BitSet CLevmarConfParser::_tokenSet_6(_tokenSet_6_data_,4);

---