CPTensorConfLexer Class Reference

#include <CPTensorConfLexer.hpp>

Inheritance diagram for CPTensorConfLexer:

[legend]Collaboration diagram for CPTensorConfLexer:

[legend]List of all members.

Public Member Functions
bool	getCaseSensitiveLiterals () const
	CPTensorConfLexer (std::istream &in)
	CPTensorConfLexer (antlr::InputBuffer &ib)
	CPTensorConfLexer (const antlr::LexerSharedInputState &state)
antlr::RefToken	nextToken ()
void	mEQUAL (bool _createToken)
void	mTRUE (bool _createToken)
void	mFALSE (bool _createToken)
void	mWS (bool _createToken)
void	mSTRING (bool _createToken)
void	mNUMBER (bool _createToken)
void	mCOMMENT (bool _createToken)
void	mSCALEFACTORT (bool _createToken)
void	mNORMALIZET (bool _createToken)
void	mWRITETENSORT (bool _createToken)
void	mWRITESERIALPARALLELT (bool _createToken)
void	mCALCERRT (bool _createToken)
Protected Member Functions
void	mNEWLINE (bool _createToken)
void	mCHAR (bool _createToken)
void	mDIGIT (bool _createToken)
void	mOTHER (bool _createToken)
void	mREAL (bool _createToken)
void	mINT (bool _createToken)

---

Detailed Description

Definition at line 18 of file CPTensorConfLexer.hpp.

---

Constructor & Destructor Documentation

CPTensorConfLexer::CPTensorConfLexer

(

std::istream &

in

)

Definition at line 13 of file CPTensorConfLexer.cpp.

        : antlr::CharScanner(new antlr::CharBuffer(in),false)
{
        initLiterals();
}

CPTensorConfLexer::CPTensorConfLexer

(

antlr::InputBuffer &

ib

)

Definition at line 19 of file CPTensorConfLexer.cpp.

        : antlr::CharScanner(ib,false)
{
        initLiterals();
}

CPTensorConfLexer::CPTensorConfLexer

(

const antlr::LexerSharedInputState &

state

)

Definition at line 25 of file CPTensorConfLexer.cpp.

        : antlr::CharScanner(state,false)
{
        initLiterals();
}

---

Member Function Documentation

bool CPTensorConfLexer::getCaseSensitiveLiterals

(

)

const [inline]

Definition at line 25 of file CPTensorConfLexer.hpp.

        {
                return true;
        }

antlr::RefToken CPTensorConfLexer::nextToken

(

)

Definition at line 35 of file CPTensorConfLexer.cpp.

References mCALCERRT(), mCOMMENT(), mEQUAL(), mFALSE(), mNORMALIZET(), mNUMBER(), mSCALEFACTORT(), mSTRING(), mTRUE(), mWRITESERIALPARALLELT(), mWRITETENSORT(), and mWS().

