MakeInputConfLexer Class Reference

#include <MakeInputConfLexer.hpp>

Inheritance diagram for MakeInputConfLexer:

[legend]Collaboration diagram for MakeInputConfLexer:

[legend]List of all members.

Public Member Functions
bool	getCaseSensitiveLiterals () const
	MakeInputConfLexer (std::istream &in)
	MakeInputConfLexer (antlr::InputBuffer &ib)
	MakeInputConfLexer (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	mSLOWNESST (bool _createToken)
void	mOMEGAT (bool _createToken)
void	mSIGMAT (bool _createToken)
void	mSHIFTT (bool _createToken)
void	mCCT (bool _createToken)
void	mPOISSONT (bool _createToken)
void	mNLAYERST (bool _createToken)
void	mOUTPUTBASET (bool _createToken)
void	mCORRELATEDT (bool _createToken)
void	mDTT (bool _createToken)
void	mNPTST (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 MakeInputConfLexer.hpp.

---

Constructor & Destructor Documentation

MakeInputConfLexer::MakeInputConfLexer

(

std::istream &

in

)

Definition at line 13 of file MakeInputConfLexer.cpp.

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

MakeInputConfLexer::MakeInputConfLexer

(

antlr::InputBuffer &

ib

)

Definition at line 19 of file MakeInputConfLexer.cpp.

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

MakeInputConfLexer::MakeInputConfLexer

(

const antlr::LexerSharedInputState &

state

)

Definition at line 25 of file MakeInputConfLexer.cpp.

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

---

Member Function Documentation

bool MakeInputConfLexer::getCaseSensitiveLiterals

(

)

const [inline]

Definition at line 25 of file MakeInputConfLexer.hpp.

        {
                return true;
        }

antlr::RefToken MakeInputConfLexer::nextToken

(

)

Definition at line 35 of file MakeInputConfLexer.cpp.

References mCCT(), mCOMMENT(), mCORRELATEDT(), mDTT(), mEQUAL(), mFALSE(), mNLAYERST(), mNPTST(), mNUMBER(), mOMEGAT(), mOUTPUTBASET(), mPOISSONT(), mSHIFTT(), mSIGMAT(), mSLOWNESST(), mSTRING(), mTRUE(), 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) == 0x6f /* 'o' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x70 /* 'p' */ ) && (LA(5) == 0x75 /* 'u' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x62 /* 'b' */ ) && (LA(8) == 0x61 /* 'a' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
                                        mOUTPUTBASET(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x64 /* 'd' */ )) {
                                        mCORRELATEDT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x77 /* 'w' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
                                        mSLOWNESST(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x6e /* 'n' */ ) && (true) && (true) && (true)) {
                                        mPOISSONT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x6e /* 'n' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x79 /* 'y' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
                                        mNLAYERST(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) == 0x6f /* 'o' */ ) && (LA(2) == 0x6d /* 'm' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x67 /* 'g' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true) && (true)) {
                                        mOMEGAT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x67 /* 'g' */ ) && (LA(4) == 0x6d /* 'm' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true) && (true)) {
                                        mSIGMAT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
                                        mSHIFTT(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) == 0x6e /* 'n' */ ) && (LA(2) == 0x70 /* 'p' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x73 /* 's' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mNPTST(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x63 /* 'c' */ ) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mCCT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x64 /* 'd' */ ) && (LA(2) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mDTT(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 MakeInputConfLexer::mEQUAL

(

bool

_createToken

)

Definition at line 170 of file MakeInputConfLexer.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 MakeInputConfLexer::mTRUE

(

bool

_createToken

)

Definition at line 184 of file MakeInputConfLexer.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 MakeInputConfLexer::mFALSE

(

bool

_createToken

)

Definition at line 198 of file MakeInputConfLexer.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 MakeInputConfLexer::mWS

(

bool

_createToken

)

Definition at line 212 of file MakeInputConfLexer.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 _cnt60=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 ( _cnt60>=1 ) { goto _loop60; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                }
                _cnt60++;
        }
        _loop60:;
        }  // ( ... )+
        if ( inputState->guessing==0 ) {
#line 84 "MakeInputConf.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 250 "MakeInputConfLexer.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 MakeInputConfLexer::mNEWLINE

(

bool

_createToken

)

[protected]

Definition at line 259 of file MakeInputConfLexer.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 110 "MakeInputConf.g"
                newline();
#line 287 "MakeInputConfLexer.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 MakeInputConfLexer::mSTRING

(

bool

_createToken

)

Definition at line 296 of file MakeInputConfLexer.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 _loop63;
                }
                }
        }
        _loop63:;
        } // ( ... )*
        _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 MakeInputConfLexer::mCHAR

