ViewVC Help

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

root/OpenMD/branches/development/src/mdParser/MDLexer.cpp

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC

#	Line 120 | Line 120 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
120		theRetToken=_returnToken;
121		break;
122		}
123	–	case 0x2b /* '+' */ :
124	–	{
125	–	mPLUS(true);
126	–	theRetToken=_returnToken;
127	–	break;
128	–	}
129	–	case 0x2d /* '-' */ :
130	–	{
131	–	mMINUS(true);
132	–	theRetToken=_returnToken;
133	–	break;
134	–	}
123		case 0x9 /* '\t' */ :
124		case 0xa /* '\n' */ :
125		case 0xc /* '\14' */ :
#	Line 161 | Line 149 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
149		theRetToken=_returnToken;
150		break;
151		}
164	–	case 0x2e /* '.' */ :
165	–	case 0x30 /* '0' */ :
166	–	case 0x31 /* '1' */ :
167	–	case 0x32 /* '2' */ :
168	–	case 0x33 /* '3' */ :
169	–	case 0x34 /* '4' */ :
170	–	case 0x35 /* '5' */ :
171	–	case 0x36 /* '6' */ :
172	–	case 0x37 /* '7' */ :
173	–	case 0x38 /* '8' */ :
174	–	case 0x39 /* '9' */ :
175	–	{
176	–	mNumber(true);
177	–	theRetToken=_returnToken;
178	–	break;
179	–	}
152		case 0x41 /* 'A' */ :
153		case 0x42 /* 'B' */ :
154		case 0x43 /* 'C' */ :
#	Line 235 | Line 207 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
207		theRetToken=_returnToken;
208		break;
209		}
210	+	case 0x2b /* '+' */ :
211	+	case 0x2d /* '-' */ :
212	+	case 0x2e /* '.' */ :
213	+	case 0x30 /* '0' */ :
214	+	case 0x31 /* '1' */ :
215	+	case 0x32 /* '2' */ :
216	+	case 0x33 /* '3' */ :
217	+	case 0x34 /* '4' */ :
218	+	case 0x35 /* '5' */ :
219	+	case 0x36 /* '6' */ :
220	+	case 0x37 /* '7' */ :
221	+	case 0x38 /* '8' */ :
222	+	case 0x39 /* '9' */ :
223	+	{
224	+	mNUM_INT(true);
225	+	theRetToken=_returnToken;
226	+	break;
227	+	}
228		default:
229		if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
230		mComment(true);
#	Line 419 | Line 409 | void MDLexer::mRCURLY(bool _createToken) {
409		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
410
411		match('}' /* charlit */ );
422	–	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
423	–	_token = makeToken(_ttype);
424	–	_token->setText(text.substr(_begin, text.length()-_begin));
425	–	}
426	–	_returnToken = _token;
427	–	_saveIndex=0;
428	–	}
429	–
430	–	void MDLexer::mPLUS(bool _createToken) {
431	–	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
432	–	_ttype = PLUS;
433	–	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
434	–
435	–	match('+' /* charlit */ );
412		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
413		_token = makeToken(_ttype);
414		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 441 | Line 417 | void MDLexer::mPLUS(bool _createToken) {
417		_saveIndex=0;
418		}
419
444	–	void MDLexer::mMINUS(bool _createToken) {
445	–	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
446	–	_ttype = MINUS;
447	–	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
448	–
449	–	match('-' /* charlit */ );
450	–	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
451	–	_token = makeToken(_ttype);
452	–	_token->setText(text.substr(_begin, text.length()-_begin));
453	–	}
454	–	_returnToken = _token;
455	–	_saveIndex=0;
456	–	}
457	–
420		void MDLexer::mWhitespace(bool _createToken) {
421		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
422		_ttype = Whitespace;
#	Line 511 | Line 473 | void MDLexer::mWhitespace(bool _createToken) {
473
474		}
475		if ( inputState->guessing==0 ) {
476	<	#line 262 "MDParser.g"
476	>	#line 218 "MDParser.g"
477		newline();
478	<	#line 517 "MDLexer.cpp"
478	>	#line 479 "MDLexer.cpp"
479		}
480		break;
481		}
#	Line 539 | Line 501 | void MDLexer::mWhitespace(bool _createToken) {
501
502		}
503		if ( inputState->guessing==0 ) {
504	<	#line 267 "MDParser.g"
504	>	#line 223 "MDParser.g"
505		printf("CPP_parser.g continuation line detected\n");
506		deferredNewline();
507	<	#line 546 "MDLexer.cpp"
507	>	#line 508 "MDLexer.cpp"
508		}
509		break;
510		}
#	Line 553 | Line 515 | void MDLexer::mWhitespace(bool _createToken) {
515		}
516		}
517		if ( inputState->guessing==0 ) {
518	<	#line 270 "MDParser.g"
518	>	#line 226 "MDParser.g"
519		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
520	<	#line 559 "MDLexer.cpp"
520	>	#line 521 "MDLexer.cpp"
521		}
522		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
523		_token = makeToken(_ttype);
#	Line 579 | Line 541 | void MDLexer::mComment(bool _createToken) {
541		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
542		mEndOfLine(false);
543		if ( inputState->guessing==0 ) {
544	<	#line 277 "MDParser.g"
544	>	#line 233 "MDParser.g"
545		deferredNewline();
546	<	#line 585 "MDLexer.cpp"
546	>	#line 547 "MDLexer.cpp"
547		}
548		}
549		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 590 | Line 552 | void MDLexer::mComment(bool _createToken) {
552		}
553		}
554		else {
555	<	goto _loop81;
555	>	goto _loop78;
556		}
557
558		}
559	<	_loop81:;
559	>	_loop78:;
560		} // ( ... )*
561		match("*/");
562		if ( inputState->guessing==0 ) {
563	<	#line 280 "MDParser.g"
563	>	#line 236 "MDParser.g"
564		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
565	<	#line 604 "MDLexer.cpp"
565	>	#line 566 "MDLexer.cpp"
566		}
567		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
568		_token = makeToken(_ttype);
#	Line 652 | Line 614 | void MDLexer::mCPPComment(bool _createToken) {
614		}
615		}
616		else {
617	<	goto _loop85;
617	>	goto _loop82;
618		}
619
620		}
621	<	_loop85:;
621	>	_loop82:;
622		} // ( ... )*
623		mEndOfLine(false);
624		if ( inputState->guessing==0 ) {
625	<	#line 286 "MDParser.g"
625	>	#line 242 "MDParser.g"
626		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
627	<	#line 666 "MDLexer.cpp"
627	>	#line 628 "MDLexer.cpp"
628		}
629		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
630		_token = makeToken(_ttype);
#	Line 680 | Line 642 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
642		match('#' /* charlit */ );
643		mLineDirective(false);
644		if ( inputState->guessing==0 ) {
645	<	#line 293 "MDParser.g"
645	>	#line 249 "MDParser.g"
646		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
647	<	#line 686 "MDLexer.cpp"
647	>	#line 648 "MDLexer.cpp"
648		}
649		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
650		_token = makeToken(_ttype);
#	Line 700 | Line 662 | void MDLexer::mLineDirective(bool _createToken) {
662		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
663
664		if ( inputState->guessing==0 ) {
665	<	#line 299 "MDParser.g"
665	>	#line 255 "MDParser.g"
666
667		deferredLineCount = 0;
668
669	<	#line 708 "MDLexer.cpp"
669	>	#line 670 "MDLexer.cpp"
670		}
671		{
672		switch ( LA(1)) {
#	Line 726 | Line 688 | void MDLexer::mLineDirective(bool _createToken) {
688		}
689		}
690		{ // ( ... )+
691	<	int _cnt90=0;
691	>	int _cnt87=0;
692		for (;;) {
693		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
694		mSpace(false);
695		}
696		else {
697	<	if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
697	>	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
698		}
699
700	<	_cnt90++;
700	>	_cnt87++;
701		}
702	<	_loop90:;
702	>	_loop87:;
703		}  // ( ... )+
704		mDecimal(true);
705		n=_returnToken;
706		if ( inputState->guessing==0 ) {
707	<	#line 304 "MDParser.g"
707	>	#line 260 "MDParser.g"
708		setLine(oopse::lexi_cast<int>(n->getText()) - 1);
709	<	#line 748 "MDLexer.cpp"
709	>	#line 710 "MDLexer.cpp"
710		}
711		{ // ( ... )+
712	<	int _cnt92=0;
712	>	int _cnt89=0;
713		for (;;) {
714		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
715		mSpace(false);
716		}
717		else {
718	<	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
718	>	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
719		}
720
721	<	_cnt92++;
721	>	_cnt89++;
722		}
723	<	_loop92:;
723	>	_loop89:;
724		}  // ( ... )+
725		{
726		mStringLiteral(true);
727		sl=_returnToken;
728		}
729		if ( inputState->guessing==0 ) {
730	<	#line 306 "MDParser.g"
730	>	#line 262 "MDParser.g"
731		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
732	<	#line 771 "MDLexer.cpp"
732	>	#line 733 "MDLexer.cpp"
733		}
734		{ // ( ... )*
735		for (;;) {
736		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
737		{ // ( ... )+
738	<	int _cnt96=0;
738	>	int _cnt93=0;
739		for (;;) {
740		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
741		mSpace(false);
742		}
743		else {
744	<	if ( _cnt96>=1 ) { goto _loop96; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
744	>	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
745		}
746
747	<	_cnt96++;
747	>	_cnt93++;
748		}
749	<	_loop96:;
749	>	_loop93:;
750		}  // ( ... )+
751		mDecimal(false);
752		}
753		else {
754	<	goto _loop97;
754	>	goto _loop94;
755		}
756
757		}
758	<	_loop97:;
758	>	_loop94:;
759		} // ( ... )*
760		mEndOfLine(false);
761		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 846 | Line 808 | void MDLexer::mDecimal(bool _createToken) {
808		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
809
810		{ // ( ... )+
811	<	int _cnt122=0;
811	>	int _cnt124=0;
812		for (;;) {
813		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
814		matchRange('0','9');
815		}
816		else {
817	<	if ( _cnt122>=1 ) { goto _loop122; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
817	>	if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
818		}
819
820	<	_cnt122++;
820	>	_cnt124++;
821		}
822	<	_loop122:;
822	>	_loop124:;
823		}  // ( ... )+
824		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
825		_token = makeToken(_ttype);
#	Line 895 | Line 857 | void MDLexer::mStringLiteral(bool _createToken) {
857
858		}
859		if ( inputState->guessing==0 ) {
860	<	#line 346 "MDParser.g"
860	>	#line 302 "MDParser.g"
861		deferredNewline();
862	<	#line 901 "MDLexer.cpp"
862	>	#line 863 "MDLexer.cpp"
863		}
864		}
865		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 906 | Line 868 | void MDLexer::mStringLiteral(bool _createToken) {
868		}
869		}
870		else {
871	<	goto _loop107;
871	>	goto _loop104;
872		}
873
874		}
875	<	_loop107:;
875	>	_loop104:;
876		} // ( ... )*
877		match('\"' /* charlit */ );
878		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1070 | Line 1032 | void MDLexer::mEscape(bool _createToken) {
1032		{
1033		match('x' /* charlit */ );
1034		{ // ( ... )+
1035	<	int _cnt118=0;
1035	>	int _cnt115=0;
1036		for (;;) {
1037		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1038		mDigit(false);
#	Line 1082 | Line 1044 | void MDLexer::mEscape(bool _createToken) {
1044		matchRange('A','F');
1045		}
1046		else {
1047	<	if ( _cnt118>=1 ) { goto _loop118; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1047	>	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1048		}
1049
1050	<	_cnt118++;
1050	>	_cnt115++;
1051		}
1052	<	_loop118:;
1052	>	_loop115:;
1053		}  // ( ... )+
1054		break;
1055		}
#	Line 1119 | Line 1081 | void MDLexer::mDigit(bool _createToken) {
1081		_saveIndex=0;
1082		}
1083
1084	<	void MDLexer::mLongSuffix(bool _createToken) {
1084	>	void MDLexer::mVocabulary(bool _createToken) {
1085		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1086	<	_ttype = LongSuffix;
1086	>	_ttype = Vocabulary;
1087		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1088
1089	<	switch ( LA(1)) {
1128	<	case 0x6c /* 'l' */ :
1129	<	{
1130	<	match('l' /* charlit */ );
1131	<	break;
1132	<	}
1133	<	case 0x4c /* 'L' */ :
1134	<	{
1135	<	match('L' /* charlit */ );
1136	<	break;
1137	<	}
1138	<	default:
1139	<	{
1140	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1141	<	}
1142	<	}
1089	>	matchRange('\3',static_cast<unsigned char>('\377'));
1090		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1091		_token = makeToken(_ttype);
1092		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1148 | Line 1095 | void MDLexer::mLongSuffix(bool _createToken) {
1095		_saveIndex=0;
1096		}
1097
1098	<	void MDLexer::mUnsignedSuffix(bool _createToken) {
1098	>	void MDLexer::mID(bool _createToken) {
1099		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1100	<	_ttype = UnsignedSuffix;
1100	>	_ttype = ID;
1101		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1102
1103	+	{
1104		switch ( LA(1)) {
1105	+	case 0x61 /* 'a' */ :
1106	+	case 0x62 /* 'b' */ :
1107	+	case 0x63 /* 'c' */ :
1108	+	case 0x64 /* 'd' */ :
1109	+	case 0x65 /* 'e' */ :
1110	+	case 0x66 /* 'f' */ :
1111	+	case 0x67 /* 'g' */ :
1112	+	case 0x68 /* 'h' */ :
1113	+	case 0x69 /* 'i' */ :
1114	+	case 0x6a /* 'j' */ :
1115	+	case 0x6b /* 'k' */ :
1116	+	case 0x6c /* 'l' */ :
1117	+	case 0x6d /* 'm' */ :
1118	+	case 0x6e /* 'n' */ :
1119	+	case 0x6f /* 'o' */ :
1120	+	case 0x70 /* 'p' */ :
1121	+	case 0x71 /* 'q' */ :
1122	+	case 0x72 /* 'r' */ :
1123	+	case 0x73 /* 's' */ :
1124	+	case 0x74 /* 't' */ :
1125		case 0x75 /* 'u' */ :
1126	+	case 0x76 /* 'v' */ :
1127	+	case 0x77 /* 'w' */ :
1128	+	case 0x78 /* 'x' */ :
1129	+	case 0x79 /* 'y' */ :
1130	+	case 0x7a /* 'z' */ :
1131		{
1132	<	match('u' /* charlit */ );
1132	>	matchRange('a','z');
1133		break;
1134		}
1135	+	case 0x41 /* 'A' */ :
1136	+	case 0x42 /* 'B' */ :
1137	+	case 0x43 /* 'C' */ :
1138	+	case 0x44 /* 'D' */ :
1139	+	case 0x45 /* 'E' */ :
1140	+	case 0x46 /* 'F' */ :
1141	+	case 0x47 /* 'G' */ :
1142	+	case 0x48 /* 'H' */ :
1143	+	case 0x49 /* 'I' */ :
1144	+	case 0x4a /* 'J' */ :
1145	+	case 0x4b /* 'K' */ :
1146	+	case 0x4c /* 'L' */ :
1147	+	case 0x4d /* 'M' */ :
1148	+	case 0x4e /* 'N' */ :
1149	+	case 0x4f /* 'O' */ :
1150	+	case 0x50 /* 'P' */ :
1151	+	case 0x51 /* 'Q' */ :
1152	+	case 0x52 /* 'R' */ :
1153	+	case 0x53 /* 'S' */ :
1154	+	case 0x54 /* 'T' */ :
1155		case 0x55 /* 'U' */ :
1156	+	case 0x56 /* 'V' */ :
1157	+	case 0x57 /* 'W' */ :
1158	+	case 0x58 /* 'X' */ :
1159	+	case 0x59 /* 'Y' */ :
1160	+	case 0x5a /* 'Z' */ :
1161		{
1162	<	match('U' /* charlit */ );
1162	>	matchRange('A','Z');
1163		break;
1164		}
1165	+	case 0x5f /* '_' */ :
1166	+	{
1167	+	match('_' /* charlit */ );
1168	+	break;
1169	+	}
1170		default:
1171		{
1172		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1173		}
1174		}
1175	+	}
1176	+	{ // ( ... )*
1177	+	for (;;) {
1178	+	switch ( LA(1)) {
1179	+	case 0x61 /* 'a' */ :
1180	+	case 0x62 /* 'b' */ :
1181	+	case 0x63 /* 'c' */ :
1182	+	case 0x64 /* 'd' */ :
1183	+	case 0x65 /* 'e' */ :
1184	+	case 0x66 /* 'f' */ :
1185	+	case 0x67 /* 'g' */ :
1186	+	case 0x68 /* 'h' */ :
1187	+	case 0x69 /* 'i' */ :
1188	+	case 0x6a /* 'j' */ :
1189	+	case 0x6b /* 'k' */ :
1190	+	case 0x6c /* 'l' */ :
1191	+	case 0x6d /* 'm' */ :
1192	+	case 0x6e /* 'n' */ :
1193	+	case 0x6f /* 'o' */ :
1194	+	case 0x70 /* 'p' */ :
1195	+	case 0x71 /* 'q' */ :
1196	+	case 0x72 /* 'r' */ :
1197	+	case 0x73 /* 's' */ :
1198	+	case 0x74 /* 't' */ :
1199	+	case 0x75 /* 'u' */ :
1200	+	case 0x76 /* 'v' */ :
1201	+	case 0x77 /* 'w' */ :
1202	+	case 0x78 /* 'x' */ :
1203	+	case 0x79 /* 'y' */ :
1204	+	case 0x7a /* 'z' */ :
1205	+	{
1206	+	matchRange('a','z');
1207	+	break;
1208	+	}
1209	+	case 0x41 /* 'A' */ :
1210	+	case 0x42 /* 'B' */ :
1211	+	case 0x43 /* 'C' */ :
1212	+	case 0x44 /* 'D' */ :
1213	+	case 0x45 /* 'E' */ :
1214	+	case 0x46 /* 'F' */ :
1215	+	case 0x47 /* 'G' */ :
1216	+	case 0x48 /* 'H' */ :
1217	+	case 0x49 /* 'I' */ :
1218	+	case 0x4a /* 'J' */ :
1219	+	case 0x4b /* 'K' */ :
1220	+	case 0x4c /* 'L' */ :
1221	+	case 0x4d /* 'M' */ :
1222	+	case 0x4e /* 'N' */ :
1223	+	case 0x4f /* 'O' */ :
1224	+	case 0x50 /* 'P' */ :
1225	+	case 0x51 /* 'Q' */ :
1226	+	case 0x52 /* 'R' */ :
1227	+	case 0x53 /* 'S' */ :
1228	+	case 0x54 /* 'T' */ :
1229	+	case 0x55 /* 'U' */ :
1230	+	case 0x56 /* 'V' */ :
1231	+	case 0x57 /* 'W' */ :
1232	+	case 0x58 /* 'X' */ :
1233	+	case 0x59 /* 'Y' */ :
1234	+	case 0x5a /* 'Z' */ :
1235	+	{
1236	+	matchRange('A','Z');
1237	+	break;
1238	+	}
1239	+	case 0x5f /* '_' */ :
1240	+	{
1241	+	match('_' /* charlit */ );
1242	+	break;
1243	+	}
1244	+	case 0x30 /* '0' */ :
1245	+	case 0x31 /* '1' */ :
1246	+	case 0x32 /* '2' */ :
1247	+	case 0x33 /* '3' */ :
1248	+	case 0x34 /* '4' */ :
1249	+	case 0x35 /* '5' */ :
1250	+	case 0x36 /* '6' */ :
1251	+	case 0x37 /* '7' */ :
1252	+	case 0x38 /* '8' */ :
1253	+	case 0x39 /* '9' */ :
1254	+	{
1255	+	matchRange('0','9');
1256	+	break;
1257	+	}
1258	+	default:
1259	+	{
1260	+	goto _loop120;
1261	+	}
1262	+	}
1263	+	}
1264	+	_loop120:;
1265	+	} // ( ... )*
1266	+	_ttype = testLiteralsTable(_ttype);
1267		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1268		_token = makeToken(_ttype);
1269		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1177 | Line 1272 | void MDLexer::mUnsignedSuffix(bool _createToken) {
1272		_saveIndex=0;
1273		}
1274
1275	<	void MDLexer::mFloatSuffix(bool _createToken) {
1275	>	void MDLexer::mHEX_DIGIT(bool _createToken) {
1276		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1277	<	_ttype = FloatSuffix;
1277	>	_ttype = HEX_DIGIT;
1278		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1279
1280	+	{
1281		switch ( LA(1)) {
1282	<	case 0x66 /* 'f' */ :
1282	>	case 0x30 /* '0' */ :
1283	>	case 0x31 /* '1' */ :
1284	>	case 0x32 /* '2' */ :
1285	>	case 0x33 /* '3' */ :
1286	>	case 0x34 /* '4' */ :
1287	>	case 0x35 /* '5' */ :
1288	>	case 0x36 /* '6' */ :
1289	>	case 0x37 /* '7' */ :
1290	>	case 0x38 /* '8' */ :
1291	>	case 0x39 /* '9' */ :
1292		{
1293	<	match('f' /* charlit */ );
1293	>	matchRange('0','9');
1294		break;
1295		}
1296	+	case 0x41 /* 'A' */ :
1297	+	case 0x42 /* 'B' */ :
1298	+	case 0x43 /* 'C' */ :
1299	+	case 0x44 /* 'D' */ :
1300	+	case 0x45 /* 'E' */ :
1301		case 0x46 /* 'F' */ :
1302		{
1303	<	match('F' /* charlit */ );
1303	>	matchRange('A','F');
1304		break;
1305		}
1306	+	case 0x61 /* 'a' */ :
1307	+	case 0x62 /* 'b' */ :
1308	+	case 0x63 /* 'c' */ :
1309	+	case 0x64 /* 'd' */ :
1310	+	case 0x65 /* 'e' */ :
1311	+	case 0x66 /* 'f' */ :
1312	+	{
1313	+	matchRange('a','f');
1314	+	break;
1315	+	}
1316		default:
1317		{
1318		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1319		}
1320		}
1321	+	}
1322		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1323		_token = makeToken(_ttype);
1324		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1206 | Line 1327 | void MDLexer::mFloatSuffix(bool _createToken) {
1327		_saveIndex=0;
1328		}
1329
1330	<	void MDLexer::mExponent(bool _createToken) {
1330	>	void MDLexer::mNUM_INT(bool _createToken) {
1331		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1332	<	_ttype = Exponent;
1332	>	_ttype = NUM_INT;
1333		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1334	+	ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1335	+	ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1336	+	ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1337	+	ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1338	+	#line 395 "MDParser.g"
1339
1340	+	bool isDecimal = false;
1341	+	ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1342	+
1343	+	#line 1344 "MDLexer.cpp"
1344	+
1345		{
1346		switch ( LA(1)) {
1216	–	case 0x65 /* 'e' */ :
1217	–	{
1218	–	match('e' /* charlit */ );
1219	–	break;
1220	–	}
1221	–	case 0x45 /* 'E' */ :
1222	–	{
1223	–	match('E' /* charlit */ );
1224	–	break;
1225	–	}
1226	–	case 0x64 /* 'd' */ :
1227	–	{
1228	–	match('d' /* charlit */ );
1229	–	break;
1230	–	}
1231	–	case 0x44 /* 'D' */ :
1232	–	{
1233	–	match('D' /* charlit */ );
1234	–	break;
1235	–	}
1236	–	default:
1237	–	{
1238	–	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1239	–	}
1240	–	}
1241	–	}
1242	–	{
1243	–	switch ( LA(1)) {
1347		case 0x2b /* '+' */ :
1348		{
1349		match('+' /* charlit */ );
#	Line 1251 | Line 1354 | void MDLexer::mExponent(bool _createToken) {
1354		match('-' /* charlit */ );
1355		break;
1356		}
1357	+	case 0x2e /* '.' */ :
1358		case 0x30 /* '0' */ :
1359		case 0x31 /* '1' */ :
1360		case 0x32 /* '2' */ :
#	Line 1270 | Line 1374 | void MDLexer::mExponent(bool _createToken) {
1374		}
1375		}
1376		}
1377	<	{ // ( ... )+
1378	<	int _cnt130=0;
1379	<	for (;;) {
1380	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1381	<	mDigit(false);
1377	>	{
1378	>	switch ( LA(1)) {
1379	>	case 0x2e /* '.' */ :
1380	>	{
1381	>	match('.' /* charlit */ );
1382	>	if ( inputState->guessing==0 ) {
1383	>	#line 402 "MDParser.g"
1384	>	_ttype = DOT;
1385	>	#line 1386 "MDLexer.cpp"
1386		}
1387	<	else {
1388	<	if ( _cnt130>=1 ) { goto _loop130; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1281	<	}
1282	<
1283	<	_cnt130++;
1284	<	}
1285	<	_loop130:;
1286	<	}  // ( ... )+
1287	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1288	<	_token = makeToken(_ttype);
1289	<	_token->setText(text.substr(_begin, text.length()-_begin));
1290	<	}
1291	<	_returnToken = _token;
1292	<	_saveIndex=0;
1293	<	}
1294	<
1295	<	void MDLexer::mVocabulary(bool _createToken) {
1296	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1297	<	_ttype = Vocabulary;
1298	<	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1299	<
1300	<	matchRange('\3',static_cast<unsigned char>('\377'));
1301	<	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1302	<	_token = makeToken(_ttype);
1303	<	_token->setText(text.substr(_begin, text.length()-_begin));
1304	<	}
1305	<	_returnToken = _token;
1306	<	_saveIndex=0;
1307	<	}
1308	<
1309	<	void MDLexer::mNumber(bool _createToken) {
1310	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1311	<	_ttype = Number;
1312	<	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1313	<
1314	<	bool synPredMatched137 = false;
1315	<	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_6.member(LA(2))) && (true))) {
1316	<	int _m137 = mark();
1317	<	synPredMatched137 = true;
1318	<	inputState->guessing++;
1319	<	try {
1320	<	{
1387	>	{
1388	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1389		{ // ( ... )+
1390	<	int _cnt135=0;
1390	>	int _cnt132=0;
1391		for (;;) {
1392		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1393	<	mDigit(false);
1393	>	matchRange('0','9');
1394		}
1395		else {
1396	<	if ( _cnt135>=1 ) { goto _loop135; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1396	>	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1397		}
1398
1399	<	_cnt135++;
1399	>	_cnt132++;
1400		}
1401	<	_loop135:;
1401	>	_loop132:;
1402		}  // ( ... )+
1403		{
1404	<	switch ( LA(1)) {
1405	<	case 0x2e /* '.' */ :
1338	<	{
1339	<	match('.' /* charlit */ );
1340	<	break;
1404	>	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1405	>	mEXPONENT(false);
1406		}
1342	–	case 0x65 /* 'e' */ :
1343	–	{
1344	–	match('e' /* charlit */ );
1345	–	break;
1346	–	}
1347	–	case 0x45 /* 'E' */ :
1348	–	{
1349	–	match('E' /* charlit */ );
1350	–	break;
1351	–	}
1352	–	case 0x64 /* 'd' */ :
1353	–	{
1354	–	match('d' /* charlit */ );
1355	–	break;
1356	–	}
1357	–	case 0x44 /* 'D' */ :
1358	–	{
1359	–	match('D' /* charlit */ );
1360	–	break;
1361	–	}
1362	–	default:
1363	–	{
1364	–	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1365	–	}
1366	–	}
1367	–	}
1368	–	}
1369	–	}
1370	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1371	–	synPredMatched137 = false;
1372	–	}
1373	–	rewind(_m137);
1374	–	inputState->guessing--;
1375	–	}
1376	–	if ( synPredMatched137 ) {
1377	–	{ // ( ... )+
1378	–	int _cnt139=0;
1379	–	for (;;) {
1380	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1381	–	mDigit(false);
1382	–	}
1407		else {
1384	–	if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1408		}
1409
1387	–	_cnt139++;
1388	–	}
1389	–	_loop139:;
1390	–	}  // ( ... )+
1391	–	{
1392	–	switch ( LA(1)) {
1393	–	case 0x2e /* '.' */ :
1394	–	{
1395	–	match('.' /* charlit */ );
1396	–	{ // ( ... )*
1397	–	for (;;) {
1398	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1399	–	mDigit(false);
1400	–	}
1401	–	else {
1402	–	goto _loop142;
1403	–	}
1404	–
1410		}
1406	–	_loop142:;
1407	–	} // ( ... )*
1411		{
1412	<	if ((_tokenSet_7.member(LA(1)))) {
1413	<	mExponent(false);
1412	>	if ((_tokenSet_6.member(LA(1)))) {
1413	>	mFLOAT_SUFFIX(true);
1414	>	f1=_returnToken;
1415	>	if ( inputState->guessing==0 ) {
1416	>	#line 403 "MDParser.g"
1417	>	t=f1;
1418	>	#line 1419 "MDLexer.cpp"
1419	>	}
1420		}
1421		else {
1422		}
1423
1424		}
1425		if ( inputState->guessing==0 ) {
1426	<	#line 451 "MDParser.g"
1427	<	_ttype = FLOATONE;
1428	<	#line 1420 "MDLexer.cpp"
1426	>	#line 404 "MDParser.g"
1427	>
1428	>	if ( t &&
1429	>	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1430	>	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1431	>	_ttype = NUM_FLOAT;
1432	>	}
1433	>	else {
1434	>	_ttype = NUM_DOUBLE; // assume double
1435	>	}
1436	>
1437	>	#line 1438 "MDLexer.cpp"
1438		}
1421	–	break;
1439		}
1440	<	case 0x44 /* 'D' */ :
1424	<	case 0x45 /* 'E' */ :
1425	<	case 0x64 /* 'd' */ :
1426	<	case 0x65 /* 'e' */ :
1427	<	{
1428	<	mExponent(false);
1429	<	if ( inputState->guessing==0 ) {
1430	<	#line 452 "MDParser.g"
1431	<	_ttype = FLOATTWO;
1432	<	#line 1433 "MDLexer.cpp"
1433	<	}
1434	<	break;
1440	>	else {
1441		}
1442	<	default:
1437	<	{
1438	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1442	>
1443		}
1444	<	}
1441	<	}
1442	<	{
1443	<	switch ( LA(1)) {
1444	<	case 0x46 /* 'F' */ :
1445	<	case 0x66 /* 'f' */ :
1446	<	{
1447	<	mFloatSuffix(false);
1448	<	break;
1449	<	}
1450	<	case 0x4c /* 'L' */ :
1451	<	case 0x6c /* 'l' */ :
1452	<	{
1453	<	mLongSuffix(false);
1454	<	break;
1455	<	}
1456	<	default:
1457	<	{
1458	<	}
1459	<	}
1460	<	}
1444	>	break;
1445		}
1446	<	else if ((LA(1) == 0x30 /* '0' */ ) && (LA(2) == 0x58 /* 'X' */  || LA(2) == 0x78 /* 'x' */ )) {
1447	<	match('0' /* charlit */ );
1446	>	case 0x30 /* '0' */ :
1447	>	case 0x31 /* '1' */ :
1448	>	case 0x32 /* '2' */ :
1449	>	case 0x33 /* '3' */ :
1450	>	case 0x34 /* '4' */ :
1451	>	case 0x35 /* '5' */ :
1452	>	case 0x36 /* '6' */ :
1453	>	case 0x37 /* '7' */ :
1454	>	case 0x38 /* '8' */ :
1455	>	case 0x39 /* '9' */ :
1456	>	{
1457		{
1458		switch ( LA(1)) {
1459	<	case 0x78 /* 'x' */ :
1459	>	case 0x30 /* '0' */ :
1460		{
1461	<	match('x' /* charlit */ );
1462	<	break;
1463	<	}
1464	<	case 0x58 /* 'X' */ :
1465	<	{
1473	<	match('X' /* charlit */ );
1474	<	break;
1475	<	}
1476	<	default:
1477	<	{
1478	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1479	<	}
1480	<	}
1481	<	}
1482	<	{ // ( ... )+
1483	<	int _cnt160=0;
1484	<	for (;;) {
1485	<	switch ( LA(1)) {
1486	<	case 0x61 /* 'a' */ :
1487	<	case 0x62 /* 'b' */ :
1488	<	case 0x63 /* 'c' */ :
1489	<	case 0x64 /* 'd' */ :
1490	<	case 0x65 /* 'e' */ :
1491	<	case 0x66 /* 'f' */ :
1492	<	{
1493	<	matchRange('a','f');
1494	<	break;
1461	>	match('0' /* charlit */ );
1462	>	if ( inputState->guessing==0 ) {
1463	>	#line 416 "MDParser.g"
1464	>	isDecimal = true;
1465	>	#line 1466 "MDLexer.cpp"
1466		}
1496	–	case 0x41 /* 'A' */ :
1497	–	case 0x42 /* 'B' */ :
1498	–	case 0x43 /* 'C' */ :
1499	–	case 0x44 /* 'D' */ :
1500	–	case 0x45 /* 'E' */ :
1501	–	case 0x46 /* 'F' */ :
1467		{
1468	<	matchRange('A','F');
1469	<	break;
1468	>	if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
1469	>	{
1470	>	switch ( LA(1)) {
1471	>	case 0x78 /* 'x' */ :
1472	>	{
1473	>	match('x' /* charlit */ );
1474	>	break;
1475	>	}
1476	>	case 0x58 /* 'X' */ :
1477	>	{
1478	>	match('X' /* charlit */ );
1479	>	break;
1480	>	}
1481	>	default:
1482	>	{
1483	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1484	>	}
1485	>	}
1486	>	}
1487	>	{ // ( ... )+
1488	>	int _cnt139=0;
1489	>	for (;;) {
1490	>	if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1491	>	mHEX_DIGIT(false);
1492	>	}
1493	>	else {
1494	>	if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1495	>	}
1496	>
1497	>	_cnt139++;
1498	>	}
1499	>	_loop139:;
1500	>	}  // ( ... )+
1501		}
1502	<	case 0x30 /* '0' */ :
1503	<	case 0x31 /* '1' */ :
1504	<	case 0x32 /* '2' */ :
1505	<	case 0x33 /* '3' */ :
1506	<	case 0x34 /* '4' */ :
1507	<	case 0x35 /* '5' */ :
1508	<	case 0x36 /* '6' */ :
1509	<	case 0x37 /* '7' */ :
1510	<	case 0x38 /* '8' */ :
1511	<	case 0x39 /* '9' */ :
1512	<	{
1513	<	mDigit(false);
1514	<	break;
1502	>	else {
1503	>	bool synPredMatched144 = false;
1504	>	if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1505	>	int _m144 = mark();
1506	>	synPredMatched144 = true;
1507	>	inputState->guessing++;
1508	>	try {
1509	>	{
1510	>	{ // ( ... )+
1511	>	int _cnt142=0;
1512	>	for (;;) {
1513	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1514	>	matchRange('0','9');
1515	>	}
1516	>	else {
1517	>	if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1518	>	}
1519	>
1520	>	_cnt142++;
1521	>	}
1522	>	_loop142:;
1523	>	}  // ( ... )+
1524	>	{
1525	>	switch ( LA(1)) {
1526	>	case 0x2e /* '.' */ :
1527	>	{
1528	>	match('.' /* charlit */ );
1529	>	break;
1530	>	}
1531	>	case 0x45 /* 'E' */ :
1532	>	case 0x65 /* 'e' */ :
1533	>	{
1534	>	mEXPONENT(false);
1535	>	break;
1536	>	}
1537	>	case 0x44 /* 'D' */ :
1538	>	case 0x46 /* 'F' */ :
1539	>	case 0x64 /* 'd' */ :
1540	>	case 0x66 /* 'f' */ :
1541	>	{
1542	>	mFLOAT_SUFFIX(false);
1543	>	break;
1544	>	}
1545	>	default:
1546	>	{
1547	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1548	>	}
1549	>	}
1550	>	}
1551	>	}
1552	>	}
1553	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1554	>	synPredMatched144 = false;
1555	>	}
1556	>	rewind(_m144);
1557	>	inputState->guessing--;
1558	>	}
1559	>	if ( synPredMatched144 ) {
1560	>	{ // ( ... )+
1561	>	int _cnt146=0;
1562	>	for (;;) {
1563	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1564	>	matchRange('0','9');
1565	>	}
1566	>	else {
1567	>	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1568	>	}
1569	>
1570	>	_cnt146++;
1571	>	}
1572	>	_loop146:;
1573	>	}  // ( ... )+
1574	>	}
1575	>	else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1576	>	{ // ( ... )+
1577	>	int _cnt148=0;
1578	>	for (;;) {
1579	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1580	>	matchRange('0','7');
1581	>	}
1582	>	else {
1583	>	if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1584	>	}
1585	>
1586	>	_cnt148++;
1587	>	}
1588	>	_loop148:;
1589	>	}  // ( ... )+
1590	>	}
1591	>	else {
1592	>	}
1593		}
1520	–	default:
1521	–	{
1522	–	if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1594		}
1595	<	}
1525	<	_cnt160++;
1595	>	break;
1596		}
1597	<	_loop160:;
1598	<	}  // ( ... )+
1599	<	{ // ( ... )*
1600	<	for (;;) {
1601	<	switch ( LA(1)) {
1602	<	case 0x4c /* 'L' */ :
1603	<	case 0x6c /* 'l' */ :
1597	>	case 0x31 /* '1' */ :
1598	>	case 0x32 /* '2' */ :
1599	>	case 0x33 /* '3' */ :
1600	>	case 0x34 /* '4' */ :
1601	>	case 0x35 /* '5' */ :
1602	>	case 0x36 /* '6' */ :
1603	>	case 0x37 /* '7' */ :
1604	>	case 0x38 /* '8' */ :
1605	>	case 0x39 /* '9' */ :
1606	>	{
1607		{
1608	<	mLongSuffix(false);
1536	<	break;
1608	>	matchRange('1','9');
1609		}
1610	<	case 0x55 /* 'U' */ :
1539	<	case 0x75 /* 'u' */ :
1540	<	{
1541	<	mUnsignedSuffix(false);
1542	<	break;
1543	<	}
1544	<	default:
1545	<	{
1546	<	goto _loop162;
1547	<	}
1548	<	}
1549	<	}
1550	<	_loop162:;
1551	<	} // ( ... )*
1552	<	if ( inputState->guessing==0 ) {
1553	<	#line 480 "MDParser.g"
1554	<	_ttype = HEXADECIMALINT;
1555	<	#line 1556 "MDLexer.cpp"
1556	<	}
1557	<	}
1558	<	else if ((LA(1) == 0x2e /* '.' */ )) {
1559	<	match('.' /* charlit */ );
1560	<	if ( inputState->guessing==0 ) {
1561	<	#line 458 "MDParser.g"
1562	<	_ttype = DOT;
1563	<	#line 1564 "MDLexer.cpp"
1564	<	}
1565	<	{
1566	<	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1567	<	{ // ( ... )+
1568	<	int _cnt147=0;
1610	>	{ // ( ... )*
1611		for (;;) {
1612		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1613	<	mDigit(false);
1613	>	matchRange('0','9');
1614		}
1615		else {
1616	<	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1616	>	goto _loop151;
1617		}
1618
1577	–	_cnt147++;
1619		}
1620	<	_loop147:;
1621	<	}  // ( ... )+
1581	<	{
1582	<	if ((_tokenSet_7.member(LA(1)))) {
1583	<	mExponent(false);
1584	<	}
1585	<	else {
1586	<	}
1587	<
1588	<	}
1620	>	_loop151:;
1621	>	} // ( ... )*
1622		if ( inputState->guessing==0 ) {
1623	<	#line 459 "MDParser.g"
1624	<	_ttype = FLOATONE;
1625	<	#line 1593 "MDLexer.cpp"
1623	>	#line 433 "MDParser.g"
1624	>	isDecimal=true;
1625	>	#line 1626 "MDLexer.cpp"
1626		}
1627	<	{
1595	<	switch ( LA(1)) {
1596	<	case 0x46 /* 'F' */ :
1597	<	case 0x66 /* 'f' */ :
1598	<	{
1599	<	mFloatSuffix(false);
1600	<	break;
1601	<	}
1602	<	case 0x4c /* 'L' */ :
1603	<	case 0x6c /* 'l' */ :
1604	<	{
1605	<	mLongSuffix(false);
1606	<	break;
1607	<	}
1608	<	default:
1609	<	{
1610	<	}
1611	<	}
1612	<	}
1627	>	break;
1628		}
1629	<	else {
1629	>	default:
1630	>	{
1631	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1632		}
1616	–
1633		}
1618	–	}
1619	–	else if ((LA(1) == 0x30 /* '0' */ ) && (true) && (true)) {
1620	–	match('0' /* charlit */ );
1621	–	{ // ( ... )*
1622	–	for (;;) {
1623	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1624	–	matchRange('0','7');
1625	–	}
1626	–	else {
1627	–	goto _loop151;
1628	–	}
1629	–
1634		}
1635	<	_loop151:;
1636	<	} // ( ... )*
1637	<	{ // ( ... )*
1634	<	for (;;) {
1635	>	{
1636	>	if ((LA(1) == 0x4c /* 'L' */  || LA(1) == 0x6c /* 'l' */ )) {
1637	>	{
1638		switch ( LA(1)) {
1636	–	case 0x4c /* 'L' */ :
1639		case 0x6c /* 'l' */ :
1640		{
1641	<	mLongSuffix(false);
1641	>	match('l' /* charlit */ );
1642		break;
1643		}
1644	<	case 0x55 /* 'U' */ :
1643	<	case 0x75 /* 'u' */ :
1644	>	case 0x4c /* 'L' */ :
1645		{
1646	<	mUnsignedSuffix(false);
1646	>	match('L' /* charlit */ );
1647		break;
1648		}
1649		default:
1650		{
1651	<	goto _loop153;
1651	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1652		}
1653		}
1653	–	}
1654	–	_loop153:;
1655	–	} // ( ... )*
1656	–	if ( inputState->guessing==0 ) {
1657	–	#line 469 "MDParser.g"
1658	–	_ttype = OCTALINT;
1659	–	#line 1660 "MDLexer.cpp"
1660	–	}
1661	–	}
1662	–	else if (((LA(1) >= 0x31 /* '1' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true)) {
1663	–	matchRange('1','9');
1664	–	{ // ( ... )*
1665	–	for (;;) {
1666	–	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1667	–	mDigit(false);
1654		}
1655	<	else {
1656	<	goto _loop155;
1655	>	if ( inputState->guessing==0 ) {
1656	>	#line 435 "MDParser.g"
1657	>	_ttype = NUM_LONG;
1658	>	#line 1659 "MDLexer.cpp"
1659		}
1672	–
1660		}
1661	<	_loop155:;
1662	<	} // ( ... )*
1676	<	{ // ( ... )*
1677	<	for (;;) {
1661	>	else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1662	>	{
1663		switch ( LA(1)) {
1664	<	case 0x4c /* 'L' */ :
1680	<	case 0x6c /* 'l' */ :
1664	>	case 0x2e /* '.' */ :
1665		{
1666	<	mLongSuffix(false);
1666	>	match('.' /* charlit */ );
1667	>	{ // ( ... )*
1668	>	for (;;) {
1669	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1670	>	matchRange('0','9');
1671	>	}
1672	>	else {
1673	>	goto _loop156;
1674	>	}
1675	>
1676	>	}
1677	>	_loop156:;
1678	>	} // ( ... )*
1679	>	{
1680	>	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1681	>	mEXPONENT(false);
1682	>	}
1683	>	else {
1684	>	}
1685	>
1686	>	}
1687	>	{
1688	>	if ((_tokenSet_6.member(LA(1)))) {
1689	>	mFLOAT_SUFFIX(true);
1690	>	f2=_returnToken;
1691	>	if ( inputState->guessing==0 ) {
1692	>	#line 439 "MDParser.g"
1693	>	t=f2;
1694	>	#line 1695 "MDLexer.cpp"
1695	>	}
1696	>	}
1697	>	else {
1698	>	}
1699	>
1700	>	}
1701		break;
1702		}
1703	<	case 0x55 /* 'U' */ :
1704	<	case 0x75 /* 'u' */ :
1703	>	case 0x45 /* 'E' */ :
1704	>	case 0x65 /* 'e' */ :
1705		{
1706	<	mUnsignedSuffix(false);
1706	>	mEXPONENT(false);
1707	>	{
1708	>	if ((_tokenSet_6.member(LA(1)))) {
1709	>	mFLOAT_SUFFIX(true);
1710	>	f3=_returnToken;
1711	>	if ( inputState->guessing==0 ) {
1712	>	#line 440 "MDParser.g"
1713	>	t=f3;
1714	>	#line 1715 "MDLexer.cpp"
1715	>	}
1716	>	}
1717	>	else {
1718	>	}
1719	>
1720	>	}
1721		break;
1722		}
1723	+	case 0x44 /* 'D' */ :
1724	+	case 0x46 /* 'F' */ :
1725	+	case 0x64 /* 'd' */ :
1726	+	case 0x66 /* 'f' */ :
1727	+	{
1728	+	mFLOAT_SUFFIX(true);
1729	+	f4=_returnToken;
1730	+	if ( inputState->guessing==0 ) {
1731	+	#line 441 "MDParser.g"
1732	+	t=f4;
1733	+	#line 1734 "MDLexer.cpp"
1734	+	}
1735	+	break;
1736	+	}
1737		default:
1738		{
1739	<	goto _loop157;
1739	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1740		}
1741		}
1742	+	}
1743	+	if ( inputState->guessing==0 ) {
1744	+	#line 443 "MDParser.g"
1745	+
1746	+	if ( t &&
1747	+	(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
1748	+	t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
1749	+	_ttype = NUM_FLOAT;
1750	+	}
1751	+	else {
1752	+	_ttype = NUM_DOUBLE; // assume double
1753	+	}
1754	+
1755	+	#line 1756 "MDLexer.cpp"
1756	+	}
1757		}
1758	<	_loop157:;
1698	<	} // ( ... )*
1699	<	if ( inputState->guessing==0 ) {
1700	<	#line 474 "MDParser.g"
1701	<	_ttype = DECIMALINT;
1702	<	#line 1703 "MDLexer.cpp"
1758	>	else {
1759		}
1760	+
1761	+	}
1762	+	break;
1763		}
1764	<	else {
1764	>	default:
1765	>	{
1766		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1767		}
1768	<
1768	>	}
1769	>	}
1770		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1771		_token = makeToken(_ttype);
1772		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1714 | Line 1775 | void MDLexer::mNumber(bool _createToken) {
1775		_saveIndex=0;
1776		}
1777
1778	<	void MDLexer::mID(bool _createToken) {
1778	>	void MDLexer::mEXPONENT(bool _createToken) {
1779		int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1780	<	_ttype = ID;
1780	>	_ttype = EXPONENT;
1781		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1782
1783		{
1784		switch ( LA(1)) {
1724	–	case 0x61 /* 'a' */ :
1725	–	case 0x62 /* 'b' */ :
1726	–	case 0x63 /* 'c' */ :
1727	–	case 0x64 /* 'd' */ :
1785		case 0x65 /* 'e' */ :
1729	–	case 0x66 /* 'f' */ :
1730	–	case 0x67 /* 'g' */ :
1731	–	case 0x68 /* 'h' */ :
1732	–	case 0x69 /* 'i' */ :
1733	–	case 0x6a /* 'j' */ :
1734	–	case 0x6b /* 'k' */ :
1735	–	case 0x6c /* 'l' */ :
1736	–	case 0x6d /* 'm' */ :
1737	–	case 0x6e /* 'n' */ :
1738	–	case 0x6f /* 'o' */ :
1739	–	case 0x70 /* 'p' */ :
1740	–	case 0x71 /* 'q' */ :
1741	–	case 0x72 /* 'r' */ :
1742	–	case 0x73 /* 's' */ :
1743	–	case 0x74 /* 't' */ :
1744	–	case 0x75 /* 'u' */ :
1745	–	case 0x76 /* 'v' */ :
1746	–	case 0x77 /* 'w' */ :
1747	–	case 0x78 /* 'x' */ :
1748	–	case 0x79 /* 'y' */ :
1749	–	case 0x7a /* 'z' */ :
1786		{
1787	<	matchRange('a','z');
1787	>	match('e' /* charlit */ );
1788		break;
1789		}
1754	–	case 0x41 /* 'A' */ :
1755	–	case 0x42 /* 'B' */ :
1756	–	case 0x43 /* 'C' */ :
1757	–	case 0x44 /* 'D' */ :
1790		case 0x45 /* 'E' */ :
1759	–	case 0x46 /* 'F' */ :
1760	–	case 0x47 /* 'G' */ :
1761	–	case 0x48 /* 'H' */ :
1762	–	case 0x49 /* 'I' */ :
1763	–	case 0x4a /* 'J' */ :
1764	–	case 0x4b /* 'K' */ :
1765	–	case 0x4c /* 'L' */ :
1766	–	case 0x4d /* 'M' */ :
1767	–	case 0x4e /* 'N' */ :
1768	–	case 0x4f /* 'O' */ :
1769	–	case 0x50 /* 'P' */ :
1770	–	case 0x51 /* 'Q' */ :
1771	–	case 0x52 /* 'R' */ :
1772	–	case 0x53 /* 'S' */ :
1773	–	case 0x54 /* 'T' */ :
1774	–	case 0x55 /* 'U' */ :
1775	–	case 0x56 /* 'V' */ :
1776	–	case 0x57 /* 'W' */ :
1777	–	case 0x58 /* 'X' */ :
1778	–	case 0x59 /* 'Y' */ :
1779	–	case 0x5a /* 'Z' */ :
1791		{
1792	<	matchRange('A','Z');
1792	>	match('E' /* charlit */ );
1793		break;
1794		}
1795	<	case 0x5f /* '_' */ :
1795	>	default:
1796		{
1797	<	match('_' /* charlit */ );
1797	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1798	>	}
1799	>	}
1800	>	}
1801	>	{
1802	>	switch ( LA(1)) {
1803	>	case 0x2b /* '+' */ :
1804	>	{
1805	>	match('+' /* charlit */ );
1806		break;
1807		}
1808	+	case 0x2d /* '-' */ :
1809	+	{
1810	+	match('-' /* charlit */ );
1811	+	break;
1812	+	}
1813	+	case 0x30 /* '0' */ :
1814	+	case 0x31 /* '1' */ :
1815	+	case 0x32 /* '2' */ :
1816	+	case 0x33 /* '3' */ :
1817	+	case 0x34 /* '4' */ :
1818	+	case 0x35 /* '5' */ :
1819	+	case 0x36 /* '6' */ :
1820	+	case 0x37 /* '7' */ :
1821	+	case 0x38 /* '8' */ :
1822	+	case 0x39 /* '9' */ :
1823	+	{
1824	+	break;
1825	+	}
1826		default:
1827		{
1828		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1829		}
1830		}
1831		}
1832	<	{ // ( ... )*
1832	>	{ // ( ... )+
1833	>	int _cnt164=0;
1834		for (;;) {
1835	<	switch ( LA(1)) {
1798	<	case 0x61 /* 'a' */ :
1799	<	case 0x62 /* 'b' */ :
1800	<	case 0x63 /* 'c' */ :
1801	<	case 0x64 /* 'd' */ :
1802	<	case 0x65 /* 'e' */ :
1803	<	case 0x66 /* 'f' */ :
1804	<	case 0x67 /* 'g' */ :
1805	<	case 0x68 /* 'h' */ :
1806	<	case 0x69 /* 'i' */ :
1807	<	case 0x6a /* 'j' */ :
1808	<	case 0x6b /* 'k' */ :
1809	<	case 0x6c /* 'l' */ :
1810	<	case 0x6d /* 'm' */ :
1811	<	case 0x6e /* 'n' */ :
1812	<	case 0x6f /* 'o' */ :
1813	<	case 0x70 /* 'p' */ :
1814	<	case 0x71 /* 'q' */ :
1815	<	case 0x72 /* 'r' */ :
1816	<	case 0x73 /* 's' */ :
1817	<	case 0x74 /* 't' */ :
1818	<	case 0x75 /* 'u' */ :
1819	<	case 0x76 /* 'v' */ :
1820	<	case 0x77 /* 'w' */ :
1821	<	case 0x78 /* 'x' */ :
1822	<	case 0x79 /* 'y' */ :
1823	<	case 0x7a /* 'z' */ :
1824	<	{
1825	<	matchRange('a','z');
1826	<	break;
1827	<	}
1828	<	case 0x41 /* 'A' */ :
1829	<	case 0x42 /* 'B' */ :
1830	<	case 0x43 /* 'C' */ :
1831	<	case 0x44 /* 'D' */ :
1832	<	case 0x45 /* 'E' */ :
1833	<	case 0x46 /* 'F' */ :
1834	<	case 0x47 /* 'G' */ :
1835	<	case 0x48 /* 'H' */ :
1836	<	case 0x49 /* 'I' */ :
1837	<	case 0x4a /* 'J' */ :
1838	<	case 0x4b /* 'K' */ :
1839	<	case 0x4c /* 'L' */ :
1840	<	case 0x4d /* 'M' */ :
1841	<	case 0x4e /* 'N' */ :
1842	<	case 0x4f /* 'O' */ :
1843	<	case 0x50 /* 'P' */ :
1844	<	case 0x51 /* 'Q' */ :
1845	<	case 0x52 /* 'R' */ :
1846	<	case 0x53 /* 'S' */ :
1847	<	case 0x54 /* 'T' */ :
1848	<	case 0x55 /* 'U' */ :
1849	<	case 0x56 /* 'V' */ :
1850	<	case 0x57 /* 'W' */ :
1851	<	case 0x58 /* 'X' */ :
1852	<	case 0x59 /* 'Y' */ :
1853	<	case 0x5a /* 'Z' */ :
1854	<	{
1855	<	matchRange('A','Z');
1856	<	break;
1857	<	}
1858	<	case 0x5f /* '_' */ :
1859	<	{
1860	<	match('_' /* charlit */ );
1861	<	break;
1862	<	}
1863	<	case 0x30 /* '0' */ :
1864	<	case 0x31 /* '1' */ :
1865	<	case 0x32 /* '2' */ :
1866	<	case 0x33 /* '3' */ :
1867	<	case 0x34 /* '4' */ :
1868	<	case 0x35 /* '5' */ :
1869	<	case 0x36 /* '6' */ :
1870	<	case 0x37 /* '7' */ :
1871	<	case 0x38 /* '8' */ :
1872	<	case 0x39 /* '9' */ :
1873	<	{
1835	>	if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1836		matchRange('0','9');
1875	–	break;
1837		}
1838	<	default:
1839	<	{
1879	<	goto _loop166;
1838	>	else {
1839	>	if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1840		}
1841	<	}
1841	>
1842	>	_cnt164++;
1843		}
1844	<	_loop166:;
1845	<	} // ( ... )*
1885	<	_ttype = testLiteralsTable(_ttype);
1844	>	_loop164:;
1845	>	}  // ( ... )+
1846		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1847		_token = makeToken(_ttype);
1848		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1891 | Line 1851 | void MDLexer::mID(bool _createToken) {
1851		_saveIndex=0;
1852		}
1853
1854	+	void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1855	+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1856	+	_ttype = FLOAT_SUFFIX;
1857	+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1858	+
1859	+	switch ( LA(1)) {
1860	+	case 0x66 /* 'f' */ :
1861	+	{
1862	+	match('f' /* charlit */ );
1863	+	break;
1864	+	}
1865	+	case 0x46 /* 'F' */ :
1866	+	{
1867	+	match('F' /* charlit */ );
1868	+	break;
1869	+	}
1870	+	case 0x64 /* 'd' */ :
1871	+	{
1872	+	match('d' /* charlit */ );
1873	+	break;
1874	+	}
1875	+	case 0x44 /* 'D' */ :
1876	+	{
1877	+	match('D' /* charlit */ );
1878	+	break;
1879	+	}
1880	+	default:
1881	+	{
1882	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1883	+	}
1884	+	}
1885	+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1886	+	_token = makeToken(_ttype);
1887	+	_token->setText(text.substr(_begin, text.length()-_begin));
1888	+	}
1889	+	_returnToken = _token;
1890	+	_saveIndex=0;
1891	+	}
1892
1893	+
1894		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 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 6 7
1897	>	// \" # $ % & \' ( ) + , - . / 0 1 2
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1899		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1901		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1902	<	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1902	>	// \" # $ % & \' ( ) * + , - . / 0 1 2
1903		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1904		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905	<	// \" \' 0 1 2 3 4 5 6 7
1905	>	// \" \' 0 1 2
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1907		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 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 6 7
1910	>	// # $ % & \' ( ) * + , - . / 0 1 2
1911		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1912		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1913	<	// \' 0 1 2 3 4 5 6 7
1913	>	// \' 0 1 2
1914		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1915		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1917		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1918	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7
1918	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2
1919		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1920	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 67059712UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1922	<	// . 0 1 2 3 4 5 6 7
1920	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1922	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1922	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	>	// 0 1 2
1924		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1925	+	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	+	// .
1927	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1928

Diff Legend

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