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 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20141024): "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;
36	<	literals["component"] = 4;
37	<	literals["rigidBody"] = 11;
33	>	literals["Quartic"] = 29;
34	>	literals["UreyBradley"] = 33;
35	>	literals["Harmonic"] = 27;
36	>	literals["flucQ"] = 23;
37	>	literals["satellites"] = 20;
38	>	literals["Opls"] = 37;
39	>	literals["cutoffGroup"] = 14;
40	>	literals["RNEMD"] = 24;
41	>	literals["constraint"] = 15;
42	>	literals["Trappe"] = 38;
43	>	literals["distance"] = 16;
44	>	literals["Cosine"] = 34;
45	>	literals["rigidBody"] = 13;
46	>	literals["fragment"] = 17;
47	>	literals["charge"] = 43;
48		literals["zconstraint"] = 6;
49	<	literals["cutoffGroup"] = 12;
50	<	literals["bend"] = 9;
51	<	literals["orientation"] = 16;
52	<	literals["fragment"] = 13;
53	<	literals["bond"] = 8;
49	>	literals["minimizer"] = 25;
50	>	literals["Cubic"] = 28;
51	>	literals["component"] = 4;
52	>	literals["GhostBend"] = 32;
53	>	literals["center"] = 19;
54	>	literals["members"] = 18;
55	>	literals["position"] = 21;
56	>	literals["Charmm"] = 36;
57	>	literals["AmberImproper"] = 39;
58	>	literals["Fixed"] = 26;
59	>	literals["Polynomial"] = 30;
60	>	literals["orientation"] = 22;
61	>	literals["bend"] = 10;
62	>	literals["torsion"] = 11;
63	>	literals["atom"] = 8;
64		literals["molecule"] = 5;
65	<	literals["atom"] = 7;
65	>	literals["CentralAtomHeight"] = 41;
66	>	literals["Morse"] = 31;
67	>	literals["restraint"] = 7;
68	>	literals["inversion"] = 12;
69	>	literals["bond"] = 9;
70	>	literals["GhostTorsion"] = 35;
71	>	literals["ImproperCosine"] = 40;
72	>	literals["Dreiding"] = 42;
73		}
74
75		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 149 | Line 176 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
176		theRetToken=_returnToken;
177		break;
178		}
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	–	}
179		case 0x41 /* 'A' */ :
180		case 0x42 /* 'B' */ :
181		case 0x43 /* 'C' */ :
#	Line 222 | Line 231 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
231		case 0x7a /* 'z' */ :
232		{
233		mID(true);
234	+	theRetToken=_returnToken;
235	+	break;
236	+	}
237	+	case 0x2b /* '+' */ :
238	+	case 0x2d /* '-' */ :
239	+	case 0x2e /* '.' */ :
240	+	case 0x30 /* '0' */ :
241	+	case 0x31 /* '1' */ :
242	+	case 0x32 /* '2' */ :
243	+	case 0x33 /* '3' */ :
244	+	case 0x34 /* '4' */ :
245	+	case 0x35 /* '5' */ :
246	+	case 0x36 /* '6' */ :
247	+	case 0x37 /* '7' */ :
248	+	case 0x38 /* '8' */ :
249	+	case 0x39 /* '9' */ :
250	+	{
251	+	mNUM_INT(true);
252		theRetToken=_returnToken;
253		break;
254		}
#	Line 473 | Line 500 | void MDLexer::mWhitespace(bool _createToken) {
500
501		}
502		if ( inputState->guessing==0 ) {
503	<	#line 259 "MDParser.g"
503	>	#line 321 "MDParser.g"
504		newline();
505	<	#line 479 "MDLexer.cpp"
505	>	#line 506 "MDLexer.cpp"
506		}
507		break;
508		}
#	Line 501 | Line 528 | void MDLexer::mWhitespace(bool _createToken) {
528
529		}
530		if ( inputState->guessing==0 ) {
531	<	#line 264 "MDParser.g"
531	>	#line 326 "MDParser.g"
532		printf("CPP_parser.g continuation line detected\n");
533		deferredNewline();
534	<	#line 508 "MDLexer.cpp"
534	>	#line 535 "MDLexer.cpp"
535		}
536		break;
537		}
#	Line 515 | Line 542 | void MDLexer::mWhitespace(bool _createToken) {
542		}
543		}
544		if ( inputState->guessing==0 ) {
545	<	#line 267 "MDParser.g"
545	>	#line 329 "MDParser.g"
546		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
547	<	#line 521 "MDLexer.cpp"
547	>	#line 548 "MDLexer.cpp"
548		}
549		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
550		_token = makeToken(_ttype);
#	Line 541 | Line 568 | void MDLexer::mComment(bool _createToken) {
568		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
569		mEndOfLine(false);
570		if ( inputState->guessing==0 ) {
571	<	#line 274 "MDParser.g"
571	>	#line 336 "MDParser.g"
572		deferredNewline();
573	<	#line 547 "MDLexer.cpp"
573	>	#line 574 "MDLexer.cpp"
574		}
575		}
576		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 579 | void MDLexer::mComment(bool _createToken) {
579		}
580		}
581		else {
582	<	goto _loop78;
582	>	goto _loop101;
583		}
584
585		}
586	<	_loop78:;
586	>	_loop101:;
587		} // ( ... )*
588		match("*/");
589		if ( inputState->guessing==0 ) {
590	<	#line 277 "MDParser.g"
590	>	#line 339 "MDParser.g"
591		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
592	<	#line 566 "MDLexer.cpp"
592	>	#line 593 "MDLexer.cpp"
593		}
594		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
595		_token = makeToken(_ttype);
#	Line 614 | Line 641 | void MDLexer::mCPPComment(bool _createToken) {
641		}
642		}
643		else {
644	<	goto _loop82;
644	>	goto _loop105;
645		}
646
647		}
648	<	_loop82:;
648	>	_loop105:;
649		} // ( ... )*
650		mEndOfLine(false);
651		if ( inputState->guessing==0 ) {
652	<	#line 283 "MDParser.g"
652	>	#line 345 "MDParser.g"
653		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
654	<	#line 628 "MDLexer.cpp"
654	>	#line 655 "MDLexer.cpp"
655		}
656		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
657		_token = makeToken(_ttype);
#	Line 642 | Line 669 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
669		match('#' /* charlit */ );
670		mLineDirective(false);
671		if ( inputState->guessing==0 ) {
672	<	#line 290 "MDParser.g"
672	>	#line 352 "MDParser.g"
673		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
674	<	#line 648 "MDLexer.cpp"
674	>	#line 675 "MDLexer.cpp"
675		}
676		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
677		_token = makeToken(_ttype);
#	Line 662 | Line 689 | void MDLexer::mLineDirective(bool _createToken) {
689		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
690
691		if ( inputState->guessing==0 ) {
692	<	#line 296 "MDParser.g"
692	>	#line 358 "MDParser.g"
693
694		deferredLineCount = 0;
695
696	<	#line 670 "MDLexer.cpp"
696	>	#line 697 "MDLexer.cpp"
697		}
698		{
699		switch ( LA(1)) {
#	Line 688 | Line 715 | void MDLexer::mLineDirective(bool _createToken) {
715		}
716		}
717		{ // ( ... )+
718	<	int _cnt87=0;
718	>	int _cnt110=0;
719		for (;;) {
720		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
721		mSpace(false);
722		}
723		else {
724	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
725		}
726
727	<	_cnt87++;
727	>	_cnt110++;
728		}
729	<	_loop87:;
729	>	_loop110:;
730		}  // ( ... )+
731		mDecimal(true);
732		n=_returnToken;
733		if ( inputState->guessing==0 ) {
734	<	#line 301 "MDParser.g"
735	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
736	<	#line 710 "MDLexer.cpp"
734	>	#line 363 "MDParser.g"
735	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
736	>	#line 737 "MDLexer.cpp"
737		}
738		{ // ( ... )+
739	<	int _cnt89=0;
739	>	int _cnt112=0;
740		for (;;) {
741		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
742		mSpace(false);
743		}
744		else {
745	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
745	>	if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
746		}
747
748	<	_cnt89++;
748	>	_cnt112++;
749		}
750	<	_loop89:;
750	>	_loop112:;
751		}  // ( ... )+
752		{
753		mStringLiteral(true);
754		sl=_returnToken;
755		}
756		if ( inputState->guessing==0 ) {
757	<	#line 303 "MDParser.g"
757	>	#line 365 "MDParser.g"
758		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
759	<	#line 733 "MDLexer.cpp"
759	>	#line 760 "MDLexer.cpp"
760		}
761		{ // ( ... )*
762		for (;;) {
763		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
764		{ // ( ... )+
765	<	int _cnt93=0;
765	>	int _cnt116=0;
766		for (;;) {
767		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
768		mSpace(false);
769		}
770		else {
771	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
771	>	if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
772		}
773
774	<	_cnt93++;
774	>	_cnt116++;
775		}
776	<	_loop93:;
776	>	_loop116:;
777		}  // ( ... )+
778		mDecimal(false);
779		}
780		else {
781	<	goto _loop94;
781	>	goto _loop117;
782		}
783
784		}
785	<	_loop94:;
785	>	_loop117:;
786		} // ( ... )*
787		mEndOfLine(false);
788		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 835 | void MDLexer::mDecimal(bool _createToken) {
835		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
836
837		{ // ( ... )+
838	<	int _cnt119=0;
838	>	int _cnt147=0;
839		for (;;) {
840		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
841		matchRange('0','9');
842		}
843		else {
844	<	if ( _cnt119>=1 ) { goto _loop119; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
844	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
845		}
846
847	<	_cnt119++;
847	>	_cnt147++;
848		}
849	<	_loop119:;
849	>	_loop147:;
850		}  // ( ... )+
851		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
852		_token = makeToken(_ttype);
#	Line 857 | Line 884 | void MDLexer::mStringLiteral(bool _createToken) {
884
885		}
886		if ( inputState->guessing==0 ) {
887	<	#line 343 "MDParser.g"
887	>	#line 405 "MDParser.g"
888		deferredNewline();
889	<	#line 863 "MDLexer.cpp"
889	>	#line 890 "MDLexer.cpp"
890		}
891		}
892		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 895 | void MDLexer::mStringLiteral(bool _createToken) {
895		}
896		}
897		else {
898	<	goto _loop104;
898	>	goto _loop127;
899		}
900
901		}
902	<	_loop104:;
902	>	_loop127:;
903		} // ( ... )*
904		match('\"' /* charlit */ );
905		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1059 | void MDLexer::mEscape(bool _createToken) {
1059		{
1060		match('x' /* charlit */ );
1061		{ // ( ... )+
1062	<	int _cnt115=0;
1062	>	int _cnt138=0;
1063		for (;;) {
1064		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1065		mDigit(false);
#	Line 1044 | Line 1071 | void MDLexer::mEscape(bool _createToken) {
1071		matchRange('A','F');
1072		}
1073		else {
1074	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1074	>	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1075		}
1076
1077	<	_cnt115++;
1077	>	_cnt138++;
1078		}
1079	<	_loop115:;
1079	>	_loop138:;
1080		}  // ( ... )+
1081		break;
1082		}
#	Line 1081 | Line 1108 | void MDLexer::mDigit(bool _createToken) {
1108		_saveIndex=0;
1109		}
1110
1111	<	void MDLexer::mLongSuffix(bool _createToken) {
1111	>	void MDLexer::mVocabulary(bool _createToken) {
1112		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1113	<	_ttype = LongSuffix;
1113	>	_ttype = Vocabulary;
1114		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1115
1116	<	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	<	}
1116	>	matchRange('\3',static_cast<unsigned char>('\377'));
1117		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1118		_token = makeToken(_ttype);
1119		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1110 | Line 1122 | void MDLexer::mLongSuffix(bool _createToken) {
1122		_saveIndex=0;
1123		}
1124
1125	<	void MDLexer::mUnsignedSuffix(bool _createToken) {
1125	>	void MDLexer::mID(bool _createToken) {
1126		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1127	<	_ttype = UnsignedSuffix;
1127	>	_ttype = ID;
1128		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1129
1130	+	{
1131		switch ( LA(1)) {
1132	+	case 0x61 /* 'a' */ :
1133	+	case 0x62 /* 'b' */ :
1134	+	case 0x63 /* 'c' */ :
1135	+	case 0x64 /* 'd' */ :
1136	+	case 0x65 /* 'e' */ :
1137	+	case 0x66 /* 'f' */ :
1138	+	case 0x67 /* 'g' */ :
1139	+	case 0x68 /* 'h' */ :
1140	+	case 0x69 /* 'i' */ :
1141	+	case 0x6a /* 'j' */ :
1142	+	case 0x6b /* 'k' */ :
1143	+	case 0x6c /* 'l' */ :
1144	+	case 0x6d /* 'm' */ :
1145	+	case 0x6e /* 'n' */ :
1146	+	case 0x6f /* 'o' */ :
1147	+	case 0x70 /* 'p' */ :
1148	+	case 0x71 /* 'q' */ :
1149	+	case 0x72 /* 'r' */ :
1150	+	case 0x73 /* 's' */ :
1151	+	case 0x74 /* 't' */ :
1152		case 0x75 /* 'u' */ :
1153	+	case 0x76 /* 'v' */ :
1154	+	case 0x77 /* 'w' */ :
1155	+	case 0x78 /* 'x' */ :
1156	+	case 0x79 /* 'y' */ :
1157	+	case 0x7a /* 'z' */ :
1158		{
1159	<	match('u' /* charlit */ );
1159	>	matchRange('a','z');
1160		break;
1161		}
1162	+	case 0x41 /* 'A' */ :
1163	+	case 0x42 /* 'B' */ :
1164	+	case 0x43 /* 'C' */ :
1165	+	case 0x44 /* 'D' */ :
1166	+	case 0x45 /* 'E' */ :
1167	+	case 0x46 /* 'F' */ :
1168	+	case 0x47 /* 'G' */ :
1169	+	case 0x48 /* 'H' */ :
1170	+	case 0x49 /* 'I' */ :
1171	+	case 0x4a /* 'J' */ :
1172	+	case 0x4b /* 'K' */ :
1173	+	case 0x4c /* 'L' */ :
1174	+	case 0x4d /* 'M' */ :
1175	+	case 0x4e /* 'N' */ :
1176	+	case 0x4f /* 'O' */ :
1177	+	case 0x50 /* 'P' */ :
1178	+	case 0x51 /* 'Q' */ :
1179	+	case 0x52 /* 'R' */ :
1180	+	case 0x53 /* 'S' */ :
1181	+	case 0x54 /* 'T' */ :
1182		case 0x55 /* 'U' */ :
1183	+	case 0x56 /* 'V' */ :
1184	+	case 0x57 /* 'W' */ :
1185	+	case 0x58 /* 'X' */ :
1186	+	case 0x59 /* 'Y' */ :
1187	+	case 0x5a /* 'Z' */ :
1188		{
1189	<	match('U' /* charlit */ );
1189	>	matchRange('A','Z');
1190		break;
1191		}
1192	<	default:
1192	>	case 0x5f /* '_' */ :
1193		{
1194	<	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 */ );
1194	>	match('_' /* charlit */ );
1195		break;
1196		}
1153	–	case 0x46 /* 'F' */ :
1154	–	{
1155	–	match('F' /* charlit */ );
1156	–	break;
1157	–	}
1197		default:
1198		{
1199		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1200		}
1201		}
1202	+	}
1203	+	{ // ( ... )*
1204	+	for (;;) {
1205	+	switch ( LA(1)) {
1206	+	case 0x61 /* 'a' */ :
1207	+	case 0x62 /* 'b' */ :
1208	+	case 0x63 /* 'c' */ :
1209	+	case 0x64 /* 'd' */ :
1210	+	case 0x65 /* 'e' */ :
1211	+	case 0x66 /* 'f' */ :
1212	+	case 0x67 /* 'g' */ :
1213	+	case 0x68 /* 'h' */ :
1214	+	case 0x69 /* 'i' */ :
1215	+	case 0x6a /* 'j' */ :
1216	+	case 0x6b /* 'k' */ :
1217	+	case 0x6c /* 'l' */ :
1218	+	case 0x6d /* 'm' */ :
1219	+	case 0x6e /* 'n' */ :
1220	+	case 0x6f /* 'o' */ :
1221	+	case 0x70 /* 'p' */ :
1222	+	case 0x71 /* 'q' */ :
1223	+	case 0x72 /* 'r' */ :
1224	+	case 0x73 /* 's' */ :
1225	+	case 0x74 /* 't' */ :
1226	+	case 0x75 /* 'u' */ :
1227	+	case 0x76 /* 'v' */ :
1228	+	case 0x77 /* 'w' */ :
1229	+	case 0x78 /* 'x' */ :
1230	+	case 0x79 /* 'y' */ :
1231	+	case 0x7a /* 'z' */ :
1232	+	{
1233	+	matchRange('a','z');
1234	+	break;
1235	+	}
1236	+	case 0x41 /* 'A' */ :
1237	+	case 0x42 /* 'B' */ :
1238	+	case 0x43 /* 'C' */ :
1239	+	case 0x44 /* 'D' */ :
1240	+	case 0x45 /* 'E' */ :
1241	+	case 0x46 /* 'F' */ :
1242	+	case 0x47 /* 'G' */ :
1243	+	case 0x48 /* 'H' */ :
1244	+	case 0x49 /* 'I' */ :
1245	+	case 0x4a /* 'J' */ :
1246	+	case 0x4b /* 'K' */ :
1247	+	case 0x4c /* 'L' */ :
1248	+	case 0x4d /* 'M' */ :
1249	+	case 0x4e /* 'N' */ :
1250	+	case 0x4f /* 'O' */ :
1251	+	case 0x50 /* 'P' */ :
1252	+	case 0x51 /* 'Q' */ :
1253	+	case 0x52 /* 'R' */ :
1254	+	case 0x53 /* 'S' */ :
1255	+	case 0x54 /* 'T' */ :
1256	+	case 0x55 /* 'U' */ :
1257	+	case 0x56 /* 'V' */ :
1258	+	case 0x57 /* 'W' */ :
1259	+	case 0x58 /* 'X' */ :
1260	+	case 0x59 /* 'Y' */ :
1261	+	case 0x5a /* 'Z' */ :
1262	+	{
1263	+	matchRange('A','Z');
1264	+	break;
1265	+	}
1266	+	case 0x5f /* '_' */ :
1267	+	{
1268	+	match('_' /* charlit */ );
1269	+	break;
1270	+	}
1271	+	case 0x30 /* '0' */ :
1272	+	case 0x31 /* '1' */ :
1273	+	case 0x32 /* '2' */ :
1274	+	case 0x33 /* '3' */ :
1275	+	case 0x34 /* '4' */ :
1276	+	case 0x35 /* '5' */ :
1277	+	case 0x36 /* '6' */ :
1278	+	case 0x37 /* '7' */ :
1279	+	case 0x38 /* '8' */ :
1280	+	case 0x39 /* '9' */ :
1281	+	{
1282	+	matchRange('0','9');
1283	+	break;
1284	+	}
1285	+	default:
1286	+	{
1287	+	goto _loop143;
1288	+	}
1289	+	}
1290	+	}
1291	+	_loop143:;
1292	+	} // ( ... )*
1293	+	_ttype = testLiteralsTable(_ttype);
1294		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1295		_token = makeToken(_ttype);
1296		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1168 | Line 1299 | void MDLexer::mFloatSuffix(bool _createToken) {
1299		_saveIndex=0;
1300		}
1301
1302	<	void MDLexer::mExponent(bool _createToken) {
1302	>	void MDLexer::mHEX_DIGIT(bool _createToken) {
1303		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1304	<	_ttype = Exponent;
1304	>	_ttype = HEX_DIGIT;
1305		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1306
1307		{
1308		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	–	}
1309		case 0x30 /* '0' */ :
1310		case 0x31 /* '1' */ :
1311		case 0x32 /* '2' */ :
#	Line 1224 | Line 1317 | void MDLexer::mExponent(bool _createToken) {
1317		case 0x38 /* '8' */ :
1318		case 0x39 /* '9' */ :
1319		{
1320	+	matchRange('0','9');
1321		break;
1322		}
1323	+	case 0x41 /* 'A' */ :
1324	+	case 0x42 /* 'B' */ :
1325	+	case 0x43 /* 'C' */ :
1326	+	case 0x44 /* 'D' */ :
1327	+	case 0x45 /* 'E' */ :
1328	+	case 0x46 /* 'F' */ :
1329	+	{
1330	+	matchRange('A','F');
1331	+	break;
1332	+	}
1333	+	case 0x61 /* 'a' */ :
1334	+	case 0x62 /* 'b' */ :
1335	+	case 0x63 /* 'c' */ :
1336	+	case 0x64 /* 'd' */ :
1337	+	case 0x65 /* 'e' */ :
1338	+	case 0x66 /* 'f' */ :
1339	+	{
1340	+	matchRange('a','f');
1341	+	break;
1342	+	}
1343		default:
1344		{
1345		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1346		}
1347		}
1348		}
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	–	}  // ( ... )+
1349		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1350		_token = makeToken(_ttype);
1351		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1254 | Line 1354 | void MDLexer::mExponent(bool _createToken) {
1354		_saveIndex=0;
1355		}
1356
1357	<	void MDLexer::mVocabulary(bool _createToken) {
1357	>	void MDLexer::mNUM_INT(bool _createToken) {
1358		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1359	<	_ttype = Vocabulary;
1359	>	_ttype = NUM_INT;
1360		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1361	+	ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1362	+	ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1363	+	ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1364	+	ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1365	+	#line 498 "MDParser.g"
1366
1367	<	matchRange('\3',static_cast<unsigned char>('\377'));
1368	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1369	<	_token = makeToken(_ttype);
1370	<	_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;
1367	>	bool isDecimal = false;
1368	>	ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1369	>
1370	>	#line 1371 "MDLexer.cpp"
1371
1372		{
1373		switch ( LA(1)) {
#	Line 1306 | Line 1402 | void MDLexer::mNumber(bool _createToken) {
1402		}
1403		}
1404		{
1405	<	bool synPredMatched136 = false;
1406	<	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1407	<	int _m136 = mark();
1408	<	synPredMatched136 = true;
1409	<	inputState->guessing++;
1410	<	try {
1411	<	{
1405	>	switch ( LA(1)) {
1406	>	case 0x2e /* '.' */ :
1407	>	{
1408	>	match('.' /* charlit */ );
1409	>	if ( inputState->guessing==0 ) {
1410	>	#line 505 "MDParser.g"
1411	>	_ttype = DOT;
1412	>	#line 1413 "MDLexer.cpp"
1413	>	}
1414	>	{
1415	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1416		{ // ( ... )+
1417	<	int _cnt134=0;
1417	>	int _cnt155=0;
1418		for (;;) {
1419		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1420	<	mDigit(false);
1420	>	matchRange('0','9');
1421		}
1422		else {
1423	<	if ( _cnt134>=1 ) { goto _loop134; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1423	>	if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1424		}
1425
1426	<	_cnt134++;
1426	>	_cnt155++;
1427		}
1428	<	_loop134:;
1428	>	_loop155:;
1429		}  // ( ... )+
1430		{
1431	<	switch ( LA(1)) {
1432	<	case 0x2e /* '.' */ :
1333	<	{
1334	<	match('.' /* charlit */ );
1335	<	break;
1431	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1432	>	mEXPONENT(false);
1433		}
1434	<	case 0x65 /* 'e' */ :
1338	<	{
1339	<	match('e' /* charlit */ );
1340	<	break;
1434	>	else {
1435		}
1436	<	case 0x45 /* 'E' */ :
1343	<	{
1344	<	match('E' /* charlit */ );
1345	<	break;
1436	>
1437		}
1347	–	case 0x64 /* 'd' */ :
1438		{
1439	<	match('d' /* charlit */ );
1440	<	break;
1441	<	}
1442	<	case 0x44 /* 'D' */ :
1443	<	{
1444	<	match('D' /* charlit */ );
1445	<	break;
1446	<	}
1357	<	default:
1358	<	{
1359	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1439	>	if ((_tokenSet_8.member(LA(1)))) {
1440	>	mFLOAT_SUFFIX(true);
1441	>	f1=_returnToken;
1442	>	if ( inputState->guessing==0 ) {
1443	>	#line 506 "MDParser.g"
1444	>	t=f1;
1445	>	#line 1446 "MDLexer.cpp"
1446	>	}
1447		}
1448	+	else {
1449		}
1450	+
1451		}
1452	+	if ( inputState->guessing==0 ) {
1453	+	#line 507 "MDParser.g"
1454	+
1455	+	if ( t &&
1456	+	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1457	+	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1458	+	_ttype = NUM_FLOAT;
1459	+	}
1460	+	else {
1461	+	_ttype = NUM_DOUBLE; // assume double
1462	+	}
1463	+
1464	+	#line 1465 "MDLexer.cpp"
1465		}
1466		}
1467	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1366	<	synPredMatched136 = false;
1467	>	else {
1468		}
1469	<	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++;
1469	>
1470		}
1471	<	_loop138:;
1472	<	}  // ( ... )+
1471	>	break;
1472	>	}
1473	>	case 0x30 /* '0' */ :
1474	>	case 0x31 /* '1' */ :
1475	>	case 0x32 /* '2' */ :
1476	>	case 0x33 /* '3' */ :
1477	>	case 0x34 /* '4' */ :
1478	>	case 0x35 /* '5' */ :
1479	>	case 0x36 /* '6' */ :
1480	>	case 0x37 /* '7' */ :
1481	>	case 0x38 /* '8' */ :
1482	>	case 0x39 /* '9' */ :
1483	>	{
1484		{
1485		switch ( LA(1)) {
1486	<	case 0x2e /* '.' */ :
1486	>	case 0x30 /* '0' */ :
1487		{
1488	<	match('.' /* charlit */ );
1489	<	{ // ( ... )*
1490	<	for (;;) {
1491	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1492	<	mDigit(false);
1488	>	match('0' /* charlit */ );
1489	>	if ( inputState->guessing==0 ) {
1490	>	#line 519 "MDParser.g"
1491	>	isDecimal = true;
1492	>	#line 1493 "MDLexer.cpp"
1493	>	}
1494	>	{
1495	>	if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
1496	>	{
1497	>	switch ( LA(1)) {
1498	>	case 0x78 /* 'x' */ :
1499	>	{
1500	>	match('x' /* charlit */ );
1501	>	break;
1502		}
1503	<	else {
1504	<	goto _loop141;
1503	>	case 0x58 /* 'X' */ :
1504	>	{
1505	>	match('X' /* charlit */ );
1506	>	break;
1507		}
1508	<
1508	>	default:
1509	>	{
1510	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1511	>	}
1512	>	}
1513	>	}
1514	>	{ // ( ... )+
1515	>	int _cnt162=0;
1516	>	for (;;) {
1517	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1518	>	mHEX_DIGIT(false);
1519	>	}
1520	>	else {
1521	>	if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1522	>	}
1523	>
1524	>	_cnt162++;
1525	>	}
1526	>	_loop162:;
1527	>	}  // ( ... )+
1528		}
1401	–	_loop141:;
1402	–	} // ( ... )*
1403	–	{
1404	–	if ((_tokenSet_7.member(LA(1)))) {
1405	–	mExponent(false);
1406	–	}
1529		else {
1530	<	}
1531	<
1530	>	bool synPredMatched167 = false;
1531	>	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1532	>	int _m167 = mark();
1533	>	synPredMatched167 = true;
1534	>	inputState->guessing++;
1535	>	try {
1536	>	{
1537	>	{ // ( ... )+
1538	>	int _cnt165=0;
1539	>	for (;;) {
1540	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1541	>	matchRange('0','9');
1542	>	}
1543	>	else {
1544	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1545	>	}
1546	>
1547	>	_cnt165++;
1548	>	}
1549	>	_loop165:;
1550	>	}  // ( ... )+
1551	>	{
1552	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1553	>	mEXPONENT(false);
1554	>	}
1555	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1556	>	match('.' /* charlit */ );
1557	>	}
1558	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1559	>	mFLOAT_SUFFIX(false);
1560	>	}
1561	>	else {
1562	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1563	>	}
1564	>
1565	>	}
1566	>	}
1567	>	}
1568	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1569	>	synPredMatched167 = false;
1570	>	}
1571	>	rewind(_m167);
1572	>	inputState->guessing--;
1573	>	}
1574	>	if ( synPredMatched167 ) {
1575	>	{ // ( ... )+
1576	>	int _cnt169=0;
1577	>	for (;;) {
1578	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1579	>	matchRange('0','9');
1580	>	}
1581	>	else {
1582	>	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1583	>	}
1584	>
1585	>	_cnt169++;
1586	>	}
1587	>	_loop169:;
1588	>	}  // ( ... )+
1589	>	}
1590	>	else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1591	>	{ // ( ... )+
1592	>	int _cnt171=0;
1593	>	for (;;) {
1594	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1595	>	matchRange('0','7');
1596	>	}
1597	>	else {
1598	>	if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1599	>	}
1600	>
1601	>	_cnt171++;
1602	>	}
1603	>	_loop171:;
1604	>	}  // ( ... )+
1605	>	}
1606	>	else {
1607	>	}
1608		}
1411	–	if ( inputState->guessing==0 ) {
1412	–	#line 450 "MDParser.g"
1413	–	_ttype = FLOATONE;
1414	–	#line 1415 "MDLexer.cpp"
1609		}
1610		break;
1611		}
1612	<	case 0x44 /* 'D' */ :
1613	<	case 0x45 /* 'E' */ :
1614	<	case 0x64 /* 'd' */ :
1615	<	case 0x65 /* 'e' */ :
1612	>	case 0x31 /* '1' */ :
1613	>	case 0x32 /* '2' */ :
1614	>	case 0x33 /* '3' */ :
1615	>	case 0x34 /* '4' */ :
1616	>	case 0x35 /* '5' */ :
1617	>	case 0x36 /* '6' */ :
1618	>	case 0x37 /* '7' */ :
1619	>	case 0x38 /* '8' */ :
1620	>	case 0x39 /* '9' */ :
1621		{
1622	<	mExponent(false);
1622	>	{
1623	>	matchRange('1','9');
1624	>	}
1625	>	{ // ( ... )*
1626	>	for (;;) {
1627	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1628	>	matchRange('0','9');
1629	>	}
1630	>	else {
1631	>	goto _loop174;
1632	>	}
1633	>
1634	>	}
1635	>	_loop174:;
1636	>	} // ( ... )*
1637		if ( inputState->guessing==0 ) {
1638	<	#line 451 "MDParser.g"
1639	<	_ttype = FLOATTWO;
1640	<	#line 1428 "MDLexer.cpp"
1638	>	#line 536 "MDParser.g"
1639	>	isDecimal=true;
1640	>	#line 1641 "MDLexer.cpp"
1641		}
1642		break;
1643		}
#	Line 1435 | Line 1648 | void MDLexer::mNumber(bool _createToken) {
1648		}
1649		}
1650		{
1651	<	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:
1651	>	if ((LA(1) == 0x4c /* 'L' */  || LA(1) == 0x6c /* 'l' */ )) {
1652		{
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 (;;) {
1653		switch ( LA(1)) {
1654	<	case 0x61 /* 'a' */ :
1482	<	case 0x62 /* 'b' */ :
1483	<	case 0x63 /* 'c' */ :
1484	<	case 0x64 /* 'd' */ :
1485	<	case 0x65 /* 'e' */ :
1486	<	case 0x66 /* 'f' */ :
1654	>	case 0x6c /* 'l' */ :
1655		{
1656	<	matchRange('a','f');
1656	>	match('l' /* charlit */ );
1657		break;
1658		}
1659	<	case 0x41 /* 'A' */ :
1492	<	case 0x42 /* 'B' */ :
1493	<	case 0x43 /* 'C' */ :
1494	<	case 0x44 /* 'D' */ :
1495	<	case 0x45 /* 'E' */ :
1496	<	case 0x46 /* 'F' */ :
1659	>	case 0x4c /* 'L' */ :
1660		{
1661	<	matchRange('A','F');
1661	>	match('L' /* charlit */ );
1662		break;
1663		}
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	–	}
1664		default:
1665		{
1666	<	if ( _cnt159>=1 ) { goto _loop159; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1666	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1667		}
1668		}
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;
1669		}
1670	<	case 0x55 /* 'U' */ :
1671	<	case 0x75 /* 'u' */ :
1672	<	{
1673	<	mUnsignedSuffix(false);
1537	<	break;
1670	>	if ( inputState->guessing==0 ) {
1671	>	#line 538 "MDParser.g"
1672	>	_ttype = NUM_LONG;
1673	>	#line 1674 "MDLexer.cpp"
1674		}
1675	<	default:
1675	>	}
1676	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1677		{
1678	<	goto _loop161;
1678	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1679	>	mEXPONENT(false);
1680	>	{
1681	>	if ((_tokenSet_8.member(LA(1)))) {
1682	>	mFLOAT_SUFFIX(true);
1683	>	f3=_returnToken;
1684	>	if ( inputState->guessing==0 ) {
1685	>	#line 543 "MDParser.g"
1686	>	t=f3;
1687	>	#line 1688 "MDLexer.cpp"
1688	>	}
1689	>	}
1690	>	else {
1691	>	}
1692	>
1693	>	}
1694		}
1695	<	}
1696	<	}
1697	<	_loop161:;
1698	<	} // ( ... )*
1699	<	if ( inputState->guessing==0 ) {
1700	<	#line 479 "MDParser.g"
1701	<	_ttype = HEXADECIMALINT;
1702	<	#line 1551 "MDLexer.cpp"
1703	<	}
1704	<	}
1705	<	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);
1695	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1696	>	match('.' /* charlit */ );
1697	>	{ // ( ... )*
1698	>	for (;;) {
1699	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1700	>	matchRange('0','9');
1701	>	}
1702	>	else {
1703	>	goto _loop179;
1704	>	}
1705	>
1706		}
1707	+	_loop179:;
1708	+	} // ( ... )*
1709	+	{
1710	+	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1711	+	mEXPONENT(false);
1712	+	}
1713		else {
1569	–	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1714		}
1715
1716	<	_cnt146++;
1716	>	}
1717	>	{
1718	>	if ((_tokenSet_8.member(LA(1)))) {
1719	>	mFLOAT_SUFFIX(true);
1720	>	f2=_returnToken;
1721	>	if ( inputState->guessing==0 ) {
1722	>	#line 542 "MDParser.g"
1723	>	t=f2;
1724	>	#line 1725 "MDLexer.cpp"
1725	>	}
1726	>	}
1727	>	else {
1728	>	}
1729	>
1730	>	}
1731		}
1732	<	_loop146:;
1733	<	}  // ( ... )+
1734	<	{
1735	<	if ((_tokenSet_7.member(LA(1)))) {
1736	<	mExponent(false);
1732	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1733	>	mFLOAT_SUFFIX(true);
1734	>	f4=_returnToken;
1735	>	if ( inputState->guessing==0 ) {
1736	>	#line 544 "MDParser.g"
1737	>	t=f4;
1738	>	#line 1739 "MDLexer.cpp"
1739	>	}
1740		}
1741		else {
1742	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1743		}
1744
1745		}
1746		if ( inputState->guessing==0 ) {
1747	<	#line 458 "MDParser.g"
1748	<	_ttype = FLOATONE;
1749	<	#line 1588 "MDLexer.cpp"
1747	>	#line 546 "MDParser.g"
1748	>
1749	>	if ( t &&
1750	>	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1751	>	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1752	>	_ttype = NUM_FLOAT;
1753	>	}
1754	>	else {
1755	>	_ttype = NUM_DOUBLE; // assume double
1756	>	}
1757	>
1758	>	#line 1759 "MDLexer.cpp"
1759		}
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	–	}
1760		}
1761		else {
1762		}
1763
1764		}
1765	<	}
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"
1655	<	}
1765	>	break;
1766		}
1767	<	else if (((LA(1) >= 0x31 /* '1' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
1768	<	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 {
1767	>	default:
1768	>	{
1769		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1770		}
1703	–
1771		}
1772	+	}
1773		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1774		_token = makeToken(_ttype);
1775		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1710 | Line 1778 | void MDLexer::mNumber(bool _createToken) {
1778		_saveIndex=0;
1779		}
1780
1781	<	void MDLexer::mID(bool _createToken) {
1781	>	void MDLexer::mEXPONENT(bool _createToken) {
1782		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1783	<	_ttype = ID;
1783	>	_ttype = EXPONENT;
1784		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1785
1786		{
1787		switch ( LA(1)) {
1720	–	case 0x61 /* 'a' */ :
1721	–	case 0x62 /* 'b' */ :
1722	–	case 0x63 /* 'c' */ :
1723	–	case 0x64 /* 'd' */ :
1788		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' */ :
1789		{
1790	<	matchRange('a','z');
1790	>	match('e' /* charlit */ );
1791		break;
1792		}
1750	–	case 0x41 /* 'A' */ :
1751	–	case 0x42 /* 'B' */ :
1752	–	case 0x43 /* 'C' */ :
1753	–	case 0x44 /* 'D' */ :
1793		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' */ :
1794		{
1795	<	matchRange('A','Z');
1795	>	match('E' /* charlit */ );
1796		break;
1797		}
1798	<	case 0x5f /* '_' */ :
1798	>	case 0x64 /* 'd' */ :
1799		{
1800	<	match('_' /* charlit */ );
1800	>	match('d' /* charlit */ );
1801		break;
1802		}
1803	+	case 0x44 /* 'D' */ :
1804	+	{
1805	+	match('D' /* charlit */ );
1806	+	break;
1807	+	}
1808		default:
1809		{
1810		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1811		}
1812		}
1813		}
1814	<	{ // ( ... )*
1814	>	{
1815	>	switch ( LA(1)) {
1816	>	case 0x2b /* '+' */ :
1817	>	{
1818	>	match('+' /* charlit */ );
1819	>	break;
1820	>	}
1821	>	case 0x2d /* '-' */ :
1822	>	{
1823	>	match('-' /* charlit */ );
1824	>	break;
1825	>	}
1826	>	case 0x30 /* '0' */ :
1827	>	case 0x31 /* '1' */ :
1828	>	case 0x32 /* '2' */ :
1829	>	case 0x33 /* '3' */ :
1830	>	case 0x34 /* '4' */ :
1831	>	case 0x35 /* '5' */ :
1832	>	case 0x36 /* '6' */ :
1833	>	case 0x37 /* '7' */ :
1834	>	case 0x38 /* '8' */ :
1835	>	case 0x39 /* '9' */ :
1836	>	{
1837	>	break;
1838	>	}
1839	>	default:
1840	>	{
1841	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1842	>	}
1843	>	}
1844	>	}
1845	>	{ // ( ... )+
1846	>	int _cnt187=0;
1847		for (;;) {
1848	<	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	<	{
1848	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1849		matchRange('0','9');
1871	–	break;
1850		}
1851	<	default:
1852	<	{
1875	<	goto _loop165;
1851	>	else {
1852	>	if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1853		}
1854	<	}
1854	>
1855	>	_cnt187++;
1856		}
1857	<	_loop165:;
1858	<	} // ( ... )*
1881	<	_ttype = testLiteralsTable(_ttype);
1857	>	_loop187:;
1858	>	}  // ( ... )+
1859		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1860		_token = makeToken(_ttype);
1861		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1887 | Line 1864 | void MDLexer::mID(bool _createToken) {
1864		_saveIndex=0;
1865		}
1866
1867	+	void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1868	+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1869	+	_ttype = FLOAT_SUFFIX;
1870	+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1871	+
1872	+	switch ( LA(1)) {
1873	+	case 0x66 /* 'f' */ :
1874	+	{
1875	+	match('f' /* charlit */ );
1876	+	break;
1877	+	}
1878	+	case 0x46 /* 'F' */ :
1879	+	{
1880	+	match('F' /* charlit */ );
1881	+	break;
1882	+	}
1883	+	case 0x64 /* 'd' */ :
1884	+	{
1885	+	match('d' /* charlit */ );
1886	+	break;
1887	+	}
1888	+	case 0x44 /* 'D' */ :
1889	+	{
1890	+	match('D' /* charlit */ );
1891	+	break;
1892	+	}
1893	+	default:
1894	+	{
1895	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1896	+	}
1897	+	}
1898	+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1899	+	_token = makeToken(_ttype);
1900	+	_token->setText(text.substr(_begin, text.length()-_begin));
1901	+	}
1902	+	_returnToken = _token;
1903	+	_saveIndex=0;
1904	+	}
1905
1906	+
1907		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1909		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1910	<	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1910	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C
1911	>	// D E F G H I J K L M
1912		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1913		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1915		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1916	<	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1916	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
1917	>	// C D E F G H I J K L M
1918		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1919		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	<	// \" \' 0 1 2 3 4 5
1920	>	// \" \' 0 1 2 3 4 5 6 7 ?
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1922		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1924		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1925	<	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1925	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D
1926	>	// E F G H I J K L M
1927		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1928		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1929	<	// \' 0 1 2 3 4 5
1929	>	// \' 0 1 2 3 4 5 6 7 8 9 A B C D E F
1930		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1931		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1932		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1933		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1934	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1934	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
1935	>	// @ A B C D E F G H I J K L M
1936		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1937	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1938	<	// . 0 1 2 3 4 5
1937	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1938	>	// D E
1939		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1940	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1940	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1941	>	// + - 0 1 2 3 4 5 6 7 8 9
1942		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1943	+	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1944	+	// D F
1945	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1946	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1947	+	// 0 1 2 3 4 5 6 7 8 9 A B C D E F
1948	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1949	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1950	+	// . D E F
1951	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1952

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
Revision 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

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

Diff Legend

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