(

bool

_createToken

)

[protected]

Definition at line 396 of file MakeInputConfLexer.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 MakeInputConfLexer::mDIGIT

(

bool

_createToken

)

[protected]

Definition at line 412 of file MakeInputConfLexer.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 MakeInputConfLexer::mOTHER

(

bool

_createToken

)

[protected]

Definition at line 426 of file MakeInputConfLexer.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 MakeInputConfLexer::mNUMBER

(

bool

_createToken

)

Definition at line 575 of file MakeInputConfLexer.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 synPredMatched68 = false;
        if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
                int _m68 = mark();
                synPredMatched68 = true;
                inputState->guessing++;
                try {
                        {
                        mREAL(false);
                        }
                }
                catch (antlr::RecognitionException& pe) {
                        synPredMatched68 = false;
                }
                rewind(_m68);
                inputState->guessing--;
        }
        if ( synPredMatched68 ) {
                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 MakeInputConfLexer::mREAL

(

bool

_createToken

)

[protected]

Definition at line 690 of file MakeInputConfLexer.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 MakeInputConfLexer::mINT

(

bool

_createToken

)

[protected]

Definition at line 740 of file MakeInputConfLexer.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 _cnt83=0;
        for (;;) {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        mDIGIT(false);
                }
                else {
                        if ( _cnt83>=1 ) { goto _loop83; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt83++;
        }
        _loop83:;
        }  // ( ... )+
        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 MakeInputConfLexer::mCOMMENT

(

bool

_createToken

)

Definition at line 767 of file MakeInputConfLexer.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 _loop75;
                }
                
        }
        _loop75:;
        } // ( ... )*
        mNEWLINE(false);
        if ( inputState->guessing==0 ) {
#line 101 "MakeInputConf.g"
                
                                        _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
                                
#line 795 "MakeInputConfLexer.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 MakeInputConfLexer::mSLOWNESST

(

bool

_createToken

)

Definition at line 804 of file MakeInputConfLexer.cpp.

References SLOWNESST.

Referenced by nextToken().

                                                     {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = SLOWNESST;
        std::string::size_type _saveIndex;
        
        match("slowness");
        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 MakeInputConfLexer::mOMEGAT

(

bool

_createToken

)

Definition at line 818 of file MakeInputConfLexer.cpp.

References OMEGAT.

Referenced by nextToken().

                                                  {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = OMEGAT;
        std::string::size_type _saveIndex;
        
        match("omega");
        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 MakeInputConfLexer::mSIGMAT

(

bool

_createToken

)

Definition at line 832 of file MakeInputConfLexer.cpp.

References SIGMAT.

Referenced by nextToken().

                                                  {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = SIGMAT;
        std::string::size_type _saveIndex;
        
        match("sigma");
        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 MakeInputConfLexer::mSHIFTT

(

bool

_createToken

)

Definition at line 846 of file MakeInputConfLexer.cpp.

References SHIFTT.

Referenced by nextToken().

                                                  {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = SHIFTT;
        std::string::size_type _saveIndex;
        
        match("shift");
        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 MakeInputConfLexer::mCCT

(

bool

_createToken

)

Definition at line 860 of file MakeInputConfLexer.cpp.

References CCT.

Referenced by nextToken().

                                               {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = CCT;
        std::string::size_type _saveIndex;
        
        match("cc");
        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 MakeInputConfLexer::mPOISSONT

(

bool

_createToken

)

Definition at line 874 of file MakeInputConfLexer.cpp.

References POISSONT.

Referenced by nextToken().

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