CLmsConfigLexer Class Reference

#include <CLmsConfigLexer.hpp>

Inheritance diagram for CLmsConfigLexer:

[legend]Collaboration diagram for CLmsConfigLexer:

[legend]List of all members.

Public Member Functions
bool	getCaseSensitiveLiterals () const
	CLmsConfigLexer (std::istream &in)
	CLmsConfigLexer (antlr::InputBuffer &ib)
	CLmsConfigLexer (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	mMUT (bool _createToken)
void	mFILTERLENGTHT (bool _createToken)
void	mSHIFTT (bool _createToken)
void	mSECFACTORT (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 CLmsConfigLexer.hpp.

---

Constructor & Destructor Documentation

CLmsConfigLexer::CLmsConfigLexer

(

std::istream &

in

)

Definition at line 13 of file CLmsConfigLexer.cpp.

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

CLmsConfigLexer::CLmsConfigLexer

(

antlr::InputBuffer &

ib

)

Definition at line 19 of file CLmsConfigLexer.cpp.

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

CLmsConfigLexer::CLmsConfigLexer

(

const antlr::LexerSharedInputState &

state

)

Definition at line 25 of file CLmsConfigLexer.cpp.

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

---

Member Function Documentation

bool CLmsConfigLexer::getCaseSensitiveLiterals

(

)

const [inline]

Definition at line 25 of file CLmsConfigLexer.hpp.

        {
                return true;
        }

antlr::RefToken CLmsConfigLexer::nextToken

(

)

Definition at line 35 of file CLmsConfigLexer.cpp.

References mCOMMENT(), mEQUAL(), mFALSE(), mFILTERLENGTHT(), mMUT(), mNUMBER(), mSECFACTORT(), mSHIFTT(), 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) == 0x66 /* 'f' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6c /* 'l' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6e /* 'n' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
                                        mFILTERLENGTHT(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x63 /* 'c' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (true)) {
                                        mSECFACTORT(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) == 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) == 0x6d /* 'm' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
                                        mMUT(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 CLmsConfigLexer::mEQUAL

(

bool

_createToken

)

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

(

bool

_createToken

)

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

(

bool

_createToken

)

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

(

bool

_createToken

)

Definition at line 184 of file CLmsConfigLexer.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 _cnt34=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 ( _cnt34>=1 ) { goto _loop34; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                }
                _cnt34++;
        }
        _loop34:;
        }  // ( ... )+
        if ( inputState->guessing==0 ) {
#line 71 "CLmsConfig.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 222 "CLmsConfigLexer.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 CLmsConfigLexer::mNEWLINE

(

bool

_createToken

)

[protected]

Definition at line 231 of file CLmsConfigLexer.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 97 "CLmsConfig.g"
                newline();
#line 259 "CLmsConfigLexer.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 CLmsConfigLexer::mSTRING

(

bool

_createToken

)

Definition at line 268 of file CLmsConfigLexer.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 _loop37;
                }
                }
        }
        _loop37:;
        } // ( ... )*
        _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 CLmsConfigLexer::mCHAR

(

bool

_createToken

)

[protected]

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

(

bool

_createToken

)

[protected]

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

(

bool

_createToken

)

[protected]

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

(

bool

_createToken

)

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

(

bool

_createToken

)

[protected]

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

(

bool

_createToken

)

[protected]

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

(

bool

_createToken

)

Definition at line 739 of file CLmsConfigLexer.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 _loop49;
                }
                
        }
        _loop49:;
        } // ( ... )*
        mNEWLINE(false);
        if ( inputState->guessing==0 ) {
#line 88 "CLmsConfig.g"
                
                                        _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
                                
#line 767 "CLmsConfigLexer.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 CLmsConfigLexer::mMUT

(

bool

_createToken

)

Definition at line 776 of file CLmsConfigLexer.cpp.

References MUT.

Referenced by nextToken().

                                            {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = MUT;
        std::string::size_type _saveIndex;
        
        match("mu");
        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 CLmsConfigLexer::mFILTERLENGTHT

(

bool

_createToken

)

Definition at line 790 of file CLmsConfigLexer.cpp.

References FILTERLENGTHT.

Referenced by nextToken().

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

(

bool

_createToken

)

Definition at line 804 of file CLmsConfigLexer.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 CLmsConfigLexer::mSECFACTORT

(

bool

_createToken

)

Definition at line 818 of file CLmsConfigLexer.cpp.

References SECFACTORT.

Referenced by nextToken().

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

• CLmsConfigLexer.hpp
• CLmsConfigLexer.cpp

---