StationLexer.cpp

Go to the documentation of this file.

/* $ANTLR 2.7.6 (20070220): "StationParser.g" -> "StationLexer.cpp"$ */
#include "StationLexer.hpp"
#include <antlr/CharBuffer.hpp>
#include <antlr/TokenStreamException.hpp>
#include <antlr/TokenStreamIOException.hpp>
#include <antlr/TokenStreamRecognitionException.hpp>
#include <antlr/CharStreamException.hpp>
#include <antlr/CharStreamIOException.hpp>
#include <antlr/NoViableAltForCharException.hpp>

#line 1 "StationParser.g"
#line 13 "StationLexer.cpp"
StationLexer::StationLexer(std::istream& in)
        : antlr::CharScanner(new antlr::CharBuffer(in),false)
{
        initLiterals();
}

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

StationLexer::StationLexer(const antlr::LexerSharedInputState& state)
        : antlr::CharScanner(state,false)
{
        initLiterals();
}

void StationLexer::initLiterals()
{
}

antlr::RefToken StationLexer::nextToken()
{
        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 0x9 /* '\t' */ :
                        case 0x20 /* ' ' */ :
                        {
                                mWS(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x2b /* '+' */ :
                        case 0x2d /* '-' */ :
                        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' */ :
                        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' */ :
                        {
                                mENTRY(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x23 /* '#' */ :
                        {
                                mCOMMENT(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0xa /* '\n' */ :
                        case 0xd /* '\r' */ :
                        {
                                mNEWLINE(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        default:
                        {
                                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:;
        }
}

void StationLexer::mWS(bool _createToken) {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = WS;
        std::string::size_type _saveIndex;
        
        { // ( ... )+
        int _cnt11=0;
        for (;;) {
                switch ( LA(1)) {
                case 0x20 /* ' ' */ :
                {
                        match(' ' /* charlit */ );
                        break;
                }
                case 0x9 /* '\t' */ :
                {
                        match('\t' /* charlit */ );
                        break;
                }
                default:
                {
                        if ( _cnt11>=1 ) { goto _loop11; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                }
                _cnt11++;
        }
        _loop11:;
        }  // ( ... )+
#line 62 "StationParser.g"
        _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 169 "StationLexer.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 StationLexer::mENTRY(bool _createToken) {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = ENTRY;
        std::string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x2b /* '+' */ :
        {
                mPLUS(false);
                break;
        }
        case 0x2d /* '-' */ :
        {
                mMINUS(false);
                break;
        }
        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;
        }
        default:
        {
                throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        { // ( ... )*
        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 0x2c /* ',' */ :
                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;
                }
                case 0x2b /* '+' */ :
                {
                        mPLUS(false);
                        break;
                }
                case 0x2d /* '-' */ :
                {
                        mMINUS(false);
                        break;
                }
                default:
                {
                        goto _loop15;
                }
                }
        }
        _loop15:;
        } // ( ... )*
        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 StationLexer::mPLUS(bool _createToken) {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = PLUS;
        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 StationLexer::mMINUS(bool _createToken) {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = MINUS;
        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 StationLexer::mCHAR(bool _createToken) {
        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 StationLexer::mDIGIT(bool _createToken) {
        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 StationLexer::mOTHER(bool _createToken) {
        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 0x2c /* ',' */ :
        {
                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 StationLexer::mCOMMENT(bool _createToken) {
        int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
        _ttype = COMMENT;
        std::string::size_type _saveIndex;
        
        match('#' /* charlit */ );
        { // ( ... )*
        for (;;) {
                if ((_tokenSet_0.member(LA(1)))) {
                        {
                        match(_tokenSet_0);
                        }
                }
                else {
                        goto _loop19;
                }
                
        }
        _loop19:;
        } // ( ... )*
        mNEWLINE(false);
#line 74 "StationParser.g"
        
                                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
                        
#line 568 "StationLexer.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 StationLexer::mNEWLINE(bool _createToken) {
        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());
        }
        }
        }
#line 82 "StationParser.g"
        newline();
#line 603 "StationLexer.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;
}


const unsigned long StationLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 
const antlr::BitSet StationLexer::_tokenSet_0(_tokenSet_0_data_,8);

---