{
        antlr::RefToken theRetToken;
        for (;;) {
                antlr::RefToken theRetToken;
                int _ttype = antlr::Token::INVALID_TYPE;
                resetText();
                try {   // for lexical and char stream error handling
                        switch ( LA(1)) {
                        case 0x3d /* '=' */ :
                        {
                                mEQUAL(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x9 /* '\t' */ :
                        case 0xa /* '\n' */ :
                        case 0xd /* '\r' */ :
                        case 0x20 /* ' ' */ :
                        {
                                mWS(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x2b /* '+' */ :
                        case 0x2d /* '-' */ :
                        case 0x2e /* '.' */ :
                        case 0x30 /* '0' */ :
                        case 0x31 /* '1' */ :
                        case 0x32 /* '2' */ :
                        case 0x33 /* '3' */ :
                        case 0x34 /* '4' */ :
                        case 0x35 /* '5' */ :
                        case 0x36 /* '6' */ :
                        case 0x37 /* '7' */ :
                        case 0x38 /* '8' */ :
                        case 0x39 /* '9' */ :
                        {
                                mNUMBER(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x2f /* '/' */ :
                        {
                                mCOMMENT(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        default:
                                if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x63 /* 'c' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x66 /* 'f' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x63 /* 'c' */ ) && (LA(9) == 0x74 /* 't' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
                                        mSCALEFACTORT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
                                        mWRITETENSORT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x69 /* 'i' */ ) && (LA(10) == 0x61 /* 'a' */ )) {
                                        mWRITESERIALPARALLELT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x6e /* 'n' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x6d /* 'm' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x7a /* 'z' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
                                        mNORMALIZET(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (true) && (true) && (true)) {
                                        mCALCERRT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true)) {
                                        mFALSE(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mTRUE(true);
                                        theRetToken=_returnToken;
                                }
                                else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mSTRING(true);
                                        theRetToken=_returnToken;
                                }
                        else {
                                if (LA(1)==EOF_CHAR)
                                {
                                        uponEOF();
                                        _returnToken = makeToken(antlr::Token::EOF_TYPE);
                                }
                                else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                        }
                        }
                        if ( !_returnToken )
                                goto tryAgain; // found SKIP token

                        _ttype = _returnToken->getType();
                        _ttype = testLiteralsTable(_ttype);
                        _returnToken->setType(_ttype);
                        return _returnToken;
                }
                catch (antlr::RecognitionException& e) {
                                throw antlr::TokenStreamRecognitionException(e);
                }
                catch (antlr::CharStreamIOException& csie) {
                        throw antlr::TokenStreamIOException(csie.io);
                }
                catch (antlr::CharStreamException& cse) {
                        throw antlr::TokenStreamException(cse.getMessage());
                }
tryAgain:;
        }
}

Here is the call graph for this function:

void CPTensorConfLexer::mEQUAL

(

bool

_createToken

)

Definition at line 146 of file CPTensorConfLexer.cpp.

References EQUAL.

Referenced by nextToken().

                                                {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = EQUAL;
        std::string::size_type _saveIndex;
        
        match('=' /* charlit */ );
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mTRUE

(

bool

_createToken

)

Definition at line 160 of file CPTensorConfLexer.cpp.

References TRUE.

Referenced by nextToken().

                                               {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = TRUE;
        std::string::size_type _saveIndex;
        
        match("true");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mFALSE

(

bool

_createToken

)

Definition at line 174 of file CPTensorConfLexer.cpp.

References FALSE.

Referenced by nextToken().

                                                {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = FALSE;
        std::string::size_type _saveIndex;
        
        match("false");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mWS

(

bool

_createToken

)

Definition at line 188 of file CPTensorConfLexer.cpp.

References mNEWLINE(), and WS.

Referenced by nextToken().

                                             {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = WS;
        std::string::size_type _saveIndex;
        
        { // ( ... )+
        int _cnt30=0;
        for (;;) {
                switch ( LA(1)) {
                case 0x20 /* ' ' */ :
                {
                        match(' ' /* charlit */ );
                        break;
                }
                case 0xa /* '\n' */ :
                case 0xd /* '\r' */ :
                {
                        mNEWLINE(false);
                        break;
                }
                case 0x9 /* '\t' */ :
                {
                        match('\t' /* charlit */ );
                        break;
                }
                default:
                {
                        if ( _cnt30>=1 ) { goto _loop30; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                }
                _cnt30++;
        }
        _loop30:;
        }  // ( ... )+
        if ( inputState->guessing==0 ) {
#line 77 "CPTensorConf.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 226 "CPTensorConfLexer.cpp"
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mNEWLINE

(

bool

_createToken

)

[protected]

Definition at line 235 of file CPTensorConfLexer.cpp.

References NEWLINE.

Referenced by mCOMMENT(), and mWS().

                                                  {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = NEWLINE;
        std::string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0xa /* '\n' */ :
        {
                match('\n' /* charlit */ );
                break;
        }
        case 0xd /* '\r' */ :
        {
                match('\r' /* charlit */ );
                match('\n' /* charlit */ );
                break;
        }
        default:
        {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( inputState->guessing==0 ) {
#line 103 "CPTensorConf.g"
                newline();
#line 263 "CPTensorConfLexer.cpp"
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mSTRING

(

bool

_createToken

)

Definition at line 272 of file CPTensorConfLexer.cpp.

References mCHAR(), mDIGIT(), mOTHER(), and STRING.

Referenced by nextToken().

                                                 {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = STRING;
        std::string::size_type _saveIndex;
        
        mCHAR(false);
        { // ( ... )*
        for (;;) {
                switch ( LA(1)) {
                case 0x61 /* 'a' */ :
                case 0x62 /* 'b' */ :
                case 0x63 /* 'c' */ :
                case 0x64 /* 'd' */ :
                case 0x65 /* 'e' */ :
                case 0x66 /* 'f' */ :
                case 0x67 /* 'g' */ :
                case 0x68 /* 'h' */ :
                case 0x69 /* 'i' */ :
                case 0x6a /* 'j' */ :
                case 0x6b /* 'k' */ :
                case 0x6c /* 'l' */ :
                case 0x6d /* 'm' */ :
                case 0x6e /* 'n' */ :
                case 0x6f /* 'o' */ :
                case 0x70 /* 'p' */ :
                case 0x71 /* 'q' */ :
                case 0x72 /* 'r' */ :
                case 0x73 /* 's' */ :
                case 0x74 /* 't' */ :
                case 0x75 /* 'u' */ :
                case 0x76 /* 'v' */ :
                case 0x77 /* 'w' */ :
                case 0x78 /* 'x' */ :
                case 0x79 /* 'y' */ :
                case 0x7a /* 'z' */ :
                {
                        mCHAR(false);
                        break;
                }
                case 0x30 /* '0' */ :
                case 0x31 /* '1' */ :
                case 0x32 /* '2' */ :
                case 0x33 /* '3' */ :
                case 0x34 /* '4' */ :
                case 0x35 /* '5' */ :
                case 0x36 /* '6' */ :
                case 0x37 /* '7' */ :
                case 0x38 /* '8' */ :
                case 0x39 /* '9' */ :
                {
                        mDIGIT(false);
                        break;
                }
                case 0x23 /* '#' */ :
                case 0x24 /* '$' */ :
                case 0x25 /* '%' */ :
                case 0x26 /* '&' */ :
                case 0x27 /* '\'' */ :
                case 0x28 /* '(' */ :
                case 0x29 /* ')' */ :
                case 0x2a /* '*' */ :
                case 0x2b /* '+' */ :
                case 0x2c /* ',' */ :
                case 0x2d /* '-' */ :
                case 0x2e /* '.' */ :
                case 0x2f /* '/' */ :
                case 0x3a /* ':' */ :
                case 0x3b /* ';' */ :
                case 0x3c /* '<' */ :
                case 0x3f /* '?' */ :
                case 0x40 /* '@' */ :
                case 0x5b /* '[' */ :
                case 0x5d /* ']' */ :
                case 0x5e /* '^' */ :
                case 0x5f /* '_' */ :
                case 0x7b /* '{' */ :
                case 0x7c /* '|' */ :
                case 0x7d /* '}' */ :
                case 0x7e /* '~' */ :
                {
                        mOTHER(false);
                        break;
                }
                default:
                {
                        goto _loop33;
                }
                }
        }
        _loop33:;
        } // ( ... )*
        _ttype = testLiteralsTable(_ttype);
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mCHAR

(

bool

_createToken

)

[protected]

Definition at line 372 of file CPTensorConfLexer.cpp.

References CHAR.

Referenced by mSTRING().

                                               {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = CHAR;
        std::string::size_type _saveIndex;
        
        {
        matchRange('a','z');
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mDIGIT

(

bool

_createToken

)

[protected]

Definition at line 388 of file CPTensorConfLexer.cpp.

References DIGIT.

Referenced by mINT(), and mSTRING().

                                                {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = DIGIT;
        std::string::size_type _saveIndex;
        
        matchRange('0','9');
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mOTHER

(

bool

_createToken

)

[protected]

Definition at line 402 of file CPTensorConfLexer.cpp.

References OTHER.

Referenced by mSTRING().

                                                {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = OTHER;
        std::string::size_type _saveIndex;
        
        switch ( LA(1)) {
        case 0x27 /* '\'' */ :
        {
                match('\'' /* charlit */ );
                break;
        }
        case 0x23 /* '#' */ :
        {
                match('#' /* charlit */ );
                break;
        }
        case 0x24 /* '$' */ :
        {
                match('$' /* charlit */ );
                break;
        }
        case 0x25 /* '%' */ :
        {
                match('%' /* charlit */ );
                break;
        }
        case 0x26 /* '&' */ :
        {
                match('&' /* charlit */ );
                break;
        }
        case 0x28 /* '(' */ :
        {
                match('(' /* charlit */ );
                break;
        }
        case 0x29 /* ')' */ :
        {
                match(')' /* charlit */ );
                break;
        }
        case 0x2a /* '*' */ :
        {
                match('*' /* charlit */ );
                break;
        }
        case 0x2b /* '+' */ :
        {
                match('+' /* charlit */ );
                break;
        }
        case 0x2c /* ',' */ :
        {
                match(',' /* charlit */ );
                break;
        }
        case 0x2d /* '-' */ :
        {
                match('-' /* charlit */ );
                break;
        }
        case 0x2e /* '.' */ :
        {
                match('.' /* charlit */ );
                break;
        }
        case 0x2f /* '/' */ :
        {
                match('/' /* charlit */ );
                break;
        }
        case 0x3a /* ':' */ :
        {
                match(':' /* charlit */ );
                break;
        }
        case 0x3b /* ';' */ :
        {
                match(';' /* charlit */ );
                break;
        }
        case 0x3c /* '<' */ :
        {
                match('<' /* charlit */ );
                break;
        }
        case 0x3f /* '?' */ :
        {
                match('?' /* charlit */ );
                break;
        }
        case 0x40 /* '@' */ :
        {
                match('@' /* charlit */ );
                break;
        }
        case 0x5b /* '[' */ :
        {
                match('[' /* charlit */ );
                break;
        }
        case 0x5d /* ']' */ :
        {
                match(']' /* charlit */ );
                break;
        }
        case 0x5e /* '^' */ :
        {
                match('^' /* charlit */ );
                break;
        }
        case 0x5f /* '_' */ :
        {
                match('_' /* charlit */ );
                break;
        }
        case 0x7b /* '{' */ :
        {
                match('{' /* charlit */ );
                break;
        }
        case 0x7c /* '|' */ :
        {
                match('|' /* charlit */ );
                break;
        }
        case 0x7d /* '}' */ :
        {
                match('}' /* charlit */ );
                break;
        }
        case 0x7e /* '~' */ :
        {
                match('~' /* charlit */ );
                break;
        }
        default:
        {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mNUMBER

(

bool

_createToken

)

Definition at line 551 of file CPTensorConfLexer.cpp.

References mINT(), mREAL(), and NUMBER.

Referenced by nextToken().

                                                 {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = NUMBER;
        std::string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x2b /* '+' */ :
        {
                match('+' /* charlit */ );
                break;
        }
        case 0x2d /* '-' */ :
        {
                match('-' /* charlit */ );
                break;
        }
        case 0x2e /* '.' */ :
        case 0x30 /* '0' */ :
        case 0x31 /* '1' */ :
        case 0x32 /* '2' */ :
        case 0x33 /* '3' */ :
        case 0x34 /* '4' */ :
        case 0x35 /* '5' */ :
        case 0x36 /* '6' */ :
        case 0x37 /* '7' */ :
        case 0x38 /* '8' */ :
        case 0x39 /* '9' */ :
        {
                break;
        }
        default:
        {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        {
        bool synPredMatched38 = false;
        if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
                int _m38 = mark();
                synPredMatched38 = true;
                inputState->guessing++;
                try {
                        {
                        mREAL(false);
                        }
                }
                catch (antlr::RecognitionException& pe) {
                        synPredMatched38 = false;
                }
                rewind(_m38);
                inputState->guessing--;
        }
        if ( synPredMatched38 ) {
                mREAL(false);
        }
        else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
                mINT(false);
        }
        else {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        
        }
        {
        if ((LA(1) == 0x65 /* 'e' */ )) {
                {
                match('e' /* charlit */ );
                }
                {
                switch ( LA(1)) {
                case 0x2b /* '+' */ :
                {
                        match('+' /* charlit */ );
                        break;
                }
                case 0x2d /* '-' */ :
                {
                        match('-' /* charlit */ );
                        break;
                }
                case 0x30 /* '0' */ :
                case 0x31 /* '1' */ :
                case 0x32 /* '2' */ :
                case 0x33 /* '3' */ :
                case 0x34 /* '4' */ :
                case 0x35 /* '5' */ :
                case 0x36 /* '6' */ :
                case 0x37 /* '7' */ :
                case 0x38 /* '8' */ :
                case 0x39 /* '9' */ :
                {
                        break;
                }
                default:
                {
                        throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                }
                }
                mINT(false);
        }
        else {
        }
        
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mREAL

(

bool

_createToken

)

[protected]

Definition at line 666 of file CPTensorConfLexer.cpp.

References mINT(), and REAL.

Referenced by mNUMBER().

                                               {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = REAL;
        std::string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x2e /* '.' */ :
        {
                match('.' /* charlit */ );
                mINT(false);
                break;
        }
        case 0x30 /* '0' */ :
        case 0x31 /* '1' */ :
        case 0x32 /* '2' */ :
        case 0x33 /* '3' */ :
        case 0x34 /* '4' */ :
        case 0x35 /* '5' */ :
        case 0x36 /* '6' */ :
        case 0x37 /* '7' */ :
        case 0x38 /* '8' */ :
        case 0x39 /* '9' */ :
        {
                mINT(false);
                match('.' /* charlit */ );
                {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        mINT(false);
                }
                else {
                }
                
                }
                break;
        }
        default:
        {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mINT

(

bool

_createToken

)

[protected]

Definition at line 716 of file CPTensorConfLexer.cpp.

References INT, and mDIGIT().

Referenced by mNUMBER(), and mREAL().

                                              {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = INT;
        std::string::size_type _saveIndex;
        
        { // ( ... )+
        int _cnt53=0;
        for (;;) {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        mDIGIT(false);
                }
                else {
                        if ( _cnt53>=1 ) { goto _loop53; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt53++;
        }
        _loop53:;
        }  // ( ... )+
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mCOMMENT

(

bool

_createToken

)

Definition at line 743 of file CPTensorConfLexer.cpp.

References COMMENT, and mNEWLINE().

Referenced by nextToken().

                                                  {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = COMMENT;
        std::string::size_type _saveIndex;
        
        match('/' /* charlit */ );
        match('/' /* charlit */ );
        { // ( ... )*
        for (;;) {
                if ((_tokenSet_1.member(LA(1)))) {
                        {
                        match(_tokenSet_1);
                        }
                }
                else {
                        goto _loop45;
                }
                
        }
        _loop45:;
        } // ( ... )*
        mNEWLINE(false);
        if ( inputState->guessing==0 ) {
#line 94 "CPTensorConf.g"
                
                                        _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
                                
#line 771 "CPTensorConfLexer.cpp"
        }
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

Here is the call graph for this function:

void CPTensorConfLexer::mSCALEFACTORT

(

bool

_createToken

)

Definition at line 780 of file CPTensorConfLexer.cpp.

References SCALEFACTORT.

Referenced by nextToken().

                                                       {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = SCALEFACTORT;
        std::string::size_type _saveIndex;
        
        match("scalefactor");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mNORMALIZET

(

bool

_createToken

)

Definition at line 794 of file CPTensorConfLexer.cpp.

References NORMALIZET.

Referenced by nextToken().

                                                     {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = NORMALIZET;
        std::string::size_type _saveIndex;
        
        match("normalize");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mWRITETENSORT

(

bool

_createToken

)

Definition at line 808 of file CPTensorConfLexer.cpp.

References WRITETENSORT.

Referenced by nextToken().

                                                       {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = WRITETENSORT;
        std::string::size_type _saveIndex;
        
        match("writetensor");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mWRITESERIALPARALLELT

(

bool

_createToken

)

Definition at line 822 of file CPTensorConfLexer.cpp.

References WRITESERIALPARALLELT.

Referenced by nextToken().

                                                               {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = WRITESERIALPARALLELT;
        std::string::size_type _saveIndex;
        
        match("writeserialparallel");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void CPTensorConfLexer::mCALCERRT

(

bool

_createToken

)

Definition at line 836 of file CPTensorConfLexer.cpp.

References CALCERRT.

Referenced by nextToken().

                                                   {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = CALCERRT;
        std::string::size_type _saveIndex;
        
        match("calcerr");
        if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

---

The documentation for this class was generated from the following files:

• CPTensorConfLexer.hpp
• CPTensorConfLexer.cpp

---