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 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20140107): "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["flucQ"] = 23;
34	>	literals["satellites"] = 20;
35	>	literals["cutoffGroup"] = 14;
36	>	literals["RNEMD"] = 24;
37	>	literals["constraint"] = 15;
38	>	literals["distance"] = 16;
39	>	literals["rigidBody"] = 13;
40	>	literals["fragment"] = 17;
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["minimizer"] = 25;
43	>	literals["component"] = 4;
44	>	literals["center"] = 19;
45	>	literals["members"] = 18;
46	>	literals["position"] = 21;
47	>	literals["orientation"] = 22;
48	>	literals["bend"] = 10;
49	>	literals["torsion"] = 11;
50	>	literals["atom"] = 8;
51		literals["molecule"] = 5;
52	<	literals["atom"] = 7;
52	>	literals["restraint"] = 7;
53	>	literals["inversion"] = 12;
54	>	literals["bond"] = 9;
55		}
56
57		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 149 | Line 158 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
158		theRetToken=_returnToken;
159		break;
160		}
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	–	}
161		case 0x41 /* 'A' */ :
162		case 0x42 /* 'B' */ :
163		case 0x43 /* 'C' */ :
#	Line 225 | Line 216 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
216		theRetToken=_returnToken;
217		break;
218		}
219	+	case 0x2b /* '+' */ :
220	+	case 0x2d /* '-' */ :
221	+	case 0x2e /* '.' */ :
222	+	case 0x30 /* '0' */ :
223	+	case 0x31 /* '1' */ :
224	+	case 0x32 /* '2' */ :
225	+	case 0x33 /* '3' */ :
226	+	case 0x34 /* '4' */ :
227	+	case 0x35 /* '5' */ :
228	+	case 0x36 /* '6' */ :
229	+	case 0x37 /* '7' */ :
230	+	case 0x38 /* '8' */ :
231	+	case 0x39 /* '9' */ :
232	+	{
233	+	mNUM_INT(true);
234	+	theRetToken=_returnToken;
235	+	break;
236	+	}
237		default:
238		if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
239		mComment(true);
#	Line 473 | Line 482 | void MDLexer::mWhitespace(bool _createToken) {
482
483		}
484		if ( inputState->guessing==0 ) {
485	<	#line 259 "MDParser.g"
485	>	#line 264 "MDParser.g"
486		newline();
487	<	#line 479 "MDLexer.cpp"
487	>	#line 488 "MDLexer.cpp"
488		}
489		break;
490		}
#	Line 501 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510
511		}
512		if ( inputState->guessing==0 ) {
513	<	#line 264 "MDParser.g"
513	>	#line 269 "MDParser.g"
514		printf("CPP_parser.g continuation line detected\n");
515		deferredNewline();
516	<	#line 508 "MDLexer.cpp"
516	>	#line 517 "MDLexer.cpp"
517		}
518		break;
519		}
#	Line 515 | Line 524 | void MDLexer::mWhitespace(bool _createToken) {
524		}
525		}
526		if ( inputState->guessing==0 ) {
527	<	#line 267 "MDParser.g"
527	>	#line 272 "MDParser.g"
528		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
529	<	#line 521 "MDLexer.cpp"
529	>	#line 530 "MDLexer.cpp"
530		}
531		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
532		_token = makeToken(_ttype);
#	Line 541 | Line 550 | void MDLexer::mComment(bool _createToken) {
550		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
551		mEndOfLine(false);
552		if ( inputState->guessing==0 ) {
553	<	#line 274 "MDParser.g"
553	>	#line 279 "MDParser.g"
554		deferredNewline();
555	<	#line 547 "MDLexer.cpp"
555	>	#line 556 "MDLexer.cpp"
556		}
557		}
558		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 561 | void MDLexer::mComment(bool _createToken) {
561		}
562		}
563		else {
564	<	goto _loop78;
564	>	goto _loop101;
565		}
566
567		}
568	<	_loop78:;
568	>	_loop101:;
569		} // ( ... )*
570		match("*/");
571		if ( inputState->guessing==0 ) {
572	<	#line 277 "MDParser.g"
572	>	#line 282 "MDParser.g"
573		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
574	<	#line 566 "MDLexer.cpp"
574	>	#line 575 "MDLexer.cpp"
575		}
576		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
577		_token = makeToken(_ttype);
#	Line 614 | Line 623 | void MDLexer::mCPPComment(bool _createToken) {
623		}
624		}
625		else {
626	<	goto _loop82;
626	>	goto _loop105;
627		}
628
629		}
630	<	_loop82:;
630	>	_loop105:;
631		} // ( ... )*
632		mEndOfLine(false);
633		if ( inputState->guessing==0 ) {
634	<	#line 283 "MDParser.g"
634	>	#line 288 "MDParser.g"
635		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
636	<	#line 628 "MDLexer.cpp"
636	>	#line 637 "MDLexer.cpp"
637		}
638		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
639		_token = makeToken(_ttype);
#	Line 642 | Line 651 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
651		match('#' /* charlit */ );
652		mLineDirective(false);
653		if ( inputState->guessing==0 ) {
654	<	#line 290 "MDParser.g"
654	>	#line 295 "MDParser.g"
655		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
656	<	#line 648 "MDLexer.cpp"
656	>	#line 657 "MDLexer.cpp"
657		}
658		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
659		_token = makeToken(_ttype);
#	Line 662 | Line 671 | void MDLexer::mLineDirective(bool _createToken) {
671		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
672
673		if ( inputState->guessing==0 ) {
674	<	#line 296 "MDParser.g"
674	>	#line 301 "MDParser.g"
675
676		deferredLineCount = 0;
677
678	<	#line 670 "MDLexer.cpp"
678	>	#line 679 "MDLexer.cpp"
679		}
680		{
681		switch ( LA(1)) {
#	Line 688 | Line 697 | void MDLexer::mLineDirective(bool _createToken) {
697		}
698		}
699		{ // ( ... )+
700	<	int _cnt87=0;
700	>	int _cnt110=0;
701		for (;;) {
702		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
703		mSpace(false);
704		}
705		else {
706	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
706	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
707		}
708
709	<	_cnt87++;
709	>	_cnt110++;
710		}
711	<	_loop87:;
711	>	_loop110:;
712		}  // ( ... )+
713		mDecimal(true);
714		n=_returnToken;
715		if ( inputState->guessing==0 ) {
716	<	#line 301 "MDParser.g"
717	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
718	<	#line 710 "MDLexer.cpp"
716	>	#line 306 "MDParser.g"
717	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
718	>	#line 719 "MDLexer.cpp"
719		}
720		{ // ( ... )+
721	<	int _cnt89=0;
721	>	int _cnt112=0;
722		for (;;) {
723		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
724		mSpace(false);
725		}
726		else {
727	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
727	>	if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
728		}
729
730	<	_cnt89++;
730	>	_cnt112++;
731		}
732	<	_loop89:;
732	>	_loop112:;
733		}  // ( ... )+
734		{
735		mStringLiteral(true);
736		sl=_returnToken;
737		}
738		if ( inputState->guessing==0 ) {
739	<	#line 303 "MDParser.g"
739	>	#line 308 "MDParser.g"
740		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
741	<	#line 733 "MDLexer.cpp"
741	>	#line 742 "MDLexer.cpp"
742		}
743		{ // ( ... )*
744		for (;;) {
745		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746		{ // ( ... )+
747	<	int _cnt93=0;
747	>	int _cnt116=0;
748		for (;;) {
749		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
750		mSpace(false);
751		}
752		else {
753	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
753	>	if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
754		}
755
756	<	_cnt93++;
756	>	_cnt116++;
757		}
758	<	_loop93:;
758	>	_loop116:;
759		}  // ( ... )+
760		mDecimal(false);
761		}
762		else {
763	<	goto _loop94;
763	>	goto _loop117;
764		}
765
766		}
767	<	_loop94:;
767	>	_loop117:;
768		} // ( ... )*
769		mEndOfLine(false);
770		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 817 | void MDLexer::mDecimal(bool _createToken) {
817		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
818
819		{ // ( ... )+
820	<	int _cnt119=0;
820	>	int _cnt147=0;
821		for (;;) {
822		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
823		matchRange('0','9');
824		}
825		else {
826	<	if ( _cnt119>=1 ) { goto _loop119; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
826	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
827		}
828
829	<	_cnt119++;
829	>	_cnt147++;
830		}
831	<	_loop119:;
831	>	_loop147:;
832		}  // ( ... )+
833		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
834		_token = makeToken(_ttype);
#	Line 857 | Line 866 | void MDLexer::mStringLiteral(bool _createToken) {
866
867		}
868		if ( inputState->guessing==0 ) {
869	<	#line 343 "MDParser.g"
869	>	#line 348 "MDParser.g"
870		deferredNewline();
871	<	#line 863 "MDLexer.cpp"
871	>	#line 872 "MDLexer.cpp"
872		}
873		}
874		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 877 | void MDLexer::mStringLiteral(bool _createToken) {
877		}
878		}
879		else {
880	<	goto _loop104;
880	>	goto _loop127;
881		}
882
883		}
884	<	_loop104:;
884	>	_loop127:;
885		} // ( ... )*
886		match('\"' /* charlit */ );
887		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1041 | void MDLexer::mEscape(bool _createToken) {
1041		{
1042		match('x' /* charlit */ );
1043		{ // ( ... )+
1044	<	int _cnt115=0;
1044	>	int _cnt138=0;
1045		for (;;) {
1046		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1047		mDigit(false);
#	Line 1044 | Line 1053 | void MDLexer::mEscape(bool _createToken) {
1053		matchRange('A','F');
1054		}
1055		else {
1056	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1056	>	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1057		}
1058
1059	<	_cnt115++;
1059	>	_cnt138++;
1060		}
1061	<	_loop115:;
1061	>	_loop138:;
1062		}  // ( ... )+
1063		break;
1064		}
#	Line 1081 | Line 1090 | void MDLexer::mDigit(bool _createToken) {
1090		_saveIndex=0;
1091		}
1092
1093	<	void MDLexer::mLongSuffix(bool _createToken) {
1093	>	void MDLexer::mVocabulary(bool _createToken) {
1094		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1095	<	_ttype = LongSuffix;
1095	>	_ttype = Vocabulary;
1096		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1097
1098	<	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	<	}
1098	>	matchRange('\3',static_cast<unsigned char>('\377'));
1099		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1100		_token = makeToken(_ttype);
1101		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1110 | Line 1104 | void MDLexer::mLongSuffix(bool _createToken) {
1104		_saveIndex=0;
1105		}
1106
1107	<	void MDLexer::mUnsignedSuffix(bool _createToken) {
1107	>	void MDLexer::mID(bool _createToken) {
1108		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1109	<	_ttype = UnsignedSuffix;
1109	>	_ttype = ID;
1110		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1111
1112	+	{
1113		switch ( LA(1)) {
1114	+	case 0x61 /* 'a' */ :
1115	+	case 0x62 /* 'b' */ :
1116	+	case 0x63 /* 'c' */ :
1117	+	case 0x64 /* 'd' */ :
1118	+	case 0x65 /* 'e' */ :
1119	+	case 0x66 /* 'f' */ :
1120	+	case 0x67 /* 'g' */ :
1121	+	case 0x68 /* 'h' */ :
1122	+	case 0x69 /* 'i' */ :
1123	+	case 0x6a /* 'j' */ :
1124	+	case 0x6b /* 'k' */ :
1125	+	case 0x6c /* 'l' */ :
1126	+	case 0x6d /* 'm' */ :
1127	+	case 0x6e /* 'n' */ :
1128	+	case 0x6f /* 'o' */ :
1129	+	case 0x70 /* 'p' */ :
1130	+	case 0x71 /* 'q' */ :
1131	+	case 0x72 /* 'r' */ :
1132	+	case 0x73 /* 's' */ :
1133	+	case 0x74 /* 't' */ :
1134		case 0x75 /* 'u' */ :
1135	+	case 0x76 /* 'v' */ :
1136	+	case 0x77 /* 'w' */ :
1137	+	case 0x78 /* 'x' */ :
1138	+	case 0x79 /* 'y' */ :
1139	+	case 0x7a /* 'z' */ :
1140		{
1141	<	match('u' /* charlit */ );
1141	>	matchRange('a','z');
1142		break;
1143		}
1144	+	case 0x41 /* 'A' */ :
1145	+	case 0x42 /* 'B' */ :
1146	+	case 0x43 /* 'C' */ :
1147	+	case 0x44 /* 'D' */ :
1148	+	case 0x45 /* 'E' */ :
1149	+	case 0x46 /* 'F' */ :
1150	+	case 0x47 /* 'G' */ :
1151	+	case 0x48 /* 'H' */ :
1152	+	case 0x49 /* 'I' */ :
1153	+	case 0x4a /* 'J' */ :
1154	+	case 0x4b /* 'K' */ :
1155	+	case 0x4c /* 'L' */ :
1156	+	case 0x4d /* 'M' */ :
1157	+	case 0x4e /* 'N' */ :
1158	+	case 0x4f /* 'O' */ :
1159	+	case 0x50 /* 'P' */ :
1160	+	case 0x51 /* 'Q' */ :
1161	+	case 0x52 /* 'R' */ :
1162	+	case 0x53 /* 'S' */ :
1163	+	case 0x54 /* 'T' */ :
1164		case 0x55 /* 'U' */ :
1165	+	case 0x56 /* 'V' */ :
1166	+	case 0x57 /* 'W' */ :
1167	+	case 0x58 /* 'X' */ :
1168	+	case 0x59 /* 'Y' */ :
1169	+	case 0x5a /* 'Z' */ :
1170		{
1171	<	match('U' /* charlit */ );
1171	>	matchRange('A','Z');
1172		break;
1173		}
1174	<	default:
1174	>	case 0x5f /* '_' */ :
1175		{
1176	<	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 */ );
1176	>	match('_' /* charlit */ );
1177		break;
1178		}
1153	–	case 0x46 /* 'F' */ :
1154	–	{
1155	–	match('F' /* charlit */ );
1156	–	break;
1157	–	}
1179		default:
1180		{
1181		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1182		}
1183	+	}
1184	+	}
1185	+	{ // ( ... )*
1186	+	for (;;) {
1187	+	switch ( LA(1)) {
1188	+	case 0x61 /* 'a' */ :
1189	+	case 0x62 /* 'b' */ :
1190	+	case 0x63 /* 'c' */ :
1191	+	case 0x64 /* 'd' */ :
1192	+	case 0x65 /* 'e' */ :
1193	+	case 0x66 /* 'f' */ :
1194	+	case 0x67 /* 'g' */ :
1195	+	case 0x68 /* 'h' */ :
1196	+	case 0x69 /* 'i' */ :
1197	+	case 0x6a /* 'j' */ :
1198	+	case 0x6b /* 'k' */ :
1199	+	case 0x6c /* 'l' */ :
1200	+	case 0x6d /* 'm' */ :
1201	+	case 0x6e /* 'n' */ :
1202	+	case 0x6f /* 'o' */ :
1203	+	case 0x70 /* 'p' */ :
1204	+	case 0x71 /* 'q' */ :
1205	+	case 0x72 /* 'r' */ :
1206	+	case 0x73 /* 's' */ :
1207	+	case 0x74 /* 't' */ :
1208	+	case 0x75 /* 'u' */ :
1209	+	case 0x76 /* 'v' */ :
1210	+	case 0x77 /* 'w' */ :
1211	+	case 0x78 /* 'x' */ :
1212	+	case 0x79 /* 'y' */ :
1213	+	case 0x7a /* 'z' */ :
1214	+	{
1215	+	matchRange('a','z');
1216	+	break;
1217	+	}
1218	+	case 0x41 /* 'A' */ :
1219	+	case 0x42 /* 'B' */ :
1220	+	case 0x43 /* 'C' */ :
1221	+	case 0x44 /* 'D' */ :
1222	+	case 0x45 /* 'E' */ :
1223	+	case 0x46 /* 'F' */ :
1224	+	case 0x47 /* 'G' */ :
1225	+	case 0x48 /* 'H' */ :
1226	+	case 0x49 /* 'I' */ :
1227	+	case 0x4a /* 'J' */ :
1228	+	case 0x4b /* 'K' */ :
1229	+	case 0x4c /* 'L' */ :
1230	+	case 0x4d /* 'M' */ :
1231	+	case 0x4e /* 'N' */ :
1232	+	case 0x4f /* 'O' */ :
1233	+	case 0x50 /* 'P' */ :
1234	+	case 0x51 /* 'Q' */ :
1235	+	case 0x52 /* 'R' */ :
1236	+	case 0x53 /* 'S' */ :
1237	+	case 0x54 /* 'T' */ :
1238	+	case 0x55 /* 'U' */ :
1239	+	case 0x56 /* 'V' */ :
1240	+	case 0x57 /* 'W' */ :
1241	+	case 0x58 /* 'X' */ :
1242	+	case 0x59 /* 'Y' */ :
1243	+	case 0x5a /* 'Z' */ :
1244	+	{
1245	+	matchRange('A','Z');
1246	+	break;
1247	+	}
1248	+	case 0x5f /* '_' */ :
1249	+	{
1250	+	match('_' /* charlit */ );
1251	+	break;
1252	+	}
1253	+	case 0x30 /* '0' */ :
1254	+	case 0x31 /* '1' */ :
1255	+	case 0x32 /* '2' */ :
1256	+	case 0x33 /* '3' */ :
1257	+	case 0x34 /* '4' */ :
1258	+	case 0x35 /* '5' */ :
1259	+	case 0x36 /* '6' */ :
1260	+	case 0x37 /* '7' */ :
1261	+	case 0x38 /* '8' */ :
1262	+	case 0x39 /* '9' */ :
1263	+	{
1264	+	matchRange('0','9');
1265	+	break;
1266	+	}
1267	+	default:
1268	+	{
1269	+	goto _loop143;
1270	+	}
1271	+	}
1272		}
1273	+	_loop143:;
1274	+	} // ( ... )*
1275	+	_ttype = testLiteralsTable(_ttype);
1276		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1277		_token = makeToken(_ttype);
1278		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1168 | Line 1281 | void MDLexer::mFloatSuffix(bool _createToken) {
1281		_saveIndex=0;
1282		}
1283
1284	<	void MDLexer::mExponent(bool _createToken) {
1284	>	void MDLexer::mHEX_DIGIT(bool _createToken) {
1285		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1286	<	_ttype = Exponent;
1286	>	_ttype = HEX_DIGIT;
1287		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1288
1289		{
1290		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	–	}
1291		case 0x30 /* '0' */ :
1292		case 0x31 /* '1' */ :
1293		case 0x32 /* '2' */ :
#	Line 1224 | Line 1299 | void MDLexer::mExponent(bool _createToken) {
1299		case 0x38 /* '8' */ :
1300		case 0x39 /* '9' */ :
1301		{
1302	+	matchRange('0','9');
1303		break;
1304		}
1305	+	case 0x41 /* 'A' */ :
1306	+	case 0x42 /* 'B' */ :
1307	+	case 0x43 /* 'C' */ :
1308	+	case 0x44 /* 'D' */ :
1309	+	case 0x45 /* 'E' */ :
1310	+	case 0x46 /* 'F' */ :
1311	+	{
1312	+	matchRange('A','F');
1313	+	break;
1314	+	}
1315	+	case 0x61 /* 'a' */ :
1316	+	case 0x62 /* 'b' */ :
1317	+	case 0x63 /* 'c' */ :
1318	+	case 0x64 /* 'd' */ :
1319	+	case 0x65 /* 'e' */ :
1320	+	case 0x66 /* 'f' */ :
1321	+	{
1322	+	matchRange('a','f');
1323	+	break;
1324	+	}
1325		default:
1326		{
1327		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1328		}
1329		}
1330		}
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	–	}  // ( ... )+
1331		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1332		_token = makeToken(_ttype);
1333		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1254 | Line 1336 | void MDLexer::mExponent(bool _createToken) {
1336		_saveIndex=0;
1337		}
1338
1339	<	void MDLexer::mVocabulary(bool _createToken) {
1339	>	void MDLexer::mNUM_INT(bool _createToken) {
1340		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1341	<	_ttype = Vocabulary;
1341	>	_ttype = NUM_INT;
1342		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1343	+	ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1344	+	ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1345	+	ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1346	+	ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1347	+	#line 441 "MDParser.g"
1348
1349	<	matchRange('\3',static_cast<unsigned char>('\377'));
1350	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1351	<	_token = makeToken(_ttype);
1352	<	_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;
1349	>	bool isDecimal = false;
1350	>	ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1351	>
1352	>	#line 1353 "MDLexer.cpp"
1353
1354		{
1355		switch ( LA(1)) {
#	Line 1306 | Line 1384 | void MDLexer::mNumber(bool _createToken) {
1384		}
1385		}
1386		{
1387	<	bool synPredMatched136 = false;
1388	<	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1389	<	int _m136 = mark();
1390	<	synPredMatched136 = true;
1391	<	inputState->guessing++;
1392	<	try {
1393	<	{
1387	>	switch ( LA(1)) {
1388	>	case 0x2e /* '.' */ :
1389	>	{
1390	>	match('.' /* charlit */ );
1391	>	if ( inputState->guessing==0 ) {
1392	>	#line 448 "MDParser.g"
1393	>	_ttype = DOT;
1394	>	#line 1395 "MDLexer.cpp"
1395	>	}
1396	>	{
1397	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398		{ // ( ... )+
1399	<	int _cnt134=0;
1399	>	int _cnt155=0;
1400		for (;;) {
1401		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1402	<	mDigit(false);
1402	>	matchRange('0','9');
1403		}
1404		else {
1405	<	if ( _cnt134>=1 ) { goto _loop134; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1405	>	if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1406		}
1407
1408	<	_cnt134++;
1408	>	_cnt155++;
1409		}
1410	<	_loop134:;
1410	>	_loop155:;
1411		}  // ( ... )+
1412		{
1413	<	switch ( LA(1)) {
1414	<	case 0x2e /* '.' */ :
1333	<	{
1334	<	match('.' /* charlit */ );
1335	<	break;
1413	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1414	>	mEXPONENT(false);
1415		}
1416	<	case 0x65 /* 'e' */ :
1338	<	{
1339	<	match('e' /* charlit */ );
1340	<	break;
1416	>	else {
1417		}
1418	<	case 0x45 /* 'E' */ :
1343	<	{
1344	<	match('E' /* charlit */ );
1345	<	break;
1418	>
1419		}
1347	–	case 0x64 /* 'd' */ :
1420		{
1421	<	match('d' /* charlit */ );
1422	<	break;
1423	<	}
1424	<	case 0x44 /* 'D' */ :
1425	<	{
1426	<	match('D' /* charlit */ );
1427	<	break;
1356	<	}
1357	<	default:
1358	<	{
1359	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1360	<	}
1361	<	}
1362	<	}
1363	<	}
1364	<	}
1365	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1366	<	synPredMatched136 = false;
1367	<	}
1368	<	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++;
1383	<	}
1384	<	_loop138:;
1385	<	}  // ( ... )+
1386	<	{
1387	<	switch ( LA(1)) {
1388	<	case 0x2e /* '.' */ :
1389	<	{
1390	<	match('.' /* charlit */ );
1391	<	{ // ( ... )*
1392	<	for (;;) {
1393	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1394	<	mDigit(false);
1421	>	if ((_tokenSet_8.member(LA(1)))) {
1422	>	mFLOAT_SUFFIX(true);
1423	>	f1=_returnToken;
1424	>	if ( inputState->guessing==0 ) {
1425	>	#line 449 "MDParser.g"
1426	>	t=f1;
1427	>	#line 1428 "MDLexer.cpp"
1428		}
1396	–	else {
1397	–	goto _loop141;
1398	–	}
1399	–
1429		}
1401	–	_loop141:;
1402	–	} // ( ... )*
1403	–	{
1404	–	if ((_tokenSet_7.member(LA(1)))) {
1405	–	mExponent(false);
1406	–	}
1430		else {
1431		}
1432
1433		}
1434		if ( inputState->guessing==0 ) {
1435		#line 450 "MDParser.g"
1436	<	_ttype = FLOATONE;
1437	<	#line 1415 "MDLexer.cpp"
1436	>
1437	>	if ( t &&
1438	>	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1439	>	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1440	>	_ttype = NUM_FLOAT;
1441	>	}
1442	>	else {
1443	>	_ttype = NUM_DOUBLE; // assume double
1444	>	}
1445	>
1446	>	#line 1447 "MDLexer.cpp"
1447		}
1416	–	break;
1448		}
1449	<	case 0x44 /* 'D' */ :
1419	<	case 0x45 /* 'E' */ :
1420	<	case 0x64 /* 'd' */ :
1421	<	case 0x65 /* 'e' */ :
1422	<	{
1423	<	mExponent(false);
1424	<	if ( inputState->guessing==0 ) {
1425	<	#line 451 "MDParser.g"
1426	<	_ttype = FLOATTWO;
1427	<	#line 1428 "MDLexer.cpp"
1428	<	}
1429	<	break;
1449	>	else {
1450		}
1451	<	default:
1432	<	{
1433	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1451	>
1452		}
1453	<	}
1436	<	}
1437	<	{
1438	<	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:
1452	<	{
1453	<	}
1454	<	}
1455	<	}
1453	>	break;
1454		}
1455	<	else if ((LA(1) == 0x30 /* '0' */ ) && (LA(2) == 0x58 /* 'X' */  || LA(2) == 0x78 /* 'x' */ )) {
1456	<	match('0' /* charlit */ );
1455	>	case 0x30 /* '0' */ :
1456	>	case 0x31 /* '1' */ :
1457	>	case 0x32 /* '2' */ :
1458	>	case 0x33 /* '3' */ :
1459	>	case 0x34 /* '4' */ :
1460	>	case 0x35 /* '5' */ :
1461	>	case 0x36 /* '6' */ :
1462	>	case 0x37 /* '7' */ :
1463	>	case 0x38 /* '8' */ :
1464	>	case 0x39 /* '9' */ :
1465	>	{
1466		{
1467		switch ( LA(1)) {
1468	<	case 0x78 /* 'x' */ :
1468	>	case 0x30 /* '0' */ :
1469		{
1470	<	match('x' /* charlit */ );
1471	<	break;
1472	<	}
1473	<	case 0x58 /* 'X' */ :
1474	<	{
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 (;;) {
1480	<	switch ( LA(1)) {
1481	<	case 0x61 /* 'a' */ :
1482	<	case 0x62 /* 'b' */ :
1483	<	case 0x63 /* 'c' */ :
1484	<	case 0x64 /* 'd' */ :
1485	<	case 0x65 /* 'e' */ :
1486	<	case 0x66 /* 'f' */ :
1487	<	{
1488	<	matchRange('a','f');
1489	<	break;
1470	>	match('0' /* charlit */ );
1471	>	if ( inputState->guessing==0 ) {
1472	>	#line 462 "MDParser.g"
1473	>	isDecimal = true;
1474	>	#line 1475 "MDLexer.cpp"
1475		}
1491	–	case 0x41 /* 'A' */ :
1492	–	case 0x42 /* 'B' */ :
1493	–	case 0x43 /* 'C' */ :
1494	–	case 0x44 /* 'D' */ :
1495	–	case 0x45 /* 'E' */ :
1496	–	case 0x46 /* 'F' */ :
1476		{
1477	<	matchRange('A','F');
1478	<	break;
1477	>	if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
1478	>	{
1479	>	switch ( LA(1)) {
1480	>	case 0x78 /* 'x' */ :
1481	>	{
1482	>	match('x' /* charlit */ );
1483	>	break;
1484	>	}
1485	>	case 0x58 /* 'X' */ :
1486	>	{
1487	>	match('X' /* charlit */ );
1488	>	break;
1489	>	}
1490	>	default:
1491	>	{
1492	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1493	>	}
1494	>	}
1495	>	}
1496	>	{ // ( ... )+
1497	>	int _cnt162=0;
1498	>	for (;;) {
1499	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1500	>	mHEX_DIGIT(false);
1501	>	}
1502	>	else {
1503	>	if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1504	>	}
1505	>
1506	>	_cnt162++;
1507	>	}
1508	>	_loop162:;
1509	>	}  // ( ... )+
1510		}
1511	<	case 0x30 /* '0' */ :
1512	<	case 0x31 /* '1' */ :
1513	<	case 0x32 /* '2' */ :
1514	<	case 0x33 /* '3' */ :
1515	<	case 0x34 /* '4' */ :
1516	<	case 0x35 /* '5' */ :
1517	<	case 0x36 /* '6' */ :
1518	<	case 0x37 /* '7' */ :
1519	<	case 0x38 /* '8' */ :
1520	<	case 0x39 /* '9' */ :
1521	<	{
1522	<	mDigit(false);
1523	<	break;
1511	>	else {
1512	>	bool synPredMatched167 = false;
1513	>	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1514	>	int _m167 = mark();
1515	>	synPredMatched167 = true;
1516	>	inputState->guessing++;
1517	>	try {
1518	>	{
1519	>	{ // ( ... )+
1520	>	int _cnt165=0;
1521	>	for (;;) {
1522	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1523	>	matchRange('0','9');
1524	>	}
1525	>	else {
1526	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1527	>	}
1528	>
1529	>	_cnt165++;
1530	>	}
1531	>	_loop165:;
1532	>	}  // ( ... )+
1533	>	{
1534	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1535	>	mEXPONENT(false);
1536	>	}
1537	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1538	>	match('.' /* charlit */ );
1539	>	}
1540	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1541	>	mFLOAT_SUFFIX(false);
1542	>	}
1543	>	else {
1544	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1545	>	}
1546	>
1547	>	}
1548	>	}
1549	>	}
1550	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1551	>	synPredMatched167 = false;
1552	>	}
1553	>	rewind(_m167);
1554	>	inputState->guessing--;
1555	>	}
1556	>	if ( synPredMatched167 ) {
1557	>	{ // ( ... )+
1558	>	int _cnt169=0;
1559	>	for (;;) {
1560	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1561	>	matchRange('0','9');
1562	>	}
1563	>	else {
1564	>	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1565	>	}
1566	>
1567	>	_cnt169++;
1568	>	}
1569	>	_loop169:;
1570	>	}  // ( ... )+
1571	>	}
1572	>	else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1573	>	{ // ( ... )+
1574	>	int _cnt171=0;
1575	>	for (;;) {
1576	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1577	>	matchRange('0','7');
1578	>	}
1579	>	else {
1580	>	if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1581	>	}
1582	>
1583	>	_cnt171++;
1584	>	}
1585	>	_loop171:;
1586	>	}  // ( ... )+
1587	>	}
1588	>	else {
1589	>	}
1590		}
1515	–	default:
1516	–	{
1517	–	if ( _cnt159>=1 ) { goto _loop159; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1591		}
1592	<	}
1520	<	_cnt159++;
1592	>	break;
1593		}
1594	<	_loop159:;
1595	<	}  // ( ... )+
1596	<	{ // ( ... )*
1597	<	for (;;) {
1598	<	switch ( LA(1)) {
1599	<	case 0x4c /* 'L' */ :
1600	<	case 0x6c /* 'l' */ :
1594	>	case 0x31 /* '1' */ :
1595	>	case 0x32 /* '2' */ :
1596	>	case 0x33 /* '3' */ :
1597	>	case 0x34 /* '4' */ :
1598	>	case 0x35 /* '5' */ :
1599	>	case 0x36 /* '6' */ :
1600	>	case 0x37 /* '7' */ :
1601	>	case 0x38 /* '8' */ :
1602	>	case 0x39 /* '9' */ :
1603	>	{
1604		{
1605	<	mLongSuffix(false);
1531	<	break;
1605	>	matchRange('1','9');
1606		}
1607	<	case 0x55 /* 'U' */ :
1534	<	case 0x75 /* 'u' */ :
1535	<	{
1536	<	mUnsignedSuffix(false);
1537	<	break;
1538	<	}
1539	<	default:
1540	<	{
1541	<	goto _loop161;
1542	<	}
1543	<	}
1544	<	}
1545	<	_loop161:;
1546	<	} // ( ... )*
1547	<	if ( inputState->guessing==0 ) {
1548	<	#line 479 "MDParser.g"
1549	<	_ttype = HEXADECIMALINT;
1550	<	#line 1551 "MDLexer.cpp"
1551	<	}
1552	<	}
1553	<	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;
1607	>	{ // ( ... )*
1608		for (;;) {
1609		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1610	<	mDigit(false);
1610	>	matchRange('0','9');
1611		}
1612		else {
1613	<	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1613	>	goto _loop174;
1614		}
1615
1572	–	_cnt146++;
1616		}
1617	<	_loop146:;
1618	<	}  // ( ... )+
1576	<	{
1577	<	if ((_tokenSet_7.member(LA(1)))) {
1578	<	mExponent(false);
1579	<	}
1580	<	else {
1581	<	}
1582	<
1583	<	}
1617	>	_loop174:;
1618	>	} // ( ... )*
1619		if ( inputState->guessing==0 ) {
1620	<	#line 458 "MDParser.g"
1621	<	_ttype = FLOATONE;
1622	<	#line 1588 "MDLexer.cpp"
1620	>	#line 479 "MDParser.g"
1621	>	isDecimal=true;
1622	>	#line 1623 "MDLexer.cpp"
1623		}
1624	<	{
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	<	}
1624	>	break;
1625		}
1626	<	else {
1626	>	default:
1627	>	{
1628	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1629		}
1611	–
1630		}
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	–
1631		}
1632	<	_loop150:;
1633	<	} // ( ... )*
1634	<	{ // ( ... )*
1629	<	for (;;) {
1632	>	{
1633	>	if ((LA(1) == 0x4c /* 'L' */  || LA(1) == 0x6c /* 'l' */ )) {
1634	>	{
1635		switch ( LA(1)) {
1631	–	case 0x4c /* 'L' */ :
1636		case 0x6c /* 'l' */ :
1637		{
1638	<	mLongSuffix(false);
1638	>	match('l' /* charlit */ );
1639		break;
1640		}
1641	<	case 0x55 /* 'U' */ :
1638	<	case 0x75 /* 'u' */ :
1641	>	case 0x4c /* 'L' */ :
1642		{
1643	<	mUnsignedSuffix(false);
1643	>	match('L' /* charlit */ );
1644		break;
1645		}
1646		default:
1647		{
1648	<	goto _loop152;
1648	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1649		}
1650		}
1648	–	}
1649	–	_loop152:;
1650	–	} // ( ... )*
1651	–	if ( inputState->guessing==0 ) {
1652	–	#line 468 "MDParser.g"
1653	–	_ttype = OCTALINT;
1654	–	#line 1655 "MDLexer.cpp"
1655	–	}
1656	–	}
1657	–	else if (((LA(1) >= 0x31 /* '1' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
1658	–	matchRange('1','9');
1659	–	{ // ( ... )*
1660	–	for (;;) {
1661	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1662	–	mDigit(false);
1651		}
1652	<	else {
1653	<	goto _loop154;
1652	>	if ( inputState->guessing==0 ) {
1653	>	#line 481 "MDParser.g"
1654	>	_ttype = NUM_LONG;
1655	>	#line 1656 "MDLexer.cpp"
1656		}
1667	–
1657		}
1658	<	_loop154:;
1670	<	} // ( ... )*
1671	<	{ // ( ... )*
1672	<	for (;;) {
1673	<	switch ( LA(1)) {
1674	<	case 0x4c /* 'L' */ :
1675	<	case 0x6c /* 'l' */ :
1658	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1659		{
1660	<	mLongSuffix(false);
1661	<	break;
1660	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1661	>	mEXPONENT(false);
1662	>	{
1663	>	if ((_tokenSet_8.member(LA(1)))) {
1664	>	mFLOAT_SUFFIX(true);
1665	>	f3=_returnToken;
1666	>	if ( inputState->guessing==0 ) {
1667	>	#line 486 "MDParser.g"
1668	>	t=f3;
1669	>	#line 1670 "MDLexer.cpp"
1670	>	}
1671	>	}
1672	>	else {
1673	>	}
1674	>
1675	>	}
1676		}
1677	<	case 0x55 /* 'U' */ :
1678	<	case 0x75 /* 'u' */ :
1679	<	{
1680	<	mUnsignedSuffix(false);
1681	<	break;
1682	<	}
1683	<	default:
1684	<	{
1685	<	goto _loop156;
1677	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1678	>	match('.' /* charlit */ );
1679	>	{ // ( ... )*
1680	>	for (;;) {
1681	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1682	>	matchRange('0','9');
1683	>	}
1684	>	else {
1685	>	goto _loop179;
1686	>	}
1687	>
1688	>	}
1689	>	_loop179:;
1690	>	} // ( ... )*
1691	>	{
1692	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1693	>	mEXPONENT(false);
1694	>	}
1695	>	else {
1696	>	}
1697	>
1698	>	}
1699	>	{
1700	>	if ((_tokenSet_8.member(LA(1)))) {
1701	>	mFLOAT_SUFFIX(true);
1702	>	f2=_returnToken;
1703	>	if ( inputState->guessing==0 ) {
1704	>	#line 485 "MDParser.g"
1705	>	t=f2;
1706	>	#line 1707 "MDLexer.cpp"
1707	>	}
1708	>	}
1709	>	else {
1710	>	}
1711	>
1712	>	}
1713		}
1714	+	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1715	+	mFLOAT_SUFFIX(true);
1716	+	f4=_returnToken;
1717	+	if ( inputState->guessing==0 ) {
1718	+	#line 487 "MDParser.g"
1719	+	t=f4;
1720	+	#line 1721 "MDLexer.cpp"
1721	+	}
1722		}
1723	+	else {
1724	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1725	+	}
1726	+
1727	+	}
1728	+	if ( inputState->guessing==0 ) {
1729	+	#line 489 "MDParser.g"
1730	+
1731	+	if ( t &&
1732	+	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1733	+	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1734	+	_ttype = NUM_FLOAT;
1735	+	}
1736	+	else {
1737	+	_ttype = NUM_DOUBLE; // assume double
1738	+	}
1739	+
1740	+	#line 1741 "MDLexer.cpp"
1741	+	}
1742		}
1743	<	_loop156:;
1693	<	} // ( ... )*
1694	<	if ( inputState->guessing==0 ) {
1695	<	#line 473 "MDParser.g"
1696	<	_ttype = DECIMALINT;
1697	<	#line 1698 "MDLexer.cpp"
1743	>	else {
1744		}
1745	+
1746	+	}
1747	+	break;
1748		}
1749	<	else {
1749	>	default:
1750	>	{
1751		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1752		}
1703	–
1753		}
1754	+	}
1755		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1756		_token = makeToken(_ttype);
1757		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1710 | Line 1760 | void MDLexer::mNumber(bool _createToken) {
1760		_saveIndex=0;
1761		}
1762
1763	<	void MDLexer::mID(bool _createToken) {
1763	>	void MDLexer::mEXPONENT(bool _createToken) {
1764		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1765	<	_ttype = ID;
1765	>	_ttype = EXPONENT;
1766		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1767
1768		{
1769		switch ( LA(1)) {
1720	–	case 0x61 /* 'a' */ :
1721	–	case 0x62 /* 'b' */ :
1722	–	case 0x63 /* 'c' */ :
1723	–	case 0x64 /* 'd' */ :
1770		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' */ :
1771		{
1772	<	matchRange('a','z');
1772	>	match('e' /* charlit */ );
1773		break;
1774		}
1750	–	case 0x41 /* 'A' */ :
1751	–	case 0x42 /* 'B' */ :
1752	–	case 0x43 /* 'C' */ :
1753	–	case 0x44 /* 'D' */ :
1775		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' */ :
1776		{
1777	<	matchRange('A','Z');
1777	>	match('E' /* charlit */ );
1778		break;
1779		}
1780	<	case 0x5f /* '_' */ :
1780	>	case 0x64 /* 'd' */ :
1781		{
1782	<	match('_' /* charlit */ );
1782	>	match('d' /* charlit */ );
1783		break;
1784		}
1785	+	case 0x44 /* 'D' */ :
1786	+	{
1787	+	match('D' /* charlit */ );
1788	+	break;
1789	+	}
1790		default:
1791		{
1792		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1793		}
1794		}
1795		}
1796	<	{ // ( ... )*
1796	>	{
1797	>	switch ( LA(1)) {
1798	>	case 0x2b /* '+' */ :
1799	>	{
1800	>	match('+' /* charlit */ );
1801	>	break;
1802	>	}
1803	>	case 0x2d /* '-' */ :
1804	>	{
1805	>	match('-' /* charlit */ );
1806	>	break;
1807	>	}
1808	>	case 0x30 /* '0' */ :
1809	>	case 0x31 /* '1' */ :
1810	>	case 0x32 /* '2' */ :
1811	>	case 0x33 /* '3' */ :
1812	>	case 0x34 /* '4' */ :
1813	>	case 0x35 /* '5' */ :
1814	>	case 0x36 /* '6' */ :
1815	>	case 0x37 /* '7' */ :
1816	>	case 0x38 /* '8' */ :
1817	>	case 0x39 /* '9' */ :
1818	>	{
1819	>	break;
1820	>	}
1821	>	default:
1822	>	{
1823	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1824	>	}
1825	>	}
1826	>	}
1827	>	{ // ( ... )+
1828	>	int _cnt187=0;
1829		for (;;) {
1830	<	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	<	{
1830	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1831		matchRange('0','9');
1871	–	break;
1832		}
1833	<	default:
1834	<	{
1875	<	goto _loop165;
1833	>	else {
1834	>	if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1835		}
1836	<	}
1836	>
1837	>	_cnt187++;
1838		}
1839	<	_loop165:;
1840	<	} // ( ... )*
1881	<	_ttype = testLiteralsTable(_ttype);
1839	>	_loop187:;
1840	>	}  // ( ... )+
1841		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1842		_token = makeToken(_ttype);
1843		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1887 | Line 1846 | void MDLexer::mID(bool _createToken) {
1846		_saveIndex=0;
1847		}
1848
1849	+	void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1850	+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1851	+	_ttype = FLOAT_SUFFIX;
1852	+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1853	+
1854	+	switch ( LA(1)) {
1855	+	case 0x66 /* 'f' */ :
1856	+	{
1857	+	match('f' /* charlit */ );
1858	+	break;
1859	+	}
1860	+	case 0x46 /* 'F' */ :
1861	+	{
1862	+	match('F' /* charlit */ );
1863	+	break;
1864	+	}
1865	+	case 0x64 /* 'd' */ :
1866	+	{
1867	+	match('d' /* charlit */ );
1868	+	break;
1869	+	}
1870	+	case 0x44 /* 'D' */ :
1871	+	{
1872	+	match('D' /* charlit */ );
1873	+	break;
1874	+	}
1875	+	default:
1876	+	{
1877	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1878	+	}
1879	+	}
1880	+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1881	+	_token = makeToken(_ttype);
1882	+	_token->setText(text.substr(_begin, text.length()-_begin));
1883	+	}
1884	+	_returnToken = _token;
1885	+	_saveIndex=0;
1886	+	}
1887
1888	+
1889		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1891		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1892	<	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1892	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1893		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1894		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1897	<	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1897	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1899		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900	<	// \" \' 0 1 2 3 4 5
1900	>	// \" \' 0 1 2 3 4 5 6 7
1901		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1902		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1904		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1905	<	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1905	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1907		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	<	// \' 0 1 2 3 4 5
1908	>	// \' 0 1 2 3 4 5 6 7 8 9
1909		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1910		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1912		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1913	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1913	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1914		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1915	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	<	// . 0 1 2 3 4 5
1915	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1917	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	>	// + - 0 1 2 3 4 5 6 7 8 9
1919		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1920	+	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1922	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	+	// 0 1 2 3 4 5 6 7 8 9
1924	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1925	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	+	// .
1927	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1928

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
Revision 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

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

Diff Legend

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