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 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

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

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

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

Diff Legend

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