CPTensorConfParser.cpp

Go to the documentation of this file.

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

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

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

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

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

void CPTensorConfParser::configentry() {
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case SCALEFACTORT:
                {
                        match(SCALEFACTORT);
                        match(EQUAL);
                        scalefactor=numvalue();
                        break;
                }
                case NORMALIZET:
                {
                        match(NORMALIZET);
                        match(EQUAL);
                        normalize=boolvalue();
                        break;
                }
                case WRITETENSORT:
                {
                        match(WRITETENSORT);
                        match(EQUAL);
                        writetensor=boolvalue();
                        break;
                }
                case WRITESERIALPARALLELT:
                {
                        match(WRITESERIALPARALLELT);
                        match(EQUAL);
                        writeserialparallel=boolvalue();
                        break;
                }
                case CALCERRT:
                {
                        match(CALCERRT);
                        match(EQUAL);
                        calcerr=boolvalue();
                        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  CPTensorConfParser::numvalue() {
#line 48 "CPTensorConf.g"
        double r;
#line 94 "CPTensorConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(NUMBER);
                if ( inputState->guessing==0 ) {
#line 49 "CPTensorConf.g"
                        r = atof(currvalue->getText().c_str());
#line 103 "CPTensorConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_0);
                } else {
                        throw;
                }
        }
        return r;
}

bool  CPTensorConfParser::boolvalue() {
#line 52 "CPTensorConf.g"
        bool r;
#line 120 "CPTensorConfParser.cpp"
        
        try {      // for error handling
                {
                switch ( LA(1)) {
                case TRUE:
                {
                        match(TRUE);
                        if ( inputState->guessing==0 ) {
#line 53 "CPTensorConf.g"
                                r = true;
#line 131 "CPTensorConfParser.cpp"
                        }
                        break;
                }
                case FALSE:
                {
                        match(FALSE);
                        if ( inputState->guessing==0 ) {
#line 53 "CPTensorConf.g"
                                r = false;
#line 141 "CPTensorConfParser.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 CPTensorConfParser::configfile() {
#line 38 "CPTensorConf.g"
        
        scalefactor = 5;
        normalize = true;
        writetensor = false;
        writeserialparallel = false;
        calcerr = false;
        
#line 172 "CPTensorConfParser.cpp"
        
        try {      // for error handling
                { // ( ... )+
                int _cnt18=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 ( _cnt18>=1 ) { goto _loop18; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
                        }
                        
                        _cnt18++;
                }
                _loop18:;
                }  // ( ... )+
                { // ( ... )*
                for (;;) {
                        if ((LA(1) == COMMENT)) {
                                match(COMMENT);
                        }
                        else {
                                goto _loop20;
                        }
                        
                }
                _loop20:;
                } // ( ... )*
                match(antlr::Token::EOF_TYPE);
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_7);
                } else {
                        throw;
                }
        }
}

std::string  CPTensorConfParser::stringvalue() {
#line 56 "CPTensorConf.g"
        std::string r;
#line 227 "CPTensorConfParser.cpp"
        antlr::RefToken  currvalue = antlr::nullToken;
        
        try {      // for error handling
                currvalue = LT(1);
                match(STRING);
                if ( inputState->guessing==0 ) {
#line 57 "CPTensorConf.g"
                        r = currvalue->getText();
#line 236 "CPTensorConfParser.cpp"
                }
        }
        catch (antlr::RecognitionException& ex) {
                if( inputState->guessing == 0 ) {
                        reportError(ex);
                        recover(ex,_tokenSet_7);
                } else {
                        throw;
                }
        }
        return r;
}

void CPTensorConfParser::initializeASTFactory( antlr::ASTFactory& )
{
}
const char* CPTensorConfParser::tokenNames[] = {
        "<0>",
        "EOF",
        "<2>",
        "NULL_TREE_LOOKAHEAD",
        "SCALEFACTORT",
        "EQUAL",
        "NUMBER",
        "NORMALIZET",
        "WRITETENSORT",
        "WRITESERIALPARALLELT",
        "CALCERRT",
        "COMMENT",
        "TRUE",
        "FALSE",
        "STRING",
        "WS",
        "NEWLINE",
        "REAL",
        "INT",
        "DIGIT",
        "CHAR",
        "OTHER",
        0
};

const unsigned long CPTensorConfParser::_tokenSet_0_data_[] = { 3986UL, 0UL, 0UL, 0UL };
// EOF SCALEFACTORT NORMALIZET WRITETENSORT WRITESERIALPARALLELT CALCERRT 
// COMMENT 
const antlr::BitSet CPTensorConfParser::_tokenSet_0(_tokenSet_0_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_1_data_[] = { 1936UL, 0UL, 0UL, 0UL };
// SCALEFACTORT NORMALIZET WRITETENSORT WRITESERIALPARALLELT CALCERRT 
const antlr::BitSet CPTensorConfParser::_tokenSet_1(_tokenSet_1_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_2_data_[] = { 14402UL, 0UL, 0UL, 0UL };
// EOF NUMBER COMMENT TRUE FALSE 
const antlr::BitSet CPTensorConfParser::_tokenSet_2(_tokenSet_2_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_3_data_[] = { 4018UL, 0UL, 0UL, 0UL };
// EOF SCALEFACTORT EQUAL NORMALIZET WRITETENSORT WRITESERIALPARALLELT 
// CALCERRT COMMENT 
const antlr::BitSet CPTensorConfParser::_tokenSet_3(_tokenSet_3_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_4_data_[] = { 14434UL, 0UL, 0UL, 0UL };
// EOF EQUAL NUMBER COMMENT TRUE FALSE 
const antlr::BitSet CPTensorConfParser::_tokenSet_4(_tokenSet_4_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_5_data_[] = { 16338UL, 0UL, 0UL, 0UL };
// EOF SCALEFACTORT NUMBER NORMALIZET WRITETENSORT WRITESERIALPARALLELT 
// CALCERRT COMMENT TRUE FALSE 
const antlr::BitSet CPTensorConfParser::_tokenSet_5(_tokenSet_5_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_6_data_[] = { 16370UL, 0UL, 0UL, 0UL };
// EOF SCALEFACTORT EQUAL NUMBER NORMALIZET WRITETENSORT WRITESERIALPARALLELT 
// CALCERRT COMMENT TRUE FALSE 
const antlr::BitSet CPTensorConfParser::_tokenSet_6(_tokenSet_6_data_,4);
const unsigned long CPTensorConfParser::_tokenSet_7_data_[] = { 2UL, 0UL, 0UL, 0UL };
// EOF 
const antlr::BitSet CPTensorConfParser::_tokenSet_7(_tokenSet_7_data_,4);

---