MakeInputConfParser.cpp

Go to the documentation of this file.

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

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

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

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

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

void MakeInputConfParser::configentry() {
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                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 CCT:
                {
                        match(CCT);
                        match(EQUAL);
                        cc=numvalue();
                        break;
                }
                case POISSONT:
                {
                        match(POISSONT);
                        match(EQUAL);
                        poisson=numvalue();
                        break;
                }
                case NLAYERST:
                {
                        match(NLAYERST);
                        match(EQUAL);
                        nlayers=numvalue();
                        break;
                }
                case OUTPUTBASET:
                {
                        match(OUTPUTBASET);
                        match(EQUAL);
                        outputbase=stringvalue();
                        break;
                }
                case CORRELATEDT:
                {
                        match(CORRELATEDT);
                        match(EQUAL);
                        correlated=boolvalue();
                        break;
                }
                case DTT:
                {
                        match(DTT);
                        match(EQUAL);
                        dt=numvalue();
                        break;
                }
                case NPTST:
                {
                        match(NPTST);
                        match(EQUAL);
                        npts=numvalue();
                        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  MakeInputConfParser::numvalue() {
#line 55 "MakeInputConf.g"
        double r;
#line 136 "MakeInputConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(NUMBER);
                if ( inputState->guessing==0 ) {
#line 56 "MakeInputConf.g"
                        r = atof(currvalue->getText().c_str());
#line 145 "MakeInputConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

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

bool  MakeInputConfParser::boolvalue() {
#line 59 "MakeInputConf.g"
        bool r;
#line 188 "MakeInputConfParser.cpp"
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case TRUE:
                {
                        match(TRUE);
                        if ( inputState->guessing==0 ) {
#line 60 "MakeInputConf.g"
                                r = true;
#line 199 "MakeInputConfParser.cpp"
                        }
                        break;
                }
                case FALSE:
                {
                        match(FALSE);
                        if ( inputState->guessing==0 ) {
#line 60 "MakeInputConf.g"
                                r = false;
#line 209 "MakeInputConfParser.cpp"
                        }
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltException(LT(1), getFilename());
                }
                }
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

void MakeInputConfParser::configfile() {
#line 50 "MakeInputConf.g"
        
        
#line 235 "MakeInputConfParser.cpp"
        
        try {      // for error handling
                { // ( ... )+
                int _cnt48=0;
                for (;;) {
                        if ((_tokenSet_1.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_2.member(LA(4))) && (_tokenSet_0.member(LA(5))) && (_tokenSet_3.member(LA(6))) && (_tokenSet_4.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_3.member(LA(9))) && (_tokenSet_6.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_2.member(LA(3))) && (_tokenSet_0.member(LA(4))) && (_tokenSet_3.member(LA(5))) && (_tokenSet_4.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_3.member(LA(8))) && (_tokenSet_6.member(LA(9))) && (_tokenSet_6.member(LA(10)))) {
                                }
                                else {
                                        throw antlr::NoViableAltException(LT(1), getFilename());
                                }
                                
                                }
                        }
                        else {
                                if ( _cnt48>=1 ) { goto _loop48; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt48++;
                }
                _loop48:;
                }  // ( ... )+
                { // ( ... )*
                for (;;) {
                        if ((LA(1) == COMMENT)) {
                                match(COMMENT);
                        }
                        else {
                                goto _loop50;
                        }
                        
                }
                _loop50:;
                } // ( ... )*
                match(antlr::Token::EOF_TYPE);
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_7);
                } else {
                        throw;
                }
        }
}

void MakeInputConfParser::initializeASTFactory( antlr::ASTFactory& )
{
}
const char* MakeInputConfParser::tokenNames[] = {
        "<0>",
        "EOF",
        "<2>",
        "NULL_TREE_LOOKAHEAD",
        "SLOWNESST",
        "EQUAL",
        "NUMBER",
        "OMEGAT",
        "SIGMAT",
        "SHIFTT",
        "CCT",
        "POISSONT",
        "NLAYERST",
        "OUTPUTBASET",
        "STRING",
        "CORRELATEDT",
        "DTT",
        "NPTST",
        "COMMENT",
        "TRUE",
        "FALSE",
        "WS",
        "NEWLINE",
        "REAL",
        "INT",
        "DIGIT",
        "CHAR",
        "OTHER",
        0
};

const unsigned long MakeInputConfParser::_tokenSet_0_data_[] = { 507794UL, 0UL, 0UL, 0UL };
// EOF SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT NLAYERST OUTPUTBASET 
// CORRELATEDT DTT NPTST COMMENT 
const antlr::BitSet MakeInputConfParser::_tokenSet_0(_tokenSet_0_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_1_data_[] = { 245648UL, 0UL, 0UL, 0UL };
// SLOWNESST OMEGAT SIGMAT SHIFTT CCT POISSONT NLAYERST OUTPUTBASET CORRELATEDT 
// DTT NPTST 
const antlr::BitSet MakeInputConfParser::_tokenSet_1(_tokenSet_1_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_2_data_[] = { 1851458UL, 0UL, 0UL, 0UL };
// EOF NUMBER STRING COMMENT TRUE FALSE 
const antlr::BitSet MakeInputConfParser::_tokenSet_2(_tokenSet_2_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_3_data_[] = { 507826UL, 0UL, 0UL, 0UL };
// EOF SLOWNESST EQUAL OMEGAT SIGMAT SHIFTT CCT POISSONT NLAYERST OUTPUTBASET 
// CORRELATEDT DTT NPTST COMMENT 
const antlr::BitSet MakeInputConfParser::_tokenSet_3(_tokenSet_3_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_4_data_[] = { 1851490UL, 0UL, 0UL, 0UL };
// EOF EQUAL NUMBER STRING COMMENT TRUE FALSE 
const antlr::BitSet MakeInputConfParser::_tokenSet_4(_tokenSet_4_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_5_data_[] = { 2097106UL, 0UL, 0UL, 0UL };
// EOF SLOWNESST NUMBER OMEGAT SIGMAT SHIFTT CCT POISSONT NLAYERST OUTPUTBASET 
// STRING CORRELATEDT DTT NPTST COMMENT TRUE FALSE 
const antlr::BitSet MakeInputConfParser::_tokenSet_5(_tokenSet_5_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_6_data_[] = { 2097138UL, 0UL, 0UL, 0UL };
// EOF SLOWNESST EQUAL NUMBER OMEGAT SIGMAT SHIFTT CCT POISSONT NLAYERST 
// OUTPUTBASET STRING CORRELATEDT DTT NPTST COMMENT TRUE FALSE 
const antlr::BitSet MakeInputConfParser::_tokenSet_6(_tokenSet_6_data_,4);
const unsigned long MakeInputConfParser::_tokenSet_7_data_[] = { 2UL, 0UL, 0UL, 0UL };
// EOF 
const antlr::BitSet MakeInputConfParser::_tokenSet_7(_tokenSet_7_data_,4);

---