src/mdParser/MDLexer.cpp

/* $ANTLR 2.7.7 (20101020): "MDParser.g" -> "MDLexer.cpp"$ */
#include "MDLexer.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 "MDParser.g"
#line 13 "MDLexer.cpp"
MDLexer::MDLexer(ANTLR_USE_NAMESPACE(std)istream& in)
        : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true)
{
        initLiterals();
}

MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
        : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
{
        initLiterals();
}

MDLexer::MDLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
        : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true)
{
        initLiterals();
}

void MDLexer::initLiterals()
{
        literals["members"] = 16;
        literals["position"] = 18;
        literals["torsion"] = 11;
        literals["component"] = 4;
        literals["restraint"] = 7;
        literals["rigidBody"] = 13;
        literals["center"] = 17;
        literals["inversion"] = 12;
        literals["zconstraint"] = 6;
        literals["cutoffGroup"] = 14;
        literals["bend"] = 10;
        literals["orientation"] = 19;
        literals["fragment"] = 15;
        literals["bond"] = 9;
        literals["molecule"] = 5;
        literals["atom"] = 8;
}

ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
{
        ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
        for (;;) {
                ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
                int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
                resetText();
                try {   // for lexical and char stream error handling
                        switch ( LA(1)) {
                        case 0x3d /* '=' */ :
                        {
                                mASSIGNEQUAL(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x3a /* ':' */ :
                        {
                                mCOLON(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x2c /* ',' */ :
                        {
                                mCOMMA(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x3f /* '?' */ :
                        {
                                mQUESTIONMARK(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x3b /* ';' */ :
                        {
                                mSEMICOLON(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x28 /* '(' */ :
                        {
                                mLPAREN(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x29 /* ')' */ :
                        {
                                mRPAREN(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x5b /* '[' */ :
                        {
                                mLBRACKET(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x5d /* ']' */ :
                        {
                                mRBRACKET(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x7b /* '{' */ :
                        {
                                mLCURLY(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x7d /* '}' */ :
                        {
                                mRCURLY(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x9 /* '\t' */ :
                        case 0xa /* '\n' */ :
                        case 0xc /* '\14' */ :
                        case 0xd /* '\r' */ :
                        case 0x20 /* ' ' */ :
                        case 0x5c /* '\\' */ :
                        {
                                mWhitespace(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x23 /* '#' */ :
                        {
                                mPREPROC_DIRECTIVE(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x22 /* '\"' */ :
                        {
                                mStringLiteral(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x27 /* '\'' */ :
                        {
                                mCharLiteral(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        case 0x41 /* 'A' */ :
                        case 0x42 /* 'B' */ :
                        case 0x43 /* 'C' */ :
                        case 0x44 /* 'D' */ :
                        case 0x45 /* 'E' */ :
                        case 0x46 /* 'F' */ :
                        case 0x47 /* 'G' */ :
                        case 0x48 /* 'H' */ :
                        case 0x49 /* 'I' */ :
                        case 0x4a /* 'J' */ :
                        case 0x4b /* 'K' */ :
                        case 0x4c /* 'L' */ :
                        case 0x4d /* 'M' */ :
                        case 0x4e /* 'N' */ :
                        case 0x4f /* 'O' */ :
                        case 0x50 /* 'P' */ :
                        case 0x51 /* 'Q' */ :
                        case 0x52 /* 'R' */ :
                        case 0x53 /* 'S' */ :
                        case 0x54 /* 'T' */ :
                        case 0x55 /* 'U' */ :
                        case 0x56 /* 'V' */ :
                        case 0x57 /* 'W' */ :
                        case 0x58 /* 'X' */ :
                        case 0x59 /* 'Y' */ :
                        case 0x5a /* 'Z' */ :
                        case 0x5f /* '_' */ :
                        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' */ :
                        {
                                mID(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' */ :
                        {
                                mNUM_INT(true);
                                theRetToken=_returnToken;
                                break;
                        }
                        default:
                                if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
                                        mComment(true);
                                        theRetToken=_returnToken;
                                }
                                else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) {
                                        mCPPComment(true);
                                        theRetToken=_returnToken;
                                }
                        else {
                                if (LA(1)==EOF_CHAR)
                                {
                                        uponEOF();
                                        _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
                                }
                                else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                        }
                        }
                        if ( !_returnToken )
                                goto tryAgain; // found SKIP token

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

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

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

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

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

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

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

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

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

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

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

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

void MDLexer::mWhitespace(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Whitespace;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x9 /* '\t' */ :
        case 0xc /* '\14' */ :
        case 0x20 /* ' ' */ :
        {
                {
                switch ( LA(1)) {
                case 0x20 /* ' ' */ :
                {
                        match(' ' /* charlit */ );
                        break;
                }
                case 0x9 /* '\t' */ :
                {
                        match('\t' /* charlit */ );
                        break;
                }
                case 0xc /* '\14' */ :
                {
                        match('\14' /* charlit */ );
                        break;
                }
                default:
                {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                }
                }
                break;
        }
        case 0xa /* '\n' */ :
        case 0xd /* '\r' */ :
        {
                {
                if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
                        match('\r' /* charlit */ );
                        match('\n' /* charlit */ );
                }
                else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
                        match('\r' /* charlit */ );
                }
                else if ((LA(1) == 0xa /* '\n' */ )) {
                        match('\n' /* charlit */ );
                }
                else {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                
                }
                if ( inputState->guessing==0 ) {
#line 233 "MDParser.g"
                        newline();
#line 482 "MDLexer.cpp"
                }
                break;
        }
        case 0x5c /* '\\' */ :
        {
                {
                if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
                        match('\\' /* charlit */ );
                        match('\r' /* charlit */ );
                        match('\n' /* charlit */ );
                }
                else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
                        match('\\' /* charlit */ );
                        match('\r' /* charlit */ );
                }
                else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
                        match('\\' /* charlit */ );
                        match('\n' /* charlit */ );
                }
                else {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                
                }
                if ( inputState->guessing==0 ) {
#line 238 "MDParser.g"
                        printf("CPP_parser.g continuation line detected\n");
                        deferredNewline();
#line 511 "MDLexer.cpp"
                }
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( inputState->guessing==0 ) {
#line 241 "MDParser.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 524 "MDLexer.cpp"
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mComment(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Comment;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match("/*");
        { // ( ... )*
        for (;;) {
                if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
                        match('*' /* charlit */ );
                }
                else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
                        mEndOfLine(false);
                        if ( inputState->guessing==0 ) {
#line 248 "MDParser.g"
                                deferredNewline();
#line 550 "MDLexer.cpp"
                        }
                }
                else if ((_tokenSet_0.member(LA(1)))) {
                        {
                        match(_tokenSet_0);
                        }
                }
                else {
                        goto _loop86;
                }
                
        }
        _loop86:;
        } // ( ... )*
        match("*/");
        if ( inputState->guessing==0 ) {
#line 251 "MDParser.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
#line 569 "MDLexer.cpp"
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mEndOfLine(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = EndOfLine;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
                match("\r\n");
        }
        else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
                match('\r' /* charlit */ );
        }
        else if ((LA(1) == 0xa /* '\n' */ )) {
                match('\n' /* charlit */ );
        }
        else {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mCPPComment(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = CPPComment;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match("//");
        { // ( ... )*
        for (;;) {
                if ((_tokenSet_1.member(LA(1)))) {
                        {
                        match(_tokenSet_1);
                        }
                }
                else {
                        goto _loop90;
                }
                
        }
        _loop90:;
        } // ( ... )*
        mEndOfLine(false);
        if ( inputState->guessing==0 ) {
#line 257 "MDParser.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
#line 631 "MDLexer.cpp"
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = PREPROC_DIRECTIVE;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match('#' /* charlit */ );
        mLineDirective(false);
        if ( inputState->guessing==0 ) {
#line 264 "MDParser.g"
                _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
#line 651 "MDLexer.cpp"
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mLineDirective(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = LineDirective;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        ANTLR_USE_NAMESPACE(antlr)RefToken n;
        ANTLR_USE_NAMESPACE(antlr)RefToken sl;
        
        if ( inputState->guessing==0 ) {
#line 270 "MDParser.g"
                
                deferredLineCount = 0;
                
#line 673 "MDLexer.cpp"
        }
        {
        switch ( LA(1)) {
        case 0x6c /* 'l' */ :
        {
                match("line");
                break;
        }
        case 0x9 /* '\t' */ :
        case 0xc /* '\14' */ :
        case 0x20 /* ' ' */ :
        {
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        { // ( ... )+
        int _cnt95=0;
        for (;;) {
                if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
                        mSpace(false);
                }
                else {
                        if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt95++;
        }
        _loop95:;
        }  // ( ... )+
        mDecimal(true);
        n=_returnToken;
        if ( inputState->guessing==0 ) {
#line 275 "MDParser.g"
                setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
#line 713 "MDLexer.cpp"
        }
        { // ( ... )+
        int _cnt97=0;
        for (;;) {
                if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
                        mSpace(false);
                }
                else {
                        if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt97++;
        }
        _loop97:;
        }  // ( ... )+
        {
        mStringLiteral(true);
        sl=_returnToken;
        }
        if ( inputState->guessing==0 ) {
#line 277 "MDParser.g"
                std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
#line 736 "MDLexer.cpp"
        }
        { // ( ... )*
        for (;;) {
                if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
                        { // ( ... )+
                        int _cnt101=0;
                        for (;;) {
                                if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
                                        mSpace(false);
                                }
                                else {
                                        if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                }
                                
                                _cnt101++;
                        }
                        _loop101:;
                        }  // ( ... )+
                        mDecimal(false);
                }
                else {
                        goto _loop102;
                }
                
        }
        _loop102:;
        } // ( ... )*
        mEndOfLine(false);
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mSpace(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Space;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x20 /* ' ' */ :
        {
                match(' ' /* charlit */ );
                break;
        }
        case 0x9 /* '\t' */ :
        {
                match('\t' /* charlit */ );
                break;
        }
        case 0xc /* '\14' */ :
        {
                match('\14' /* charlit */ );
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mDecimal(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Decimal;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        { // ( ... )+
        int _cnt132=0;
        for (;;) {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        matchRange('0','9');
                }
                else {
                        if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt132++;
        }
        _loop132:;
        }  // ( ... )+
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mStringLiteral(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = StringLiteral;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match('\"' /* charlit */ );
        { // ( ... )*
        for (;;) {
                if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
                        mEscape(false);
                }
                else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
                        {
                        if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
                                match("\\\r\n");
                        }
                        else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
                                match("\\\r");
                        }
                        else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
                                match("\\\n");
                        }
                        else {
                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                        }
                        
                        }
                        if ( inputState->guessing==0 ) {
#line 317 "MDParser.g"
                                deferredNewline();
#line 866 "MDLexer.cpp"
                        }
                }
                else if ((_tokenSet_3.member(LA(1)))) {
                        {
                        match(_tokenSet_3);
                        }
                }
                else {
                        goto _loop112;
                }
                
        }
        _loop112:;
        } // ( ... )*
        match('\"' /* charlit */ );
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mCharLiteral(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = CharLiteral;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match('\'' /* charlit */ );
        {
        if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
                mEscape(false);
        }
        else if ((_tokenSet_5.member(LA(1))) && (LA(2) == 0x27 /* '\'' */ ) && (true)) {
                {
                match(_tokenSet_5);
                }
        }
        else {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        
        }
        match('\'' /* charlit */ );
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mEscape(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Escape;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        match('\\' /* charlit */ );
        {
        switch ( LA(1)) {
        case 0x61 /* 'a' */ :
        {
                match('a' /* charlit */ );
                break;
        }
        case 0x62 /* 'b' */ :
        {
                match('b' /* charlit */ );
                break;
        }
        case 0x66 /* 'f' */ :
        {
                match('f' /* charlit */ );
                break;
        }
        case 0x6e /* 'n' */ :
        {
                match('n' /* charlit */ );
                break;
        }
        case 0x72 /* 'r' */ :
        {
                match('r' /* charlit */ );
                break;
        }
        case 0x74 /* 't' */ :
        {
                match('t' /* charlit */ );
                break;
        }
        case 0x76 /* 'v' */ :
        {
                match('v' /* charlit */ );
                break;
        }
        case 0x22 /* '\"' */ :
        {
                match('\"' /* charlit */ );
                break;
        }
        case 0x27 /* '\'' */ :
        {
                match('\'' /* charlit */ );
                break;
        }
        case 0x5c /* '\\' */ :
        {
                match('\\' /* charlit */ );
                break;
        }
        case 0x3f /* '?' */ :
        {
                match('?' /* charlit */ );
                break;
        }
        case 0x30 /* '0' */ :
        case 0x31 /* '1' */ :
        case 0x32 /* '2' */ :
        case 0x33 /* '3' */ :
        {
                {
                matchRange('0','3');
                }
                {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                        mDigit(false);
                        {
                        if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                                mDigit(false);
                        }
                        else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
                        }
                        else {
                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                        }
                        
                        }
                }
                else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
                }
                else {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                
                }
                break;
        }
        case 0x34 /* '4' */ :
        case 0x35 /* '5' */ :
        case 0x36 /* '6' */ :
        case 0x37 /* '7' */ :
        {
                {
                matchRange('4','7');
                }
                {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                        mDigit(false);
                }
                else if ((_tokenSet_1.member(LA(1))) && (true) && (true)) {
                }
                else {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                
                }
                break;
        }
        case 0x78 /* 'x' */ :
        {
                match('x' /* charlit */ );
                { // ( ... )+
                int _cnt123=0;
                for (;;) {
                        if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                                mDigit(false);
                        }
                        else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x66 /* 'f' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                                matchRange('a','f');
                        }
                        else if (((LA(1) >= 0x41 /* 'A' */  && LA(1) <= 0x46 /* 'F' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
                                matchRange('A','F');
                        }
                        else {
                                if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                        }
                        
                        _cnt123++;
                }
                _loop123:;
                }  // ( ... )+
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

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

void MDLexer::mVocabulary(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = Vocabulary;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        matchRange('\3',static_cast<unsigned char>('\377'));
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mID(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = ID;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        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' */ :
        {
                matchRange('a','z');
                break;
        }
        case 0x41 /* 'A' */ :
        case 0x42 /* 'B' */ :
        case 0x43 /* 'C' */ :
        case 0x44 /* 'D' */ :
        case 0x45 /* 'E' */ :
        case 0x46 /* 'F' */ :
        case 0x47 /* 'G' */ :
        case 0x48 /* 'H' */ :
        case 0x49 /* 'I' */ :
        case 0x4a /* 'J' */ :
        case 0x4b /* 'K' */ :
        case 0x4c /* 'L' */ :
        case 0x4d /* 'M' */ :
        case 0x4e /* 'N' */ :
        case 0x4f /* 'O' */ :
        case 0x50 /* 'P' */ :
        case 0x51 /* 'Q' */ :
        case 0x52 /* 'R' */ :
        case 0x53 /* 'S' */ :
        case 0x54 /* 'T' */ :
        case 0x55 /* 'U' */ :
        case 0x56 /* 'V' */ :
        case 0x57 /* 'W' */ :
        case 0x58 /* 'X' */ :
        case 0x59 /* 'Y' */ :
        case 0x5a /* 'Z' */ :
        {
                matchRange('A','Z');
                break;
        }
        case 0x5f /* '_' */ :
        {
                match('_' /* charlit */ );
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(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' */ :
                {
                        matchRange('a','z');
                        break;
                }
                case 0x41 /* 'A' */ :
                case 0x42 /* 'B' */ :
                case 0x43 /* 'C' */ :
                case 0x44 /* 'D' */ :
                case 0x45 /* 'E' */ :
                case 0x46 /* 'F' */ :
                case 0x47 /* 'G' */ :
                case 0x48 /* 'H' */ :
                case 0x49 /* 'I' */ :
                case 0x4a /* 'J' */ :
                case 0x4b /* 'K' */ :
                case 0x4c /* 'L' */ :
                case 0x4d /* 'M' */ :
                case 0x4e /* 'N' */ :
                case 0x4f /* 'O' */ :
                case 0x50 /* 'P' */ :
                case 0x51 /* 'Q' */ :
                case 0x52 /* 'R' */ :
                case 0x53 /* 'S' */ :
                case 0x54 /* 'T' */ :
                case 0x55 /* 'U' */ :
                case 0x56 /* 'V' */ :
                case 0x57 /* 'W' */ :
                case 0x58 /* 'X' */ :
                case 0x59 /* 'Y' */ :
                case 0x5a /* 'Z' */ :
                {
                        matchRange('A','Z');
                        break;
                }
                case 0x5f /* '_' */ :
                {
                        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' */ :
                {
                        matchRange('0','9');
                        break;
                }
                default:
                {
                        goto _loop128;
                }
                }
        }
        _loop128:;
        } // ( ... )*
        _ttype = testLiteralsTable(_ttype);
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mHEX_DIGIT(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = HEX_DIGIT;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        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' */ :
        {
                matchRange('0','9');
                break;
        }
        case 0x41 /* 'A' */ :
        case 0x42 /* 'B' */ :
        case 0x43 /* 'C' */ :
        case 0x44 /* 'D' */ :
        case 0x45 /* 'E' */ :
        case 0x46 /* 'F' */ :
        {
                matchRange('A','F');
                break;
        }
        case 0x61 /* 'a' */ :
        case 0x62 /* 'b' */ :
        case 0x63 /* 'c' */ :
        case 0x64 /* 'd' */ :
        case 0x65 /* 'e' */ :
        case 0x66 /* 'f' */ :
        {
                matchRange('a','f');
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mNUM_INT(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = NUM_INT;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        ANTLR_USE_NAMESPACE(antlr)RefToken f1;
        ANTLR_USE_NAMESPACE(antlr)RefToken f2;
        ANTLR_USE_NAMESPACE(antlr)RefToken f3;
        ANTLR_USE_NAMESPACE(antlr)RefToken f4;
#line 410 "MDParser.g"
        
                        bool isDecimal = false;
                        ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
                
#line 1347 "MDLexer.cpp"
        
        {
        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_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        {
        switch ( LA(1)) {
        case 0x2e /* '.' */ :
        {
                match('.' /* charlit */ );
                if ( inputState->guessing==0 ) {
#line 417 "MDParser.g"
                        _ttype = DOT;
#line 1389 "MDLexer.cpp"
                }
                {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        { // ( ... )+
                        int _cnt140=0;
                        for (;;) {
                                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                                        matchRange('0','9');
                                }
                                else {
                                        if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                }
                                
                                _cnt140++;
                        }
                        _loop140:;
                        }  // ( ... )+
                        {
                        if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
                                mEXPONENT(false);
                        }
                        else {
                        }
                        
                        }
                        {
                        if ((_tokenSet_8.member(LA(1)))) {
                                mFLOAT_SUFFIX(true);
                                f1=_returnToken;
                                if ( inputState->guessing==0 ) {
#line 418 "MDParser.g"
                                        t=f1;
#line 1422 "MDLexer.cpp"
                                }
                        }
                        else {
                        }
                        
                        }
                        if ( inputState->guessing==0 ) {
#line 419 "MDParser.g"
                                
                                                                        if ( t &&
                                                                                  (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
                                                                                        t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
                                                                                _ttype = NUM_FLOAT;
                                                                        }
                                                                        else {
                                                                                _ttype = NUM_DOUBLE; // assume double
                                                                        }
                                                                
#line 1441 "MDLexer.cpp"
                        }
                }
                else {
                }
                
                }
                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' */ :
        {
                {
                switch ( LA(1)) {
                case 0x30 /* '0' */ :
                {
                        match('0' /* charlit */ );
                        if ( inputState->guessing==0 ) {
#line 431 "MDParser.g"
                                isDecimal = true;
#line 1469 "MDLexer.cpp"
                        }
                        {
                        if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
                                {
                                switch ( LA(1)) {
                                case 0x78 /* 'x' */ :
                                {
                                        match('x' /* charlit */ );
                                        break;
                                }
                                case 0x58 /* 'X' */ :
                                {
                                        match('X' /* charlit */ );
                                        break;
                                }
                                default:
                                {
                                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                                }
                                }
                                }
                                { // ( ... )+
                                int _cnt147=0;
                                for (;;) {
                                        if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
                                                mHEX_DIGIT(false);
                                        }
                                        else {
                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                        }
                                        
                                        _cnt147++;
                                }
                                _loop147:;
                                }  // ( ... )+
                        }
                        else {
                                bool synPredMatched152 = false;
                                if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
                                        int _m152 = mark();
                                        synPredMatched152 = true;
                                        inputState->guessing++;
                                        try {
                                                {
                                                { // ( ... )+
                                                int _cnt150=0;
                                                for (;;) {
                                                        if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                                                                matchRange('0','9');
                                                        }
                                                        else {
                                                                if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                                        }
                                                        
                                                        _cnt150++;
                                                }
                                                _loop150:;
                                                }  // ( ... )+
                                                {
                                                if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
                                                        mEXPONENT(false);
                                                }
                                                else if ((LA(1) == 0x2e /* '.' */ )) {
                                                        match('.' /* charlit */ );
                                                }
                                                else if ((_tokenSet_8.member(LA(1))) && (true)) {
                                                        mFLOAT_SUFFIX(false);
                                                }
                                                else {
                                                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                                                }
                                                
                                                }
                                                }
                                        }
                                        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
                                                synPredMatched152 = false;
                                        }
                                        rewind(_m152);
                                        inputState->guessing--;
                                }
                                if ( synPredMatched152 ) {
                                        { // ( ... )+
                                        int _cnt154=0;
                                        for (;;) {
                                                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                                                        matchRange('0','9');
                                                }
                                                else {
                                                        if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                                }
                                                
                                                _cnt154++;
                                        }
                                        _loop154:;
                                        }  // ( ... )+
                                }
                                else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
                                        { // ( ... )+
                                        int _cnt156=0;
                                        for (;;) {
                                                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
                                                        matchRange('0','7');
                                                }
                                                else {
                                                        if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                                                }
                                                
                                                _cnt156++;
                                        }
                                        _loop156:;
                                        }  // ( ... )+
                                }
                                else {
                                }
                        }
                        }
                        break;
                }
                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' */ :
                {
                        {
                        matchRange('1','9');
                        }
                        { // ( ... )*
                        for (;;) {
                                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                                        matchRange('0','9');
                                }
                                else {
                                        goto _loop159;
                                }
                                
                        }
                        _loop159:;
                        } // ( ... )*
                        if ( inputState->guessing==0 ) {
#line 448 "MDParser.g"
                                isDecimal=true;
#line 1617 "MDLexer.cpp"
                        }
                        break;
                }
                default:
                {
                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                }
                }
                }
                {
                if ((LA(1) == 0x4c /* 'L' */  || LA(1) == 0x6c /* 'l' */ )) {
                        {
                        switch ( LA(1)) {
                        case 0x6c /* 'l' */ :
                        {
                                match('l' /* charlit */ );
                                break;
                        }
                        case 0x4c /* 'L' */ :
                        {
                                match('L' /* charlit */ );
                                break;
                        }
                        default:
                        {
                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                        }
                        }
                        }
                        if ( inputState->guessing==0 ) {
#line 450 "MDParser.g"
                                _ttype = NUM_LONG;
#line 1650 "MDLexer.cpp"
                        }
                }
                else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
                        {
                        if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
                                mEXPONENT(false);
                                {
                                if ((_tokenSet_8.member(LA(1)))) {
                                        mFLOAT_SUFFIX(true);
                                        f3=_returnToken;
                                        if ( inputState->guessing==0 ) {
#line 455 "MDParser.g"
                                                t=f3;
#line 1664 "MDLexer.cpp"
                                        }
                                }
                                else {
                                }
                                
                                }
                        }
                        else if ((LA(1) == 0x2e /* '.' */ )) {
                                match('.' /* charlit */ );
                                { // ( ... )*
                                for (;;) {
                                        if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                                                matchRange('0','9');
                                        }
                                        else {
                                                goto _loop164;
                                        }
                                        
                                }
                                _loop164:;
                                } // ( ... )*
                                {
                                if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
                                        mEXPONENT(false);
                                }
                                else {
                                }
                                
                                }
                                {
                                if ((_tokenSet_8.member(LA(1)))) {
                                        mFLOAT_SUFFIX(true);
                                        f2=_returnToken;
                                        if ( inputState->guessing==0 ) {
#line 454 "MDParser.g"
                                                t=f2;
#line 1701 "MDLexer.cpp"
                                        }
                                }
                                else {
                                }
                                
                                }
                        }
                        else if ((_tokenSet_8.member(LA(1))) && (true)) {
                                mFLOAT_SUFFIX(true);
                                f4=_returnToken;
                                if ( inputState->guessing==0 ) {
#line 456 "MDParser.g"
                                        t=f4;
#line 1715 "MDLexer.cpp"
                                }
                        }
                        else {
                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
                        }
                        
                        }
                        if ( inputState->guessing==0 ) {
#line 458 "MDParser.g"
                                
                                                                        if ( t &&
                                                                                  (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
                                                                                        t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
                                                                                _ttype = NUM_FLOAT;
                                                                        }
                                                                        else {
                                                                                _ttype = NUM_DOUBLE; // assume double
                                                                        }
                                                                
#line 1735 "MDLexer.cpp"
                        }
                }
                else {
                }
                
                }
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mEXPONENT(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = EXPONENT;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        {
        switch ( LA(1)) {
        case 0x65 /* 'e' */ :
        {
                match('e' /* charlit */ );
                break;
        }
        case 0x45 /* 'E' */ :
        {
                match('E' /* charlit */ );
                break;
        }
        case 0x64 /* 'd' */ :
        {
                match('d' /* charlit */ );
                break;
        }
        case 0x44 /* 'D' */ :
        {
                match('D' /* charlit */ );
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        {
        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_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        }
        { // ( ... )+
        int _cnt172=0;
        for (;;) {
                if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
                        matchRange('0','9');
                }
                else {
                        if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
                }
                
                _cnt172++;
        }
        _loop172:;
        }  // ( ... )+
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}

void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
        int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
        _ttype = FLOAT_SUFFIX;
        ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
        
        switch ( LA(1)) {
        case 0x66 /* 'f' */ :
        {
                match('f' /* charlit */ );
                break;
        }
        case 0x46 /* 'F' */ :
        {
                match('F' /* charlit */ );
                break;
        }
        case 0x64 /* 'd' */ :
        {
                match('d' /* charlit */ );
                break;
        }
        case 0x44 /* 'D' */ :
        {
                match('D' /* charlit */ );
                break;
        }
        default:
        {
                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
        }
        }
        if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
           _token = makeToken(_ttype);
           _token->setText(text.substr(_begin, text.length()-_begin));
        }
        _returnToken = _token;
        _saveIndex=0;
}


const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// \" \' 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// \' 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 
// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 
// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// + - 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// 0 1 2 3 4 5 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
// . 
const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);

Revision:	1558
Committed:	Wed May 11 16:32:48 2011 UTC (13 years, 11 months ago) by gezelter
File size:	50589 byte(s)
Log Message:	Updated antlr, some minor formatting changes