ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/mdParser/MDLexer.cpp

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDLexer.cpp"$ */
2		#include "MDLexer.hpp"
3		#include <antlr/CharBuffer.hpp>
4		#include <antlr/TokenStreamException.hpp>
#	Line 30 | Line 30 | void MDLexer::initLiterals()
30
31		void MDLexer::initLiterals()
32		{
33	<	literals["members"] = 14;
34	<	literals["position"] = 15;
35	<	literals["torsion"] = 10;
33	>	literals["members"] = 16;
34	>	literals["position"] = 18;
35	>	literals["torsion"] = 11;
36		literals["component"] = 4;
37	<	literals["rigidBody"] = 11;
37	>	literals["restraint"] = 7;
38	>	literals["rigidBody"] = 13;
39	>	literals["center"] = 17;
40	>	literals["inversion"] = 12;
41		literals["zconstraint"] = 6;
42	<	literals["cutoffGroup"] = 12;
43	<	literals["bend"] = 9;
44	<	literals["orientation"] = 16;
45	<	literals["fragment"] = 13;
46	<	literals["bond"] = 8;
42	>	literals["cutoffGroup"] = 14;
43	>	literals["bend"] = 10;
44	>	literals["orientation"] = 19;
45	>	literals["fragment"] = 15;
46	>	literals["bond"] = 9;
47		literals["molecule"] = 5;
48	<	literals["atom"] = 7;
48	>	literals["atom"] = 8;
49		}
50
51		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 149 | Line 152 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
152		theRetToken=_returnToken;
153		break;
154		}
152	–	case 0x2b /* '+' */ :
153	–	case 0x2d /* '-' */ :
154	–	case 0x2e /* '.' */ :
155	–	case 0x30 /* '0' */ :
156	–	case 0x31 /* '1' */ :
157	–	case 0x32 /* '2' */ :
158	–	case 0x33 /* '3' */ :
159	–	case 0x34 /* '4' */ :
160	–	case 0x35 /* '5' */ :
161	–	case 0x36 /* '6' */ :
162	–	case 0x37 /* '7' */ :
163	–	case 0x38 /* '8' */ :
164	–	case 0x39 /* '9' */ :
165	–	{
166	–	mNumber(true);
167	–	theRetToken=_returnToken;
168	–	break;
169	–	}
155		case 0x41 /* 'A' */ :
156		case 0x42 /* 'B' */ :
157		case 0x43 /* 'C' */ :
#	Line 225 | Line 210 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
210		theRetToken=_returnToken;
211		break;
212		}
213	+	case 0x2b /* '+' */ :
214	+	case 0x2d /* '-' */ :
215	+	case 0x2e /* '.' */ :
216	+	case 0x30 /* '0' */ :
217	+	case 0x31 /* '1' */ :
218	+	case 0x32 /* '2' */ :
219	+	case 0x33 /* '3' */ :
220	+	case 0x34 /* '4' */ :
221	+	case 0x35 /* '5' */ :
222	+	case 0x36 /* '6' */ :
223	+	case 0x37 /* '7' */ :
224	+	case 0x38 /* '8' */ :
225	+	case 0x39 /* '9' */ :
226	+	{
227	+	mNUM_INT(true);
228	+	theRetToken=_returnToken;
229	+	break;
230	+	}
231		default:
232		if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
233		mComment(true);
#	Line 473 | Line 476 | void MDLexer::mWhitespace(bool _createToken) {
476
477		}
478		if ( inputState->guessing==0 ) {
479	<	#line 259 "MDParser.g"
479	>	#line 233 "MDParser.g"
480		newline();
481	<	#line 479 "MDLexer.cpp"
481	>	#line 482 "MDLexer.cpp"
482		}
483		break;
484		}
#	Line 501 | Line 504 | void MDLexer::mWhitespace(bool _createToken) {
504
505		}
506		if ( inputState->guessing==0 ) {
507	<	#line 264 "MDParser.g"
507	>	#line 238 "MDParser.g"
508		printf("CPP_parser.g continuation line detected\n");
509		deferredNewline();
510	<	#line 508 "MDLexer.cpp"
510	>	#line 511 "MDLexer.cpp"
511		}
512		break;
513		}
#	Line 515 | Line 518 | void MDLexer::mWhitespace(bool _createToken) {
518		}
519		}
520		if ( inputState->guessing==0 ) {
521	<	#line 267 "MDParser.g"
521	>	#line 241 "MDParser.g"
522		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
523	<	#line 521 "MDLexer.cpp"
523	>	#line 524 "MDLexer.cpp"
524		}
525		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
526		_token = makeToken(_ttype);
#	Line 541 | Line 544 | void MDLexer::mComment(bool _createToken) {
544		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
545		mEndOfLine(false);
546		if ( inputState->guessing==0 ) {
547	<	#line 274 "MDParser.g"
547	>	#line 248 "MDParser.g"
548		deferredNewline();
549	<	#line 547 "MDLexer.cpp"
549	>	#line 550 "MDLexer.cpp"
550		}
551		}
552		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 555 | void MDLexer::mComment(bool _createToken) {
555		}
556		}
557		else {
558	<	goto _loop78;
558	>	goto _loop86;
559		}
560
561		}
562	<	_loop78:;
562	>	_loop86:;
563		} // ( ... )*
564		match("*/");
565		if ( inputState->guessing==0 ) {
566	<	#line 277 "MDParser.g"
566	>	#line 251 "MDParser.g"
567		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
568	<	#line 566 "MDLexer.cpp"
568	>	#line 569 "MDLexer.cpp"
569		}
570		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
571		_token = makeToken(_ttype);
#	Line 614 | Line 617 | void MDLexer::mCPPComment(bool _createToken) {
617		}
618		}
619		else {
620	<	goto _loop82;
620	>	goto _loop90;
621		}
622
623		}
624	<	_loop82:;
624	>	_loop90:;
625		} // ( ... )*
626		mEndOfLine(false);
627		if ( inputState->guessing==0 ) {
628	<	#line 283 "MDParser.g"
628	>	#line 257 "MDParser.g"
629		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
630	<	#line 628 "MDLexer.cpp"
630	>	#line 631 "MDLexer.cpp"
631		}
632		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
633		_token = makeToken(_ttype);
#	Line 642 | Line 645 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
645		match('#' /* charlit */ );
646		mLineDirective(false);
647		if ( inputState->guessing==0 ) {
648	<	#line 290 "MDParser.g"
648	>	#line 264 "MDParser.g"
649		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
650	<	#line 648 "MDLexer.cpp"
650	>	#line 651 "MDLexer.cpp"
651		}
652		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
653		_token = makeToken(_ttype);
#	Line 662 | Line 665 | void MDLexer::mLineDirective(bool _createToken) {
665		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
666
667		if ( inputState->guessing==0 ) {
668	<	#line 296 "MDParser.g"
668	>	#line 270 "MDParser.g"
669
670		deferredLineCount = 0;
671
672	<	#line 670 "MDLexer.cpp"
672	>	#line 673 "MDLexer.cpp"
673		}
674		{
675		switch ( LA(1)) {
#	Line 688 | Line 691 | void MDLexer::mLineDirective(bool _createToken) {
691		}
692		}
693		{ // ( ... )+
694	<	int _cnt87=0;
694	>	int _cnt95=0;
695		for (;;) {
696		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
697		mSpace(false);
698		}
699		else {
700	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
700	>	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
701		}
702
703	<	_cnt87++;
703	>	_cnt95++;
704		}
705	<	_loop87:;
705	>	_loop95:;
706		}  // ( ... )+
707		mDecimal(true);
708		n=_returnToken;
709		if ( inputState->guessing==0 ) {
710	<	#line 301 "MDParser.g"
711	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
712	<	#line 710 "MDLexer.cpp"
710	>	#line 275 "MDParser.g"
711	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
712	>	#line 713 "MDLexer.cpp"
713		}
714		{ // ( ... )+
715	<	int _cnt89=0;
715	>	int _cnt97=0;
716		for (;;) {
717		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
718		mSpace(false);
719		}
720		else {
721	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
721	>	if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
722		}
723
724	<	_cnt89++;
724	>	_cnt97++;
725		}
726	<	_loop89:;
726	>	_loop97:;
727		}  // ( ... )+
728		{
729		mStringLiteral(true);
730		sl=_returnToken;
731		}
732		if ( inputState->guessing==0 ) {
733	<	#line 303 "MDParser.g"
733	>	#line 277 "MDParser.g"
734		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
735	<	#line 733 "MDLexer.cpp"
735	>	#line 736 "MDLexer.cpp"
736		}
737		{ // ( ... )*
738		for (;;) {
739		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
740		{ // ( ... )+
741	<	int _cnt93=0;
741	>	int _cnt101=0;
742		for (;;) {
743		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
744		mSpace(false);
745		}
746		else {
747	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
747	>	if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
748		}
749
750	<	_cnt93++;
750	>	_cnt101++;
751		}
752	<	_loop93:;
752	>	_loop101:;
753		}  // ( ... )+
754		mDecimal(false);
755		}
756		else {
757	<	goto _loop94;
757	>	goto _loop102;
758		}
759
760		}
761	<	_loop94:;
761	>	_loop102:;
762		} // ( ... )*
763		mEndOfLine(false);
764		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 811 | void MDLexer::mDecimal(bool _createToken) {
811		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
812
813		{ // ( ... )+
814	<	int _cnt119=0;
814	>	int _cnt132=0;
815		for (;;) {
816		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
817		matchRange('0','9');
818		}
819		else {
820	<	if ( _cnt119>=1 ) { goto _loop119; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
820	>	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
821		}
822
823	<	_cnt119++;
823	>	_cnt132++;
824		}
825	<	_loop119:;
825	>	_loop132:;
826		}  // ( ... )+
827		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
828		_token = makeToken(_ttype);
#	Line 857 | Line 860 | void MDLexer::mStringLiteral(bool _createToken) {
860
861		}
862		if ( inputState->guessing==0 ) {
863	<	#line 343 "MDParser.g"
863	>	#line 317 "MDParser.g"
864		deferredNewline();
865	<	#line 863 "MDLexer.cpp"
865	>	#line 866 "MDLexer.cpp"
866		}
867		}
868		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 871 | void MDLexer::mStringLiteral(bool _createToken) {
871		}
872		}
873		else {
874	<	goto _loop104;
874	>	goto _loop112;
875		}
876
877		}
878	<	_loop104:;
878	>	_loop112:;
879		} // ( ... )*
880		match('\"' /* charlit */ );
881		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1035 | void MDLexer::mEscape(bool _createToken) {
1035		{
1036		match('x' /* charlit */ );
1037		{ // ( ... )+
1038	<	int _cnt115=0;
1038	>	int _cnt123=0;
1039		for (;;) {
1040		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1041		mDigit(false);
#	Line 1044 | Line 1047 | void MDLexer::mEscape(bool _createToken) {
1047		matchRange('A','F');
1048		}
1049		else {
1050	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1050	>	if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1051		}
1052
1053	<	_cnt115++;
1053	>	_cnt123++;
1054		}
1055	<	_loop115:;
1055	>	_loop123:;
1056		}  // ( ... )+
1057		break;
1058		}
#	Line 1081 | Line 1084 | void MDLexer::mDigit(bool _createToken) {
1084		_saveIndex=0;
1085		}
1086
1087	<	void MDLexer::mLongSuffix(bool _createToken) {
1087	>	void MDLexer::mVocabulary(bool _createToken) {
1088		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1089	<	_ttype = LongSuffix;
1089	>	_ttype = Vocabulary;
1090		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1091
1092	<	switch ( LA(1)) {
1090	<	case 0x6c /* 'l' */ :
1091	<	{
1092	<	match('l' /* charlit */ );
1093	<	break;
1094	<	}
1095	<	case 0x4c /* 'L' */ :
1096	<	{
1097	<	match('L' /* charlit */ );
1098	<	break;
1099	<	}
1100	<	default:
1101	<	{
1102	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1103	<	}
1104	<	}
1092	>	matchRange('\3',static_cast<unsigned char>('\377'));
1093		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1094		_token = makeToken(_ttype);
1095		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1110 | Line 1098 | void MDLexer::mLongSuffix(bool _createToken) {
1098		_saveIndex=0;
1099		}
1100
1101	<	void MDLexer::mUnsignedSuffix(bool _createToken) {
1101	>	void MDLexer::mID(bool _createToken) {
1102		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1103	<	_ttype = UnsignedSuffix;
1103	>	_ttype = ID;
1104		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1105
1106	+	{
1107		switch ( LA(1)) {
1108	+	case 0x61 /* 'a' */ :
1109	+	case 0x62 /* 'b' */ :
1110	+	case 0x63 /* 'c' */ :
1111	+	case 0x64 /* 'd' */ :
1112	+	case 0x65 /* 'e' */ :
1113	+	case 0x66 /* 'f' */ :
1114	+	case 0x67 /* 'g' */ :
1115	+	case 0x68 /* 'h' */ :
1116	+	case 0x69 /* 'i' */ :
1117	+	case 0x6a /* 'j' */ :
1118	+	case 0x6b /* 'k' */ :
1119	+	case 0x6c /* 'l' */ :
1120	+	case 0x6d /* 'm' */ :
1121	+	case 0x6e /* 'n' */ :
1122	+	case 0x6f /* 'o' */ :
1123	+	case 0x70 /* 'p' */ :
1124	+	case 0x71 /* 'q' */ :
1125	+	case 0x72 /* 'r' */ :
1126	+	case 0x73 /* 's' */ :
1127	+	case 0x74 /* 't' */ :
1128		case 0x75 /* 'u' */ :
1129	+	case 0x76 /* 'v' */ :
1130	+	case 0x77 /* 'w' */ :
1131	+	case 0x78 /* 'x' */ :
1132	+	case 0x79 /* 'y' */ :
1133	+	case 0x7a /* 'z' */ :
1134		{
1135	<	match('u' /* charlit */ );
1135	>	matchRange('a','z');
1136		break;
1137		}
1138	+	case 0x41 /* 'A' */ :
1139	+	case 0x42 /* 'B' */ :
1140	+	case 0x43 /* 'C' */ :
1141	+	case 0x44 /* 'D' */ :
1142	+	case 0x45 /* 'E' */ :
1143	+	case 0x46 /* 'F' */ :
1144	+	case 0x47 /* 'G' */ :
1145	+	case 0x48 /* 'H' */ :
1146	+	case 0x49 /* 'I' */ :
1147	+	case 0x4a /* 'J' */ :
1148	+	case 0x4b /* 'K' */ :
1149	+	case 0x4c /* 'L' */ :
1150	+	case 0x4d /* 'M' */ :
1151	+	case 0x4e /* 'N' */ :
1152	+	case 0x4f /* 'O' */ :
1153	+	case 0x50 /* 'P' */ :
1154	+	case 0x51 /* 'Q' */ :
1155	+	case 0x52 /* 'R' */ :
1156	+	case 0x53 /* 'S' */ :
1157	+	case 0x54 /* 'T' */ :
1158		case 0x55 /* 'U' */ :
1159	+	case 0x56 /* 'V' */ :
1160	+	case 0x57 /* 'W' */ :
1161	+	case 0x58 /* 'X' */ :
1162	+	case 0x59 /* 'Y' */ :
1163	+	case 0x5a /* 'Z' */ :
1164		{
1165	<	match('U' /* charlit */ );
1165	>	matchRange('A','Z');
1166		break;
1167		}
1168	<	default:
1168	>	case 0x5f /* '_' */ :
1169		{
1170	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1132	<	}
1133	<	}
1134	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1135	<	_token = makeToken(_ttype);
1136	<	_token->setText(text.substr(_begin, text.length()-_begin));
1137	<	}
1138	<	_returnToken = _token;
1139	<	_saveIndex=0;
1140	<	}
1141	<
1142	<	void MDLexer::mFloatSuffix(bool _createToken) {
1143	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1144	<	_ttype = FloatSuffix;
1145	<	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1146	<
1147	<	switch ( LA(1)) {
1148	<	case 0x66 /* 'f' */ :
1149	<	{
1150	<	match('f' /* charlit */ );
1170	>	match('_' /* charlit */ );
1171		break;
1172		}
1153	–	case 0x46 /* 'F' */ :
1154	–	{
1155	–	match('F' /* charlit */ );
1156	–	break;
1157	–	}
1173		default:
1174		{
1175		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1176		}
1177		}
1178	+	}
1179	+	{ // ( ... )*
1180	+	for (;;) {
1181	+	switch ( LA(1)) {
1182	+	case 0x61 /* 'a' */ :
1183	+	case 0x62 /* 'b' */ :
1184	+	case 0x63 /* 'c' */ :
1185	+	case 0x64 /* 'd' */ :
1186	+	case 0x65 /* 'e' */ :
1187	+	case 0x66 /* 'f' */ :
1188	+	case 0x67 /* 'g' */ :
1189	+	case 0x68 /* 'h' */ :
1190	+	case 0x69 /* 'i' */ :
1191	+	case 0x6a /* 'j' */ :
1192	+	case 0x6b /* 'k' */ :
1193	+	case 0x6c /* 'l' */ :
1194	+	case 0x6d /* 'm' */ :
1195	+	case 0x6e /* 'n' */ :
1196	+	case 0x6f /* 'o' */ :
1197	+	case 0x70 /* 'p' */ :
1198	+	case 0x71 /* 'q' */ :
1199	+	case 0x72 /* 'r' */ :
1200	+	case 0x73 /* 's' */ :
1201	+	case 0x74 /* 't' */ :
1202	+	case 0x75 /* 'u' */ :
1203	+	case 0x76 /* 'v' */ :
1204	+	case 0x77 /* 'w' */ :
1205	+	case 0x78 /* 'x' */ :
1206	+	case 0x79 /* 'y' */ :
1207	+	case 0x7a /* 'z' */ :
1208	+	{
1209	+	matchRange('a','z');
1210	+	break;
1211	+	}
1212	+	case 0x41 /* 'A' */ :
1213	+	case 0x42 /* 'B' */ :
1214	+	case 0x43 /* 'C' */ :
1215	+	case 0x44 /* 'D' */ :
1216	+	case 0x45 /* 'E' */ :
1217	+	case 0x46 /* 'F' */ :
1218	+	case 0x47 /* 'G' */ :
1219	+	case 0x48 /* 'H' */ :
1220	+	case 0x49 /* 'I' */ :
1221	+	case 0x4a /* 'J' */ :
1222	+	case 0x4b /* 'K' */ :
1223	+	case 0x4c /* 'L' */ :
1224	+	case 0x4d /* 'M' */ :
1225	+	case 0x4e /* 'N' */ :
1226	+	case 0x4f /* 'O' */ :
1227	+	case 0x50 /* 'P' */ :
1228	+	case 0x51 /* 'Q' */ :
1229	+	case 0x52 /* 'R' */ :
1230	+	case 0x53 /* 'S' */ :
1231	+	case 0x54 /* 'T' */ :
1232	+	case 0x55 /* 'U' */ :
1233	+	case 0x56 /* 'V' */ :
1234	+	case 0x57 /* 'W' */ :
1235	+	case 0x58 /* 'X' */ :
1236	+	case 0x59 /* 'Y' */ :
1237	+	case 0x5a /* 'Z' */ :
1238	+	{
1239	+	matchRange('A','Z');
1240	+	break;
1241	+	}
1242	+	case 0x5f /* '_' */ :
1243	+	{
1244	+	match('_' /* charlit */ );
1245	+	break;
1246	+	}
1247	+	case 0x30 /* '0' */ :
1248	+	case 0x31 /* '1' */ :
1249	+	case 0x32 /* '2' */ :
1250	+	case 0x33 /* '3' */ :
1251	+	case 0x34 /* '4' */ :
1252	+	case 0x35 /* '5' */ :
1253	+	case 0x36 /* '6' */ :
1254	+	case 0x37 /* '7' */ :
1255	+	case 0x38 /* '8' */ :
1256	+	case 0x39 /* '9' */ :
1257	+	{
1258	+	matchRange('0','9');
1259	+	break;
1260	+	}
1261	+	default:
1262	+	{
1263	+	goto _loop128;
1264	+	}
1265	+	}
1266	+	}
1267	+	_loop128:;
1268	+	} // ( ... )*
1269	+	_ttype = testLiteralsTable(_ttype);
1270		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1271		_token = makeToken(_ttype);
1272		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1168 | Line 1275 | void MDLexer::mFloatSuffix(bool _createToken) {
1275		_saveIndex=0;
1276		}
1277
1278	<	void MDLexer::mExponent(bool _createToken) {
1278	>	void MDLexer::mHEX_DIGIT(bool _createToken) {
1279		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1280	<	_ttype = Exponent;
1280	>	_ttype = HEX_DIGIT;
1281		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1282
1283		{
1284		switch ( LA(1)) {
1178	–	case 0x65 /* 'e' */ :
1179	–	{
1180	–	match('e' /* charlit */ );
1181	–	break;
1182	–	}
1183	–	case 0x45 /* 'E' */ :
1184	–	{
1185	–	match('E' /* charlit */ );
1186	–	break;
1187	–	}
1188	–	case 0x64 /* 'd' */ :
1189	–	{
1190	–	match('d' /* charlit */ );
1191	–	break;
1192	–	}
1193	–	case 0x44 /* 'D' */ :
1194	–	{
1195	–	match('D' /* charlit */ );
1196	–	break;
1197	–	}
1198	–	default:
1199	–	{
1200	–	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1201	–	}
1202	–	}
1203	–	}
1204	–	{
1205	–	switch ( LA(1)) {
1206	–	case 0x2b /* '+' */ :
1207	–	{
1208	–	match('+' /* charlit */ );
1209	–	break;
1210	–	}
1211	–	case 0x2d /* '-' */ :
1212	–	{
1213	–	match('-' /* charlit */ );
1214	–	break;
1215	–	}
1285		case 0x30 /* '0' */ :
1286		case 0x31 /* '1' */ :
1287		case 0x32 /* '2' */ :
#	Line 1224 | Line 1293 | void MDLexer::mExponent(bool _createToken) {
1293		case 0x38 /* '8' */ :
1294		case 0x39 /* '9' */ :
1295		{
1296	+	matchRange('0','9');
1297		break;
1298		}
1299	+	case 0x41 /* 'A' */ :
1300	+	case 0x42 /* 'B' */ :
1301	+	case 0x43 /* 'C' */ :
1302	+	case 0x44 /* 'D' */ :
1303	+	case 0x45 /* 'E' */ :
1304	+	case 0x46 /* 'F' */ :
1305	+	{
1306	+	matchRange('A','F');
1307	+	break;
1308	+	}
1309	+	case 0x61 /* 'a' */ :
1310	+	case 0x62 /* 'b' */ :
1311	+	case 0x63 /* 'c' */ :
1312	+	case 0x64 /* 'd' */ :
1313	+	case 0x65 /* 'e' */ :
1314	+	case 0x66 /* 'f' */ :
1315	+	{
1316	+	matchRange('a','f');
1317	+	break;
1318	+	}
1319		default:
1320		{
1321		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1322		}
1323		}
1324		}
1235	–	{ // ( ... )+
1236	–	int _cnt127=0;
1237	–	for (;;) {
1238	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1239	–	mDigit(false);
1240	–	}
1241	–	else {
1242	–	if ( _cnt127>=1 ) { goto _loop127; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1243	–	}
1244	–
1245	–	_cnt127++;
1246	–	}
1247	–	_loop127:;
1248	–	}  // ( ... )+
1325		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1326		_token = makeToken(_ttype);
1327		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1254 | Line 1330 | void MDLexer::mExponent(bool _createToken) {
1330		_saveIndex=0;
1331		}
1332
1333	<	void MDLexer::mVocabulary(bool _createToken) {
1333	>	void MDLexer::mNUM_INT(bool _createToken) {
1334		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1335	<	_ttype = Vocabulary;
1335	>	_ttype = NUM_INT;
1336		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1337	+	ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1338	+	ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1339	+	ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1340	+	ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1341	+	#line 410 "MDParser.g"
1342
1343	<	matchRange('\3',static_cast<unsigned char>('\377'));
1344	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1345	<	_token = makeToken(_ttype);
1346	<	_token->setText(text.substr(_begin, text.length()-_begin));
1266	<	}
1267	<	_returnToken = _token;
1268	<	_saveIndex=0;
1269	<	}
1270	<
1271	<	void MDLexer::mNumber(bool _createToken) {
1272	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1273	<	_ttype = Number;
1274	<	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1343	>	bool isDecimal = false;
1344	>	ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1345	>
1346	>	#line 1347 "MDLexer.cpp"
1347
1348		{
1349		switch ( LA(1)) {
#	Line 1306 | Line 1378 | void MDLexer::mNumber(bool _createToken) {
1378		}
1379		}
1380		{
1381	<	bool synPredMatched136 = false;
1382	<	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1383	<	int _m136 = mark();
1384	<	synPredMatched136 = true;
1385	<	inputState->guessing++;
1386	<	try {
1387	<	{
1381	>	switch ( LA(1)) {
1382	>	case 0x2e /* '.' */ :
1383	>	{
1384	>	match('.' /* charlit */ );
1385	>	if ( inputState->guessing==0 ) {
1386	>	#line 417 "MDParser.g"
1387	>	_ttype = DOT;
1388	>	#line 1389 "MDLexer.cpp"
1389	>	}
1390	>	{
1391	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1392		{ // ( ... )+
1393	<	int _cnt134=0;
1393	>	int _cnt140=0;
1394		for (;;) {
1395		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396	<	mDigit(false);
1396	>	matchRange('0','9');
1397		}
1398		else {
1399	<	if ( _cnt134>=1 ) { goto _loop134; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1399	>	if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1400		}
1401
1402	<	_cnt134++;
1402	>	_cnt140++;
1403		}
1404	<	_loop134:;
1404	>	_loop140:;
1405		}  // ( ... )+
1406		{
1407	<	switch ( LA(1)) {
1408	<	case 0x2e /* '.' */ :
1333	<	{
1334	<	match('.' /* charlit */ );
1335	<	break;
1407	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1408	>	mEXPONENT(false);
1409		}
1410	<	case 0x65 /* 'e' */ :
1338	<	{
1339	<	match('e' /* charlit */ );
1340	<	break;
1410	>	else {
1411		}
1412	<	case 0x45 /* 'E' */ :
1343	<	{
1344	<	match('E' /* charlit */ );
1345	<	break;
1412	>
1413		}
1347	–	case 0x64 /* 'd' */ :
1414		{
1415	<	match('d' /* charlit */ );
1416	<	break;
1415	>	if ((_tokenSet_8.member(LA(1)))) {
1416	>	mFLOAT_SUFFIX(true);
1417	>	f1=_returnToken;
1418	>	if ( inputState->guessing==0 ) {
1419	>	#line 418 "MDParser.g"
1420	>	t=f1;
1421	>	#line 1422 "MDLexer.cpp"
1422	>	}
1423		}
1424	<	case 0x44 /* 'D' */ :
1353	<	{
1354	<	match('D' /* charlit */ );
1355	<	break;
1424	>	else {
1425		}
1426	<	default:
1358	<	{
1359	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1426	>
1427		}
1428	+	if ( inputState->guessing==0 ) {
1429	+	#line 419 "MDParser.g"
1430	+
1431	+	if ( t &&
1432	+	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1433	+	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1434	+	_ttype = NUM_FLOAT;
1435	+	}
1436	+	else {
1437	+	_ttype = NUM_DOUBLE; // assume double
1438	+	}
1439	+
1440	+	#line 1441 "MDLexer.cpp"
1441		}
1362	–	}
1363	–	}
1442		}
1443	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1366	<	synPredMatched136 = false;
1443	>	else {
1444		}
1445	<	rewind(_m136);
1369	<	inputState->guessing--;
1370	<	}
1371	<	if ( synPredMatched136 ) {
1372	<	{ // ( ... )+
1373	<	int _cnt138=0;
1374	<	for (;;) {
1375	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1376	<	mDigit(false);
1377	<	}
1378	<	else {
1379	<	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1380	<	}
1381	<
1382	<	_cnt138++;
1445	>
1446		}
1447	<	_loop138:;
1448	<	}  // ( ... )+
1447	>	break;
1448	>	}
1449	>	case 0x30 /* '0' */ :
1450	>	case 0x31 /* '1' */ :
1451	>	case 0x32 /* '2' */ :
1452	>	case 0x33 /* '3' */ :
1453	>	case 0x34 /* '4' */ :
1454	>	case 0x35 /* '5' */ :
1455	>	case 0x36 /* '6' */ :
1456	>	case 0x37 /* '7' */ :
1457	>	case 0x38 /* '8' */ :
1458	>	case 0x39 /* '9' */ :
1459	>	{
1460		{
1461		switch ( LA(1)) {
1462	<	case 0x2e /* '.' */ :
1462	>	case 0x30 /* '0' */ :
1463		{
1464	<	match('.' /* charlit */ );
1465	<	{ // ( ... )*
1466	<	for (;;) {
1467	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1468	<	mDigit(false);
1464	>	match('0' /* charlit */ );
1465	>	if ( inputState->guessing==0 ) {
1466	>	#line 431 "MDParser.g"
1467	>	isDecimal = true;
1468	>	#line 1469 "MDLexer.cpp"
1469	>	}
1470	>	{
1471	>	if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
1472	>	{
1473	>	switch ( LA(1)) {
1474	>	case 0x78 /* 'x' */ :
1475	>	{
1476	>	match('x' /* charlit */ );
1477	>	break;
1478		}
1479	<	else {
1480	<	goto _loop141;
1479	>	case 0x58 /* 'X' */ :
1480	>	{
1481	>	match('X' /* charlit */ );
1482	>	break;
1483		}
1484	<
1484	>	default:
1485	>	{
1486	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1487	>	}
1488	>	}
1489	>	}
1490	>	{ // ( ... )+
1491	>	int _cnt147=0;
1492	>	for (;;) {
1493	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1494	>	mHEX_DIGIT(false);
1495	>	}
1496	>	else {
1497	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1498	>	}
1499	>
1500	>	_cnt147++;
1501	>	}
1502	>	_loop147:;
1503	>	}  // ( ... )+
1504		}
1401	–	_loop141:;
1402	–	} // ( ... )*
1403	–	{
1404	–	if ((_tokenSet_7.member(LA(1)))) {
1405	–	mExponent(false);
1406	–	}
1505		else {
1506	<	}
1507	<
1506	>	bool synPredMatched152 = false;
1507	>	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1508	>	int _m152 = mark();
1509	>	synPredMatched152 = true;
1510	>	inputState->guessing++;
1511	>	try {
1512	>	{
1513	>	{ // ( ... )+
1514	>	int _cnt150=0;
1515	>	for (;;) {
1516	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1517	>	matchRange('0','9');
1518	>	}
1519	>	else {
1520	>	if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521	>	}
1522	>
1523	>	_cnt150++;
1524	>	}
1525	>	_loop150:;
1526	>	}  // ( ... )+
1527	>	{
1528	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1529	>	mEXPONENT(false);
1530	>	}
1531	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1532	>	match('.' /* charlit */ );
1533	>	}
1534	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1535	>	mFLOAT_SUFFIX(false);
1536	>	}
1537	>	else {
1538	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1539	>	}
1540	>
1541	>	}
1542	>	}
1543	>	}
1544	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1545	>	synPredMatched152 = false;
1546	>	}
1547	>	rewind(_m152);
1548	>	inputState->guessing--;
1549	>	}
1550	>	if ( synPredMatched152 ) {
1551	>	{ // ( ... )+
1552	>	int _cnt154=0;
1553	>	for (;;) {
1554	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1555	>	matchRange('0','9');
1556	>	}
1557	>	else {
1558	>	if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1559	>	}
1560	>
1561	>	_cnt154++;
1562	>	}
1563	>	_loop154:;
1564	>	}  // ( ... )+
1565	>	}
1566	>	else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1567	>	{ // ( ... )+
1568	>	int _cnt156=0;
1569	>	for (;;) {
1570	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1571	>	matchRange('0','7');
1572	>	}
1573	>	else {
1574	>	if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575	>	}
1576	>
1577	>	_cnt156++;
1578	>	}
1579	>	_loop156:;
1580	>	}  // ( ... )+
1581	>	}
1582	>	else {
1583	>	}
1584		}
1411	–	if ( inputState->guessing==0 ) {
1412	–	#line 450 "MDParser.g"
1413	–	_ttype = FLOATONE;
1414	–	#line 1415 "MDLexer.cpp"
1585		}
1586		break;
1587		}
1588	<	case 0x44 /* 'D' */ :
1589	<	case 0x45 /* 'E' */ :
1590	<	case 0x64 /* 'd' */ :
1591	<	case 0x65 /* 'e' */ :
1588	>	case 0x31 /* '1' */ :
1589	>	case 0x32 /* '2' */ :
1590	>	case 0x33 /* '3' */ :
1591	>	case 0x34 /* '4' */ :
1592	>	case 0x35 /* '5' */ :
1593	>	case 0x36 /* '6' */ :
1594	>	case 0x37 /* '7' */ :
1595	>	case 0x38 /* '8' */ :
1596	>	case 0x39 /* '9' */ :
1597		{
1598	<	mExponent(false);
1598	>	{
1599	>	matchRange('1','9');
1600	>	}
1601	>	{ // ( ... )*
1602	>	for (;;) {
1603	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1604	>	matchRange('0','9');
1605	>	}
1606	>	else {
1607	>	goto _loop159;
1608	>	}
1609	>
1610	>	}
1611	>	_loop159:;
1612	>	} // ( ... )*
1613		if ( inputState->guessing==0 ) {
1614	<	#line 451 "MDParser.g"
1615	<	_ttype = FLOATTWO;
1616	<	#line 1428 "MDLexer.cpp"
1614	>	#line 448 "MDParser.g"
1615	>	isDecimal=true;
1616	>	#line 1617 "MDLexer.cpp"
1617		}
1618		break;
1619		}
#	Line 1435 | Line 1624 | void MDLexer::mNumber(bool _createToken) {
1624		}
1625		}
1626		{
1627	<	switch ( LA(1)) {
1439	<	case 0x46 /* 'F' */ :
1440	<	case 0x66 /* 'f' */ :
1441	<	{
1442	<	mFloatSuffix(false);
1443	<	break;
1444	<	}
1445	<	case 0x4c /* 'L' */ :
1446	<	case 0x6c /* 'l' */ :
1447	<	{
1448	<	mLongSuffix(false);
1449	<	break;
1450	<	}
1451	<	default:
1627	>	if ((LA(1) == 0x4c /* 'L' */  || LA(1) == 0x6c /* 'l' */ )) {
1628		{
1453	–	}
1454	–	}
1455	–	}
1456	–	}
1457	–	else if ((LA(1) == 0x30 /* '0' */ ) && (LA(2) == 0x58 /* 'X' */  || LA(2) == 0x78 /* 'x' */ )) {
1458	–	match('0' /* charlit */ );
1459	–	{
1460	–	switch ( LA(1)) {
1461	–	case 0x78 /* 'x' */ :
1462	–	{
1463	–	match('x' /* charlit */ );
1464	–	break;
1465	–	}
1466	–	case 0x58 /* 'X' */ :
1467	–	{
1468	–	match('X' /* charlit */ );
1469	–	break;
1470	–	}
1471	–	default:
1472	–	{
1473	–	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1474	–	}
1475	–	}
1476	–	}
1477	–	{ // ( ... )+
1478	–	int _cnt159=0;
1479	–	for (;;) {
1629		switch ( LA(1)) {
1630	<	case 0x61 /* 'a' */ :
1482	<	case 0x62 /* 'b' */ :
1483	<	case 0x63 /* 'c' */ :
1484	<	case 0x64 /* 'd' */ :
1485	<	case 0x65 /* 'e' */ :
1486	<	case 0x66 /* 'f' */ :
1630	>	case 0x6c /* 'l' */ :
1631		{
1632	<	matchRange('a','f');
1632	>	match('l' /* charlit */ );
1633		break;
1634		}
1635	<	case 0x41 /* 'A' */ :
1492	<	case 0x42 /* 'B' */ :
1493	<	case 0x43 /* 'C' */ :
1494	<	case 0x44 /* 'D' */ :
1495	<	case 0x45 /* 'E' */ :
1496	<	case 0x46 /* 'F' */ :
1635	>	case 0x4c /* 'L' */ :
1636		{
1637	<	matchRange('A','F');
1637	>	match('L' /* charlit */ );
1638		break;
1639		}
1501	–	case 0x30 /* '0' */ :
1502	–	case 0x31 /* '1' */ :
1503	–	case 0x32 /* '2' */ :
1504	–	case 0x33 /* '3' */ :
1505	–	case 0x34 /* '4' */ :
1506	–	case 0x35 /* '5' */ :
1507	–	case 0x36 /* '6' */ :
1508	–	case 0x37 /* '7' */ :
1509	–	case 0x38 /* '8' */ :
1510	–	case 0x39 /* '9' */ :
1511	–	{
1512	–	mDigit(false);
1513	–	break;
1514	–	}
1640		default:
1641		{
1642	<	if ( _cnt159>=1 ) { goto _loop159; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1642	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1643		}
1644		}
1520	–	_cnt159++;
1521	–	}
1522	–	_loop159:;
1523	–	}  // ( ... )+
1524	–	{ // ( ... )*
1525	–	for (;;) {
1526	–	switch ( LA(1)) {
1527	–	case 0x4c /* 'L' */ :
1528	–	case 0x6c /* 'l' */ :
1529	–	{
1530	–	mLongSuffix(false);
1531	–	break;
1645		}
1646	<	case 0x55 /* 'U' */ :
1647	<	case 0x75 /* 'u' */ :
1648	<	{
1649	<	mUnsignedSuffix(false);
1537	<	break;
1646	>	if ( inputState->guessing==0 ) {
1647	>	#line 450 "MDParser.g"
1648	>	_ttype = NUM_LONG;
1649	>	#line 1650 "MDLexer.cpp"
1650		}
1651	<	default:
1651	>	}
1652	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1653		{
1654	<	goto _loop161;
1654	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1655	>	mEXPONENT(false);
1656	>	{
1657	>	if ((_tokenSet_8.member(LA(1)))) {
1658	>	mFLOAT_SUFFIX(true);
1659	>	f3=_returnToken;
1660	>	if ( inputState->guessing==0 ) {
1661	>	#line 455 "MDParser.g"
1662	>	t=f3;
1663	>	#line 1664 "MDLexer.cpp"
1664	>	}
1665	>	}
1666	>	else {
1667	>	}
1668	>
1669	>	}
1670		}
1671	<	}
1672	<	}
1673	<	_loop161:;
1674	<	} // ( ... )*
1675	<	if ( inputState->guessing==0 ) {
1676	<	#line 479 "MDParser.g"
1677	<	_ttype = HEXADECIMALINT;
1678	<	#line 1551 "MDLexer.cpp"
1679	<	}
1680	<	}
1681	<	else if ((LA(1) == 0x2e /* '.' */ )) {
1554	<	match('.' /* charlit */ );
1555	<	if ( inputState->guessing==0 ) {
1556	<	#line 457 "MDParser.g"
1557	<	_ttype = DOT;
1558	<	#line 1559 "MDLexer.cpp"
1559	<	}
1560	<	{
1561	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1562	<	{ // ( ... )+
1563	<	int _cnt146=0;
1564	<	for (;;) {
1565	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1566	<	mDigit(false);
1671	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1672	>	match('.' /* charlit */ );
1673	>	{ // ( ... )*
1674	>	for (;;) {
1675	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1676	>	matchRange('0','9');
1677	>	}
1678	>	else {
1679	>	goto _loop164;
1680	>	}
1681	>
1682		}
1683	+	_loop164:;
1684	+	} // ( ... )*
1685	+	{
1686	+	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1687	+	mEXPONENT(false);
1688	+	}
1689		else {
1569	–	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1690		}
1691
1692	<	_cnt146++;
1692	>	}
1693	>	{
1694	>	if ((_tokenSet_8.member(LA(1)))) {
1695	>	mFLOAT_SUFFIX(true);
1696	>	f2=_returnToken;
1697	>	if ( inputState->guessing==0 ) {
1698	>	#line 454 "MDParser.g"
1699	>	t=f2;
1700	>	#line 1701 "MDLexer.cpp"
1701	>	}
1702	>	}
1703	>	else {
1704	>	}
1705	>
1706	>	}
1707		}
1708	<	_loop146:;
1709	<	}  // ( ... )+
1710	<	{
1711	<	if ((_tokenSet_7.member(LA(1)))) {
1712	<	mExponent(false);
1708	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1709	>	mFLOAT_SUFFIX(true);
1710	>	f4=_returnToken;
1711	>	if ( inputState->guessing==0 ) {
1712	>	#line 456 "MDParser.g"
1713	>	t=f4;
1714	>	#line 1715 "MDLexer.cpp"
1715	>	}
1716		}
1717		else {
1718	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1719		}
1720
1721		}
1722		if ( inputState->guessing==0 ) {
1723		#line 458 "MDParser.g"
1724	<	_ttype = FLOATONE;
1725	<	#line 1588 "MDLexer.cpp"
1724	>
1725	>	if ( t &&
1726	>	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1727	>	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1728	>	_ttype = NUM_FLOAT;
1729	>	}
1730	>	else {
1731	>	_ttype = NUM_DOUBLE; // assume double
1732	>	}
1733	>
1734	>	#line 1735 "MDLexer.cpp"
1735		}
1589	–	{
1590	–	switch ( LA(1)) {
1591	–	case 0x46 /* 'F' */ :
1592	–	case 0x66 /* 'f' */ :
1593	–	{
1594	–	mFloatSuffix(false);
1595	–	break;
1596	–	}
1597	–	case 0x4c /* 'L' */ :
1598	–	case 0x6c /* 'l' */ :
1599	–	{
1600	–	mLongSuffix(false);
1601	–	break;
1602	–	}
1603	–	default:
1604	–	{
1605	–	}
1606	–	}
1607	–	}
1736		}
1737		else {
1738		}
1739
1612	–	}
1613	–	}
1614	–	else if ((LA(1) == 0x30 /* '0' */ ) && (true) && (true)) {
1615	–	match('0' /* charlit */ );
1616	–	{ // ( ... )*
1617	–	for (;;) {
1618	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1619	–	matchRange('0','7');
1620	–	}
1621	–	else {
1622	–	goto _loop150;
1623	–	}
1624	–
1625	–	}
1626	–	_loop150:;
1627	–	} // ( ... )*
1628	–	{ // ( ... )*
1629	–	for (;;) {
1630	–	switch ( LA(1)) {
1631	–	case 0x4c /* 'L' */ :
1632	–	case 0x6c /* 'l' */ :
1633	–	{
1634	–	mLongSuffix(false);
1635	–	break;
1636	–	}
1637	–	case 0x55 /* 'U' */ :
1638	–	case 0x75 /* 'u' */ :
1639	–	{
1640	–	mUnsignedSuffix(false);
1641	–	break;
1642	–	}
1643	–	default:
1644	–	{
1645	–	goto _loop152;
1646	–	}
1647	–	}
1648	–	}
1649	–	_loop152:;
1650	–	} // ( ... )*
1651	–	if ( inputState->guessing==0 ) {
1652	–	#line 468 "MDParser.g"
1653	–	_ttype = OCTALINT;
1654	–	#line 1655 "MDLexer.cpp"
1740		}
1741	+	break;
1742		}
1743	<	else if (((LA(1) >= 0x31 /* '1' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
1744	<	matchRange('1','9');
1659	<	{ // ( ... )*
1660	<	for (;;) {
1661	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1662	<	mDigit(false);
1663	<	}
1664	<	else {
1665	<	goto _loop154;
1666	<	}
1667	<
1668	<	}
1669	<	_loop154:;
1670	<	} // ( ... )*
1671	<	{ // ( ... )*
1672	<	for (;;) {
1673	<	switch ( LA(1)) {
1674	<	case 0x4c /* 'L' */ :
1675	<	case 0x6c /* 'l' */ :
1676	<	{
1677	<	mLongSuffix(false);
1678	<	break;
1679	<	}
1680	<	case 0x55 /* 'U' */ :
1681	<	case 0x75 /* 'u' */ :
1682	<	{
1683	<	mUnsignedSuffix(false);
1684	<	break;
1685	<	}
1686	<	default:
1687	<	{
1688	<	goto _loop156;
1689	<	}
1690	<	}
1691	<	}
1692	<	_loop156:;
1693	<	} // ( ... )*
1694	<	if ( inputState->guessing==0 ) {
1695	<	#line 473 "MDParser.g"
1696	<	_ttype = DECIMALINT;
1697	<	#line 1698 "MDLexer.cpp"
1698	<	}
1699	<	}
1700	<	else {
1743	>	default:
1744	>	{
1745		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1746		}
1703	–
1747		}
1748	+	}
1749		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1750		_token = makeToken(_ttype);
1751		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1710 | Line 1754 | void MDLexer::mNumber(bool _createToken) {
1754		_saveIndex=0;
1755		}
1756
1757	<	void MDLexer::mID(bool _createToken) {
1757	>	void MDLexer::mEXPONENT(bool _createToken) {
1758		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1759	<	_ttype = ID;
1759	>	_ttype = EXPONENT;
1760		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1761
1762		{
1763		switch ( LA(1)) {
1720	–	case 0x61 /* 'a' */ :
1721	–	case 0x62 /* 'b' */ :
1722	–	case 0x63 /* 'c' */ :
1723	–	case 0x64 /* 'd' */ :
1764		case 0x65 /* 'e' */ :
1725	–	case 0x66 /* 'f' */ :
1726	–	case 0x67 /* 'g' */ :
1727	–	case 0x68 /* 'h' */ :
1728	–	case 0x69 /* 'i' */ :
1729	–	case 0x6a /* 'j' */ :
1730	–	case 0x6b /* 'k' */ :
1731	–	case 0x6c /* 'l' */ :
1732	–	case 0x6d /* 'm' */ :
1733	–	case 0x6e /* 'n' */ :
1734	–	case 0x6f /* 'o' */ :
1735	–	case 0x70 /* 'p' */ :
1736	–	case 0x71 /* 'q' */ :
1737	–	case 0x72 /* 'r' */ :
1738	–	case 0x73 /* 's' */ :
1739	–	case 0x74 /* 't' */ :
1740	–	case 0x75 /* 'u' */ :
1741	–	case 0x76 /* 'v' */ :
1742	–	case 0x77 /* 'w' */ :
1743	–	case 0x78 /* 'x' */ :
1744	–	case 0x79 /* 'y' */ :
1745	–	case 0x7a /* 'z' */ :
1765		{
1766	<	matchRange('a','z');
1766	>	match('e' /* charlit */ );
1767		break;
1768		}
1750	–	case 0x41 /* 'A' */ :
1751	–	case 0x42 /* 'B' */ :
1752	–	case 0x43 /* 'C' */ :
1753	–	case 0x44 /* 'D' */ :
1769		case 0x45 /* 'E' */ :
1755	–	case 0x46 /* 'F' */ :
1756	–	case 0x47 /* 'G' */ :
1757	–	case 0x48 /* 'H' */ :
1758	–	case 0x49 /* 'I' */ :
1759	–	case 0x4a /* 'J' */ :
1760	–	case 0x4b /* 'K' */ :
1761	–	case 0x4c /* 'L' */ :
1762	–	case 0x4d /* 'M' */ :
1763	–	case 0x4e /* 'N' */ :
1764	–	case 0x4f /* 'O' */ :
1765	–	case 0x50 /* 'P' */ :
1766	–	case 0x51 /* 'Q' */ :
1767	–	case 0x52 /* 'R' */ :
1768	–	case 0x53 /* 'S' */ :
1769	–	case 0x54 /* 'T' */ :
1770	–	case 0x55 /* 'U' */ :
1771	–	case 0x56 /* 'V' */ :
1772	–	case 0x57 /* 'W' */ :
1773	–	case 0x58 /* 'X' */ :
1774	–	case 0x59 /* 'Y' */ :
1775	–	case 0x5a /* 'Z' */ :
1770		{
1771	<	matchRange('A','Z');
1771	>	match('E' /* charlit */ );
1772		break;
1773		}
1774	<	case 0x5f /* '_' */ :
1774	>	case 0x64 /* 'd' */ :
1775		{
1776	<	match('_' /* charlit */ );
1776	>	match('d' /* charlit */ );
1777		break;
1778		}
1779	+	case 0x44 /* 'D' */ :
1780	+	{
1781	+	match('D' /* charlit */ );
1782	+	break;
1783	+	}
1784		default:
1785		{
1786		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1787		}
1788		}
1789		}
1790	<	{ // ( ... )*
1790	>	{
1791	>	switch ( LA(1)) {
1792	>	case 0x2b /* '+' */ :
1793	>	{
1794	>	match('+' /* charlit */ );
1795	>	break;
1796	>	}
1797	>	case 0x2d /* '-' */ :
1798	>	{
1799	>	match('-' /* charlit */ );
1800	>	break;
1801	>	}
1802	>	case 0x30 /* '0' */ :
1803	>	case 0x31 /* '1' */ :
1804	>	case 0x32 /* '2' */ :
1805	>	case 0x33 /* '3' */ :
1806	>	case 0x34 /* '4' */ :
1807	>	case 0x35 /* '5' */ :
1808	>	case 0x36 /* '6' */ :
1809	>	case 0x37 /* '7' */ :
1810	>	case 0x38 /* '8' */ :
1811	>	case 0x39 /* '9' */ :
1812	>	{
1813	>	break;
1814	>	}
1815	>	default:
1816	>	{
1817	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1818	>	}
1819	>	}
1820	>	}
1821	>	{ // ( ... )+
1822	>	int _cnt172=0;
1823		for (;;) {
1824	<	switch ( LA(1)) {
1794	<	case 0x61 /* 'a' */ :
1795	<	case 0x62 /* 'b' */ :
1796	<	case 0x63 /* 'c' */ :
1797	<	case 0x64 /* 'd' */ :
1798	<	case 0x65 /* 'e' */ :
1799	<	case 0x66 /* 'f' */ :
1800	<	case 0x67 /* 'g' */ :
1801	<	case 0x68 /* 'h' */ :
1802	<	case 0x69 /* 'i' */ :
1803	<	case 0x6a /* 'j' */ :
1804	<	case 0x6b /* 'k' */ :
1805	<	case 0x6c /* 'l' */ :
1806	<	case 0x6d /* 'm' */ :
1807	<	case 0x6e /* 'n' */ :
1808	<	case 0x6f /* 'o' */ :
1809	<	case 0x70 /* 'p' */ :
1810	<	case 0x71 /* 'q' */ :
1811	<	case 0x72 /* 'r' */ :
1812	<	case 0x73 /* 's' */ :
1813	<	case 0x74 /* 't' */ :
1814	<	case 0x75 /* 'u' */ :
1815	<	case 0x76 /* 'v' */ :
1816	<	case 0x77 /* 'w' */ :
1817	<	case 0x78 /* 'x' */ :
1818	<	case 0x79 /* 'y' */ :
1819	<	case 0x7a /* 'z' */ :
1820	<	{
1821	<	matchRange('a','z');
1822	<	break;
1823	<	}
1824	<	case 0x41 /* 'A' */ :
1825	<	case 0x42 /* 'B' */ :
1826	<	case 0x43 /* 'C' */ :
1827	<	case 0x44 /* 'D' */ :
1828	<	case 0x45 /* 'E' */ :
1829	<	case 0x46 /* 'F' */ :
1830	<	case 0x47 /* 'G' */ :
1831	<	case 0x48 /* 'H' */ :
1832	<	case 0x49 /* 'I' */ :
1833	<	case 0x4a /* 'J' */ :
1834	<	case 0x4b /* 'K' */ :
1835	<	case 0x4c /* 'L' */ :
1836	<	case 0x4d /* 'M' */ :
1837	<	case 0x4e /* 'N' */ :
1838	<	case 0x4f /* 'O' */ :
1839	<	case 0x50 /* 'P' */ :
1840	<	case 0x51 /* 'Q' */ :
1841	<	case 0x52 /* 'R' */ :
1842	<	case 0x53 /* 'S' */ :
1843	<	case 0x54 /* 'T' */ :
1844	<	case 0x55 /* 'U' */ :
1845	<	case 0x56 /* 'V' */ :
1846	<	case 0x57 /* 'W' */ :
1847	<	case 0x58 /* 'X' */ :
1848	<	case 0x59 /* 'Y' */ :
1849	<	case 0x5a /* 'Z' */ :
1850	<	{
1851	<	matchRange('A','Z');
1852	<	break;
1853	<	}
1854	<	case 0x5f /* '_' */ :
1855	<	{
1856	<	match('_' /* charlit */ );
1857	<	break;
1858	<	}
1859	<	case 0x30 /* '0' */ :
1860	<	case 0x31 /* '1' */ :
1861	<	case 0x32 /* '2' */ :
1862	<	case 0x33 /* '3' */ :
1863	<	case 0x34 /* '4' */ :
1864	<	case 0x35 /* '5' */ :
1865	<	case 0x36 /* '6' */ :
1866	<	case 0x37 /* '7' */ :
1867	<	case 0x38 /* '8' */ :
1868	<	case 0x39 /* '9' */ :
1869	<	{
1824	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1825		matchRange('0','9');
1871	–	break;
1826		}
1827	<	default:
1828	<	{
1875	<	goto _loop165;
1827	>	else {
1828	>	if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1829		}
1830	<	}
1830	>
1831	>	_cnt172++;
1832		}
1833	<	_loop165:;
1834	<	} // ( ... )*
1881	<	_ttype = testLiteralsTable(_ttype);
1833	>	_loop172:;
1834	>	}  // ( ... )+
1835		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1836		_token = makeToken(_ttype);
1837		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1887 | Line 1840 | void MDLexer::mID(bool _createToken) {
1840		_saveIndex=0;
1841		}
1842
1843	+	void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1844	+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1845	+	_ttype = FLOAT_SUFFIX;
1846	+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1847	+
1848	+	switch ( LA(1)) {
1849	+	case 0x66 /* 'f' */ :
1850	+	{
1851	+	match('f' /* charlit */ );
1852	+	break;
1853	+	}
1854	+	case 0x46 /* 'F' */ :
1855	+	{
1856	+	match('F' /* charlit */ );
1857	+	break;
1858	+	}
1859	+	case 0x64 /* 'd' */ :
1860	+	{
1861	+	match('d' /* charlit */ );
1862	+	break;
1863	+	}
1864	+	case 0x44 /* 'D' */ :
1865	+	{
1866	+	match('D' /* charlit */ );
1867	+	break;
1868	+	}
1869	+	default:
1870	+	{
1871	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1872	+	}
1873	+	}
1874	+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1875	+	_token = makeToken(_ttype);
1876	+	_token->setText(text.substr(_begin, text.length()-_begin));
1877	+	}
1878	+	_returnToken = _token;
1879	+	_saveIndex=0;
1880	+	}
1881
1882	+
1883		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1885		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
#	Line 1914 | Line 1906 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_token
1906		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1907		// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1908		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1909	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	<	// . 0 1 2 3 4 5
1909	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1910		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1911	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912	>	// + - 0 1 2 3 4 5
1913		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1914	+	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1916	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917	+	// 0 1 2 3 4 5
1918	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1919	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	+	// .
1921	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1922

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines