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 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
branches/development/src/mdParser/MDLexer.cpp (file contents), Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20110725): "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["torsion"] = 10;
34	<	literals["molecule"] = 5;
35	<	literals["inversion"] = 11;
36	<	literals["fragment"] = 14;
37	<	literals["bend"] = 9;
38	<	literals["orientation"] = 18;
39	<	literals["cutoffGroup"] = 13;
33	>	literals["flucQ"] = 20;
34	>	literals["cutoffGroup"] = 14;
35	>	literals["RNEMD"] = 21;
36	>	literals["rigidBody"] = 13;
37	>	literals["fragment"] = 15;
38		literals["zconstraint"] = 6;
39	<	literals["bond"] = 8;
42	<	literals["rigidBody"] = 12;
43	<	literals["center"] = 16;
39	>	literals["minimizer"] = 22;
40		literals["component"] = 4;
41	<	literals["position"] = 17;
42	<	literals["atom"] = 7;
43	<	literals["members"] = 15;
41	>	literals["center"] = 17;
42	>	literals["members"] = 16;
43	>	literals["position"] = 18;
44	>	literals["orientation"] = 19;
45	>	literals["bend"] = 10;
46	>	literals["torsion"] = 11;
47	>	literals["atom"] = 8;
48	>	literals["molecule"] = 5;
49	>	literals["restraint"] = 7;
50	>	literals["inversion"] = 12;
51	>	literals["bond"] = 9;
52		}
53
54		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 139 | Line 143 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
143		theRetToken=_returnToken;
144		break;
145		}
146	<	case 0x22 /* '"' */ :
146	>	case 0x22 /* '\"' */ :
147		{
148		mStringLiteral(true);
149		theRetToken=_returnToken;
#	Line 266 | Line 270 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
270		}
271
272		void MDLexer::mASSIGNEQUAL(bool _createToken) {
273	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
274	<	_ttype = ASSIGNEQUAL;
275	<	int _saveIndex;
273	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
274	>	_ttype = ASSIGNEQUAL;
275	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
276
277	<	match('=');
277	>	match('=' /* charlit */ );
278		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
279		_token = makeToken(_ttype);
280		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 280 | Line 284 | void MDLexer::mCOLON(bool _createToken) {
284		}
285
286		void MDLexer::mCOLON(bool _createToken) {
287	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
287	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
288		_ttype = COLON;
289	<	int _saveIndex;
289	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
290
291	<	match(':');
291	>	match(':' /* charlit */ );
292		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
293		_token = makeToken(_ttype);
294		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 294 | Line 298 | void MDLexer::mCOMMA(bool _createToken) {
298		}
299
300		void MDLexer::mCOMMA(bool _createToken) {
301	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
301	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
302		_ttype = COMMA;
303	<	int _saveIndex;
303	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
304
305	<	match(',');
305	>	match(',' /* charlit */ );
306		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
307		_token = makeToken(_ttype);
308		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 308 | Line 312 | void MDLexer::mQUESTIONMARK(bool _createToken) {
312		}
313
314		void MDLexer::mQUESTIONMARK(bool _createToken) {
315	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
315	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
316		_ttype = QUESTIONMARK;
317	<	int _saveIndex;
317	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
318
319	<	match('?');
319	>	match('?' /* charlit */ );
320		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
321		_token = makeToken(_ttype);
322		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 322 | Line 326 | void MDLexer::mSEMICOLON(bool _createToken) {
326		}
327
328		void MDLexer::mSEMICOLON(bool _createToken) {
329	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
329	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
330		_ttype = SEMICOLON;
331	<	int _saveIndex;
331	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
332
333	<	match(';');
333	>	match(';' /* charlit */ );
334		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
335		_token = makeToken(_ttype);
336		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 336 | Line 340 | void MDLexer::mLPAREN(bool _createToken) {
340		}
341
342		void MDLexer::mLPAREN(bool _createToken) {
343	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
343	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
344		_ttype = LPAREN;
345	<	int _saveIndex;
345	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
346
347	<	match('(');
347	>	match('(' /* charlit */ );
348		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
349		_token = makeToken(_ttype);
350		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 350 | Line 354 | void MDLexer::mRPAREN(bool _createToken) {
354		}
355
356		void MDLexer::mRPAREN(bool _createToken) {
357	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
357	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
358		_ttype = RPAREN;
359	<	int _saveIndex;
359	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
360
361	<	match(')');
361	>	match(')' /* charlit */ );
362		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
363		_token = makeToken(_ttype);
364		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 364 | Line 368 | void MDLexer::mLBRACKET(bool _createToken) {
368		}
369
370		void MDLexer::mLBRACKET(bool _createToken) {
371	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
371	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
372		_ttype = LBRACKET;
373	<	int _saveIndex;
373	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
374
375	<	match('[');
375	>	match('[' /* charlit */ );
376		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
377		_token = makeToken(_ttype);
378		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 378 | Line 382 | void MDLexer::mRBRACKET(bool _createToken) {
382		}
383
384		void MDLexer::mRBRACKET(bool _createToken) {
385	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
385	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
386		_ttype = RBRACKET;
387	<	int _saveIndex;
387	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
388
389	<	match(']');
389	>	match(']' /* charlit */ );
390		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
391		_token = makeToken(_ttype);
392		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 392 | Line 396 | void MDLexer::mLCURLY(bool _createToken) {
396		}
397
398		void MDLexer::mLCURLY(bool _createToken) {
399	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
399	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
400		_ttype = LCURLY;
401	<	int _saveIndex;
401	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
402
403	<	match('{');
403	>	match('{' /* charlit */ );
404		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
405		_token = makeToken(_ttype);
406		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 406 | Line 410 | void MDLexer::mRCURLY(bool _createToken) {
410		}
411
412		void MDLexer::mRCURLY(bool _createToken) {
413	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
414	<	_ttype = RCURLY;
415	<	int _saveIndex;
413	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
414	>	_ttype = RCURLY;
415	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
416
417	<	match('}');
417	>	match('}' /* charlit */ );
418		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
419		_token = makeToken(_ttype);
420		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 420 | Line 424 | void MDLexer::mWhitespace(bool _createToken) {
424		}
425
426		void MDLexer::mWhitespace(bool _createToken) {
427	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
427	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
428		_ttype = Whitespace;
429	<	int _saveIndex;
429	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
430
431		{
432		switch ( LA(1)) {
#	Line 434 | Line 438 | void MDLexer::mWhitespace(bool _createToken) {
438		switch ( LA(1)) {
439		case 0x20 /* ' ' */ :
440		{
441	<	match(' ');
441	>	match(' ' /* charlit */ );
442		break;
443		}
444		case 0x9 /* '\t' */ :
445		{
446	<	match('\t');
446	>	match('\t' /* charlit */ );
447		break;
448		}
449		case 0xc /* '\14' */ :
450		{
451	<	match('\14');
451	>	match('\14' /* charlit */ );
452		break;
453		}
454		default:
#	Line 460 | Line 464 | void MDLexer::mWhitespace(bool _createToken) {
464		{
465		{
466		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
467	<	match('\r');
468	<	match('\n');
467	>	match('\r' /* charlit */ );
468	>	match('\n' /* charlit */ );
469		}
470		else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
471	<	match('\r');
471	>	match('\r' /* charlit */ );
472		}
473		else if ((LA(1) == 0xa /* '\n' */ )) {
474	<	match('\n');
474	>	match('\n' /* charlit */ );
475		}
476		else {
477		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 475 | Line 479 | void MDLexer::mWhitespace(bool _createToken) {
479
480		}
481		if ( inputState->guessing==0 ) {
482	<	#line 227 "MDParser.g"
482	>	#line 248 "MDParser.g"
483		newline();
484	<	#line 481 "MDLexer.cpp"
484	>	#line 485 "MDLexer.cpp"
485		}
486		break;
487		}
#	Line 485 | Line 489 | void MDLexer::mWhitespace(bool _createToken) {
489		{
490		{
491		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
492	<	match('\\');
493	<	match('\r');
494	<	match('\n');
492	>	match('\\' /* charlit */ );
493	>	match('\r' /* charlit */ );
494	>	match('\n' /* charlit */ );
495		}
496		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
497	<	match('\\');
498	<	match('\r');
497	>	match('\\' /* charlit */ );
498	>	match('\r' /* charlit */ );
499		}
500		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
501	<	match('\\');
502	<	match('\n');
501	>	match('\\' /* charlit */ );
502	>	match('\n' /* charlit */ );
503		}
504		else {
505		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 503 | Line 507 | void MDLexer::mWhitespace(bool _createToken) {
507
508		}
509		if ( inputState->guessing==0 ) {
510	<	#line 232 "MDParser.g"
510	>	#line 253 "MDParser.g"
511		printf("CPP_parser.g continuation line detected\n");
512		deferredNewline();
513	<	#line 510 "MDLexer.cpp"
513	>	#line 514 "MDLexer.cpp"
514		}
515		break;
516		}
#	Line 517 | Line 521 | void MDLexer::mWhitespace(bool _createToken) {
521		}
522		}
523		if ( inputState->guessing==0 ) {
524	<	#line 235 "MDParser.g"
524	>	#line 256 "MDParser.g"
525		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
526	<	#line 523 "MDLexer.cpp"
526	>	#line 527 "MDLexer.cpp"
527		}
528		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
529		_token = makeToken(_ttype);
#	Line 530 | Line 534 | void MDLexer::mComment(bool _createToken) {
534		}
535
536		void MDLexer::mComment(bool _createToken) {
537	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
537	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
538		_ttype = Comment;
539	<	int _saveIndex;
539	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
540
541		match("/*");
542		{ // ( ... )*
543		for (;;) {
544	<	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
545	<	match('*');
544	>	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
545	>	match('*' /* charlit */ );
546		}
547		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
548		mEndOfLine(false);
549		if ( inputState->guessing==0 ) {
550	<	#line 242 "MDParser.g"
550	>	#line 263 "MDParser.g"
551		deferredNewline();
552	<	#line 549 "MDLexer.cpp"
552	>	#line 553 "MDLexer.cpp"
553		}
554		}
555		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 554 | Line 558 | void MDLexer::mComment(bool _createToken) {
558		}
559		}
560		else {
561	<	goto _loop83;
561	>	goto _loop95;
562		}
563
564		}
565	<	_loop83:;
565	>	_loop95:;
566		} // ( ... )*
567		match("*/");
568		if ( inputState->guessing==0 ) {
569	<	#line 245 "MDParser.g"
569	>	#line 266 "MDParser.g"
570		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
571	<	#line 568 "MDLexer.cpp"
571	>	#line 572 "MDLexer.cpp"
572		}
573		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
574		_token = makeToken(_ttype);
#	Line 575 | Line 579 | void MDLexer::mEndOfLine(bool _createToken) {
579		}
580
581		void MDLexer::mEndOfLine(bool _createToken) {
582	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
582	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
583		_ttype = EndOfLine;
584	<	int _saveIndex;
584	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
585
586		{
587		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
588		match("\r\n");
589		}
590		else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
591	<	match('\r');
591	>	match('\r' /* charlit */ );
592		}
593		else if ((LA(1) == 0xa /* '\n' */ )) {
594	<	match('\n');
594	>	match('\n' /* charlit */ );
595		}
596		else {
597		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 603 | Line 607 | void MDLexer::mCPPComment(bool _createToken) {
607		}
608
609		void MDLexer::mCPPComment(bool _createToken) {
610	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
610	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
611		_ttype = CPPComment;
612	<	int _saveIndex;
612	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
613
614		match("//");
615		{ // ( ... )*
#	Line 616 | Line 620 | void MDLexer::mCPPComment(bool _createToken) {
620		}
621		}
622		else {
623	<	goto _loop87;
623	>	goto _loop99;
624		}
625
626		}
627	<	_loop87:;
627	>	_loop99:;
628		} // ( ... )*
629		mEndOfLine(false);
630		if ( inputState->guessing==0 ) {
631	<	#line 251 "MDParser.g"
631	>	#line 272 "MDParser.g"
632		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
633	<	#line 630 "MDLexer.cpp"
633	>	#line 634 "MDLexer.cpp"
634		}
635		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
636		_token = makeToken(_ttype);
#	Line 637 | Line 641 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
641		}
642
643		void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
644	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
644	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
645		_ttype = PREPROC_DIRECTIVE;
646	<	int _saveIndex;
646	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
647
648	<	match('#');
648	>	match('#' /* charlit */ );
649		mLineDirective(false);
650		if ( inputState->guessing==0 ) {
651	<	#line 258 "MDParser.g"
651	>	#line 279 "MDParser.g"
652		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
653	<	#line 650 "MDLexer.cpp"
653	>	#line 654 "MDLexer.cpp"
654		}
655		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
656		_token = makeToken(_ttype);
#	Line 657 | Line 661 | void MDLexer::mLineDirective(bool _createToken) {
661		}
662
663		void MDLexer::mLineDirective(bool _createToken) {
664	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
664	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
665		_ttype = LineDirective;
666	<	int _saveIndex;
666	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
667		ANTLR_USE_NAMESPACE(antlr)RefToken n;
668		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
669
670		if ( inputState->guessing==0 ) {
671	<	#line 264 "MDParser.g"
671	>	#line 285 "MDParser.g"
672
673		deferredLineCount = 0;
674
675	<	#line 672 "MDLexer.cpp"
675	>	#line 676 "MDLexer.cpp"
676		}
677		{
678		switch ( LA(1)) {
#	Line 690 | Line 694 | void MDLexer::mLineDirective(bool _createToken) {
694		}
695		}
696		{ // ( ... )+
697	<	int _cnt92=0;
697	>	int _cnt104=0;
698		for (;;) {
699		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
700		mSpace(false);
701		}
702		else {
703	<	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
703	>	if ( _cnt104>=1 ) { goto _loop104; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
704		}
705
706	<	_cnt92++;
706	>	_cnt104++;
707		}
708	<	_loop92:;
708	>	_loop104:;
709		}  // ( ... )+
710		mDecimal(true);
711		n=_returnToken;
712		if ( inputState->guessing==0 ) {
713	<	#line 269 "MDParser.g"
714	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
715	<	#line 712 "MDLexer.cpp"
713	>	#line 290 "MDParser.g"
714	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
715	>	#line 716 "MDLexer.cpp"
716		}
717		{ // ( ... )+
718	<	int _cnt94=0;
718	>	int _cnt106=0;
719		for (;;) {
720		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
721		mSpace(false);
722		}
723		else {
724	<	if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724	>	if ( _cnt106>=1 ) { goto _loop106; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
725		}
726
727	<	_cnt94++;
727	>	_cnt106++;
728		}
729	<	_loop94:;
729	>	_loop106:;
730		}  // ( ... )+
731		{
732		mStringLiteral(true);
733		sl=_returnToken;
734		}
735		if ( inputState->guessing==0 ) {
736	<	#line 271 "MDParser.g"
736	>	#line 292 "MDParser.g"
737		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
738	<	#line 735 "MDLexer.cpp"
738	>	#line 739 "MDLexer.cpp"
739		}
740		{ // ( ... )*
741		for (;;) {
742		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
743		{ // ( ... )+
744	<	int _cnt98=0;
744	>	int _cnt110=0;
745		for (;;) {
746		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
747		mSpace(false);
748		}
749		else {
750	<	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
750	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
751		}
752
753	<	_cnt98++;
753	>	_cnt110++;
754		}
755	<	_loop98:;
755	>	_loop110:;
756		}  // ( ... )+
757		mDecimal(false);
758		}
759		else {
760	<	goto _loop99;
760	>	goto _loop111;
761		}
762
763		}
764	<	_loop99:;
764	>	_loop111:;
765		} // ( ... )*
766		mEndOfLine(false);
767		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 769 | Line 773 | void MDLexer::mSpace(bool _createToken) {
773		}
774
775		void MDLexer::mSpace(bool _createToken) {
776	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
776	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
777		_ttype = Space;
778	<	int _saveIndex;
778	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
779
780		{
781		switch ( LA(1)) {
782		case 0x20 /* ' ' */ :
783		{
784	<	match(' ');
784	>	match(' ' /* charlit */ );
785		break;
786		}
787		case 0x9 /* '\t' */ :
788		{
789	<	match('\t');
789	>	match('\t' /* charlit */ );
790		break;
791		}
792		case 0xc /* '\14' */ :
793		{
794	<	match('\14');
794	>	match('\14' /* charlit */ );
795		break;
796		}
797		default:
#	Line 805 | Line 809 | void MDLexer::mDecimal(bool _createToken) {
809		}
810
811		void MDLexer::mDecimal(bool _createToken) {
812	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
812	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
813		_ttype = Decimal;
814	<	int _saveIndex;
814	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
815
816		{ // ( ... )+
817	<	int _cnt129=0;
817	>	int _cnt141=0;
818		for (;;) {
819		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
820		matchRange('0','9');
821		}
822		else {
823	<	if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
823	>	if ( _cnt141>=1 ) { goto _loop141; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
824		}
825
826	<	_cnt129++;
826	>	_cnt141++;
827		}
828	<	_loop129:;
828	>	_loop141:;
829		}  // ( ... )+
830		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
831		_token = makeToken(_ttype);
#	Line 832 | Line 836 | void MDLexer::mStringLiteral(bool _createToken) {
836		}
837
838		void MDLexer::mStringLiteral(bool _createToken) {
839	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
839	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
840		_ttype = StringLiteral;
841	<	int _saveIndex;
841	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
842
843	<	match('"');
843	>	match('\"' /* charlit */ );
844		{ // ( ... )*
845		for (;;) {
846		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
#	Line 845 | Line 849 | void MDLexer::mStringLiteral(bool _createToken) {
849		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
850		{
851		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
852	<	match("\\r\n");
852	>	match("\\\r\n");
853		}
854		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
855	<	match("\\r");
855	>	match("\\\r");
856		}
857		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
858	<	match("\\n");
858	>	match("\\\n");
859		}
860		else {
861		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 859 | Line 863 | void MDLexer::mStringLiteral(bool _createToken) {
863
864		}
865		if ( inputState->guessing==0 ) {
866	<	#line 311 "MDParser.g"
866	>	#line 332 "MDParser.g"
867		deferredNewline();
868	<	#line 865 "MDLexer.cpp"
868	>	#line 869 "MDLexer.cpp"
869		}
870		}
871		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 870 | Line 874 | void MDLexer::mStringLiteral(bool _createToken) {
874		}
875		}
876		else {
877	<	goto _loop109;
877	>	goto _loop121;
878		}
879
880		}
881	<	_loop109:;
881	>	_loop121:;
882		} // ( ... )*
883	<	match('"');
883	>	match('\"' /* charlit */ );
884		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
885		_token = makeToken(_ttype);
886		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 886 | Line 890 | void MDLexer::mCharLiteral(bool _createToken) {
890		}
891
892		void MDLexer::mCharLiteral(bool _createToken) {
893	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
893	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
894		_ttype = CharLiteral;
895	<	int _saveIndex;
895	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
896
897	<	match('\'');
897	>	match('\'' /* charlit */ );
898		{
899		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
900		mEscape(false);
#	Line 905 | Line 909 | void MDLexer::mCharLiteral(bool _createToken) {
909		}
910
911		}
912	<	match('\'');
912	>	match('\'' /* charlit */ );
913		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
914		_token = makeToken(_ttype);
915		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 915 | Line 919 | void MDLexer::mEscape(bool _createToken) {
919		}
920
921		void MDLexer::mEscape(bool _createToken) {
922	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
922	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
923		_ttype = Escape;
924	<	int _saveIndex;
924	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
925
926	<	match('\\');
926	>	match('\\' /* charlit */ );
927		{
928		switch ( LA(1)) {
929		case 0x61 /* 'a' */ :
930		{
931	<	match('a');
931	>	match('a' /* charlit */ );
932		break;
933		}
934		case 0x62 /* 'b' */ :
935		{
936	<	match('b');
936	>	match('b' /* charlit */ );
937		break;
938		}
939		case 0x66 /* 'f' */ :
940		{
941	<	match('f');
941	>	match('f' /* charlit */ );
942		break;
943		}
944		case 0x6e /* 'n' */ :
945		{
946	<	match('n');
946	>	match('n' /* charlit */ );
947		break;
948		}
949		case 0x72 /* 'r' */ :
950		{
951	<	match('r');
951	>	match('r' /* charlit */ );
952		break;
953		}
954		case 0x74 /* 't' */ :
955		{
956	<	match('t');
956	>	match('t' /* charlit */ );
957		break;
958		}
959		case 0x76 /* 'v' */ :
960		{
961	<	match('v');
961	>	match('v' /* charlit */ );
962		break;
963		}
964	<	case 0x22 /* '"' */ :
964	>	case 0x22 /* '\"' */ :
965		{
966	<	match('"');
966	>	match('\"' /* charlit */ );
967		break;
968		}
969		case 0x27 /* '\'' */ :
970		{
971	<	match('\'');
971	>	match('\'' /* charlit */ );
972		break;
973		}
974		case 0x5c /* '\\' */ :
975		{
976	<	match('\\');
976	>	match('\\' /* charlit */ );
977		break;
978		}
979		case 0x3f /* '?' */ :
980		{
981	<	match('?');
981	>	match('?' /* charlit */ );
982		break;
983		}
984		case 0x30 /* '0' */ :
#	Line 1032 | Line 1036 | void MDLexer::mEscape(bool _createToken) {
1036		}
1037		case 0x78 /* 'x' */ :
1038		{
1039	<	match('x');
1039	>	match('x' /* charlit */ );
1040		{ // ( ... )+
1041	<	int _cnt120=0;
1041	>	int _cnt132=0;
1042		for (;;) {
1043		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1044		mDigit(false);
#	Line 1046 | Line 1050 | void MDLexer::mEscape(bool _createToken) {
1050		matchRange('A','F');
1051		}
1052		else {
1053	<	if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1053	>	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1054		}
1055
1056	<	_cnt120++;
1056	>	_cnt132++;
1057		}
1058	<	_loop120:;
1058	>	_loop132:;
1059		}  // ( ... )+
1060		break;
1061		}
#	Line 1070 | Line 1074 | void MDLexer::mDigit(bool _createToken) {
1074		}
1075
1076		void MDLexer::mDigit(bool _createToken) {
1077	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1077	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1078		_ttype = Digit;
1079	<	int _saveIndex;
1079	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1080
1081		matchRange('0','9');
1082		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1084 | Line 1088 | void MDLexer::mVocabulary(bool _createToken) {
1088		}
1089
1090		void MDLexer::mVocabulary(bool _createToken) {
1091	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1091	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1092		_ttype = Vocabulary;
1093	<	int _saveIndex;
1093	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1094
1095	<	matchRange('\3',static_cast<unsigned char>(255));
1095	>	matchRange('\3',static_cast<unsigned char>('\377'));
1096		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1097		_token = makeToken(_ttype);
1098		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1098 | Line 1102 | void MDLexer::mID(bool _createToken) {
1102		}
1103
1104		void MDLexer::mID(bool _createToken) {
1105	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1105	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1106		_ttype = ID;
1107	<	int _saveIndex;
1107	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1108
1109		{
1110		switch ( LA(1)) {
#	Line 1166 | Line 1170 | void MDLexer::mID(bool _createToken) {
1170		}
1171		case 0x5f /* '_' */ :
1172		{
1173	<	match('_');
1173	>	match('_' /* charlit */ );
1174		break;
1175		}
1176		default:
#	Line 1240 | Line 1244 | void MDLexer::mID(bool _createToken) {
1244		}
1245		case 0x5f /* '_' */ :
1246		{
1247	<	match('_');
1247	>	match('_' /* charlit */ );
1248		break;
1249		}
1250		case 0x30 /* '0' */ :
#	Line 1259 | Line 1263 | void MDLexer::mID(bool _createToken) {
1263		}
1264		default:
1265		{
1266	<	goto _loop125;
1266	>	goto _loop137;
1267		}
1268		}
1269		}
1270	<	_loop125:;
1270	>	_loop137:;
1271		} // ( ... )*
1272		_ttype = testLiteralsTable(_ttype);
1273		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1275 | Line 1279 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1279		}
1280
1281		void MDLexer::mHEX_DIGIT(bool _createToken) {
1282	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1282	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1283		_ttype = HEX_DIGIT;
1284	<	int _saveIndex;
1284	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1285
1286		{
1287		switch ( LA(1)) {
#	Line 1330 | Line 1334 | void MDLexer::mNUM_INT(bool _createToken) {
1334		}
1335
1336		void MDLexer::mNUM_INT(bool _createToken) {
1337	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1337	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1338		_ttype = NUM_INT;
1339	<	int _saveIndex;
1339	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1340		ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1341		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1342		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1343		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1344	<	#line 404 "MDParser.g"
1344	>	#line 425 "MDParser.g"
1345
1346		bool isDecimal = false;
1347		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1348
1349	<	#line 1346 "MDLexer.cpp"
1349	>	#line 1350 "MDLexer.cpp"
1350
1351		{
1352		switch ( LA(1)) {
1353		case 0x2b /* '+' */ :
1354		{
1355	<	match('+');
1355	>	match('+' /* charlit */ );
1356		break;
1357		}
1358		case 0x2d /* '-' */ :
1359		{
1360	<	match('-');
1360	>	match('-' /* charlit */ );
1361		break;
1362		}
1363		case 0x2e /* '.' */ :
#	Line 1380 | Line 1384 | void MDLexer::mNUM_INT(bool _createToken) {
1384		switch ( LA(1)) {
1385		case 0x2e /* '.' */ :
1386		{
1387	<	match('.');
1387	>	match('.' /* charlit */ );
1388		if ( inputState->guessing==0 ) {
1389	<	#line 411 "MDParser.g"
1389	>	#line 432 "MDParser.g"
1390		_ttype = DOT;
1391	<	#line 1388 "MDLexer.cpp"
1391	>	#line 1392 "MDLexer.cpp"
1392		}
1393		{
1394		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1395		{ // ( ... )+
1396	<	int _cnt137=0;
1396	>	int _cnt149=0;
1397		for (;;) {
1398		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1399		matchRange('0','9');
1400		}
1401		else {
1402	<	if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1402	>	if ( _cnt149>=1 ) { goto _loop149; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1403		}
1404
1405	<	_cnt137++;
1405	>	_cnt149++;
1406		}
1407	<	_loop137:;
1407	>	_loop149:;
1408		}  // ( ... )+
1409		{
1410		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1415 | Line 1419 | void MDLexer::mNUM_INT(bool _createToken) {
1419		mFLOAT_SUFFIX(true);
1420		f1=_returnToken;
1421		if ( inputState->guessing==0 ) {
1422	<	#line 412 "MDParser.g"
1422	>	#line 433 "MDParser.g"
1423		t=f1;
1424	<	#line 1421 "MDLexer.cpp"
1424	>	#line 1425 "MDLexer.cpp"
1425		}
1426		}
1427		else {
#	Line 1425 | Line 1429 | void MDLexer::mNUM_INT(bool _createToken) {
1429
1430		}
1431		if ( inputState->guessing==0 ) {
1432	<	#line 413 "MDParser.g"
1432	>	#line 434 "MDParser.g"
1433
1434		if ( t &&
1435		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1436 | Line 1440 | void MDLexer::mNUM_INT(bool _createToken) {
1440		_ttype = NUM_DOUBLE; // assume double
1441		}
1442
1443	<	#line 1440 "MDLexer.cpp"
1443	>	#line 1444 "MDLexer.cpp"
1444		}
1445		}
1446		else {
#	Line 1460 | Line 1464 | void MDLexer::mNUM_INT(bool _createToken) {
1464		switch ( LA(1)) {
1465		case 0x30 /* '0' */ :
1466		{
1467	<	match('0');
1467	>	match('0' /* charlit */ );
1468		if ( inputState->guessing==0 ) {
1469	<	#line 425 "MDParser.g"
1469	>	#line 446 "MDParser.g"
1470		isDecimal = true;
1471	<	#line 1468 "MDLexer.cpp"
1471	>	#line 1472 "MDLexer.cpp"
1472		}
1473		{
1474		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1472 | Line 1476 | void MDLexer::mNUM_INT(bool _createToken) {
1476		switch ( LA(1)) {
1477		case 0x78 /* 'x' */ :
1478		{
1479	<	match('x');
1479	>	match('x' /* charlit */ );
1480		break;
1481		}
1482		case 0x58 /* 'X' */ :
1483		{
1484	<	match('X');
1484	>	match('X' /* charlit */ );
1485		break;
1486		}
1487		default:
#	Line 1487 | Line 1491 | void MDLexer::mNUM_INT(bool _createToken) {
1491		}
1492		}
1493		{ // ( ... )+
1494	<	int _cnt144=0;
1494	>	int _cnt156=0;
1495		for (;;) {
1496		if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1497		mHEX_DIGIT(false);
1498		}
1499		else {
1500	<	if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1500	>	if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1501		}
1502
1503	<	_cnt144++;
1503	>	_cnt156++;
1504		}
1505	<	_loop144:;
1505	>	_loop156:;
1506		}  // ( ... )+
1507		}
1508		else {
1509	<	bool synPredMatched149 = false;
1509	>	bool synPredMatched161 = false;
1510		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1511	<	int _m149 = mark();
1512	<	synPredMatched149 = true;
1511	>	int _m161 = mark();
1512	>	synPredMatched161 = true;
1513		inputState->guessing++;
1514		try {
1515		{
1516		{ // ( ... )+
1517	<	int _cnt147=0;
1517	>	int _cnt159=0;
1518		for (;;) {
1519		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1520		matchRange('0','9');
1521		}
1522		else {
1523	<	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1523	>	if ( _cnt159>=1 ) { goto _loop159; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1524		}
1525
1526	<	_cnt147++;
1526	>	_cnt159++;
1527		}
1528	<	_loop147:;
1528	>	_loop159:;
1529		}  // ( ... )+
1530		{
1531		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1532		mEXPONENT(false);
1533		}
1534		else if ((LA(1) == 0x2e /* '.' */ )) {
1535	<	match('.');
1535	>	match('.' /* charlit */ );
1536		}
1537		else if ((_tokenSet_8.member(LA(1))) && (true)) {
1538		mFLOAT_SUFFIX(false);
#	Line 1541 | Line 1545 | void MDLexer::mNUM_INT(bool _createToken) {
1545		}
1546		}
1547		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1548	<	synPredMatched149 = false;
1548	>	synPredMatched161 = false;
1549		}
1550	<	rewind(_m149);
1550	>	rewind(_m161);
1551		inputState->guessing--;
1552		}
1553	<	if ( synPredMatched149 ) {
1553	>	if ( synPredMatched161 ) {
1554		{ // ( ... )+
1555	<	int _cnt151=0;
1555	>	int _cnt163=0;
1556		for (;;) {
1557		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1558		matchRange('0','9');
1559		}
1560		else {
1561	<	if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1561	>	if ( _cnt163>=1 ) { goto _loop163; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1562		}
1563
1564	<	_cnt151++;
1564	>	_cnt163++;
1565		}
1566	<	_loop151:;
1566	>	_loop163:;
1567		}  // ( ... )+
1568		}
1569		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1570		{ // ( ... )+
1571	<	int _cnt153=0;
1571	>	int _cnt165=0;
1572		for (;;) {
1573		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1574		matchRange('0','7');
1575		}
1576		else {
1577	<	if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1577	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1578		}
1579
1580	<	_cnt153++;
1580	>	_cnt165++;
1581		}
1582	<	_loop153:;
1582	>	_loop165:;
1583		}  // ( ... )+
1584		}
1585		else {
#	Line 1603 | Line 1607 | void MDLexer::mNUM_INT(bool _createToken) {
1607		matchRange('0','9');
1608		}
1609		else {
1610	<	goto _loop156;
1610	>	goto _loop168;
1611		}
1612
1613		}
1614	<	_loop156:;
1614	>	_loop168:;
1615		} // ( ... )*
1616		if ( inputState->guessing==0 ) {
1617	<	#line 442 "MDParser.g"
1617	>	#line 463 "MDParser.g"
1618		isDecimal=true;
1619	<	#line 1616 "MDLexer.cpp"
1619	>	#line 1620 "MDLexer.cpp"
1620		}
1621		break;
1622		}
#	Line 1628 | Line 1632 | void MDLexer::mNUM_INT(bool _createToken) {
1632		switch ( LA(1)) {
1633		case 0x6c /* 'l' */ :
1634		{
1635	<	match('l');
1635	>	match('l' /* charlit */ );
1636		break;
1637		}
1638		case 0x4c /* 'L' */ :
1639		{
1640	<	match('L');
1640	>	match('L' /* charlit */ );
1641		break;
1642		}
1643		default:
#	Line 1643 | Line 1647 | void MDLexer::mNUM_INT(bool _createToken) {
1647		}
1648		}
1649		if ( inputState->guessing==0 ) {
1650	<	#line 444 "MDParser.g"
1650	>	#line 465 "MDParser.g"
1651		_ttype = NUM_LONG;
1652	<	#line 1649 "MDLexer.cpp"
1652	>	#line 1653 "MDLexer.cpp"
1653		}
1654		}
1655		else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
#	Line 1657 | Line 1661 | void MDLexer::mNUM_INT(bool _createToken) {
1661		mFLOAT_SUFFIX(true);
1662		f3=_returnToken;
1663		if ( inputState->guessing==0 ) {
1664	<	#line 449 "MDParser.g"
1664	>	#line 470 "MDParser.g"
1665		t=f3;
1666	<	#line 1663 "MDLexer.cpp"
1666	>	#line 1667 "MDLexer.cpp"
1667		}
1668		}
1669		else {
#	Line 1668 | Line 1672 | void MDLexer::mNUM_INT(bool _createToken) {
1672		}
1673		}
1674		else if ((LA(1) == 0x2e /* '.' */ )) {
1675	<	match('.');
1675	>	match('.' /* charlit */ );
1676		{ // ( ... )*
1677		for (;;) {
1678		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1679		matchRange('0','9');
1680		}
1681		else {
1682	<	goto _loop161;
1682	>	goto _loop173;
1683		}
1684
1685		}
1686	<	_loop161:;
1686	>	_loop173:;
1687		} // ( ... )*
1688		{
1689		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1694 | Line 1698 | void MDLexer::mNUM_INT(bool _createToken) {
1698		mFLOAT_SUFFIX(true);
1699		f2=_returnToken;
1700		if ( inputState->guessing==0 ) {
1701	<	#line 448 "MDParser.g"
1701	>	#line 469 "MDParser.g"
1702		t=f2;
1703	<	#line 1700 "MDLexer.cpp"
1703	>	#line 1704 "MDLexer.cpp"
1704		}
1705		}
1706		else {
#	Line 1708 | Line 1712 | void MDLexer::mNUM_INT(bool _createToken) {
1712		mFLOAT_SUFFIX(true);
1713		f4=_returnToken;
1714		if ( inputState->guessing==0 ) {
1715	<	#line 450 "MDParser.g"
1715	>	#line 471 "MDParser.g"
1716		t=f4;
1717	<	#line 1714 "MDLexer.cpp"
1717	>	#line 1718 "MDLexer.cpp"
1718		}
1719		}
1720		else {
#	Line 1719 | Line 1723 | void MDLexer::mNUM_INT(bool _createToken) {
1723
1724		}
1725		if ( inputState->guessing==0 ) {
1726	<	#line 452 "MDParser.g"
1726	>	#line 473 "MDParser.g"
1727
1728		if ( t &&
1729		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1730 | Line 1734 | void MDLexer::mNUM_INT(bool _createToken) {
1734		_ttype = NUM_DOUBLE; // assume double
1735		}
1736
1737	<	#line 1734 "MDLexer.cpp"
1737	>	#line 1738 "MDLexer.cpp"
1738		}
1739		}
1740		else {
#	Line 1754 | Line 1758 | void MDLexer::mEXPONENT(bool _createToken) {
1758		}
1759
1760		void MDLexer::mEXPONENT(bool _createToken) {
1761	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1761	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1762		_ttype = EXPONENT;
1763	<	int _saveIndex;
1763	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1764
1765		{
1766		switch ( LA(1)) {
1767		case 0x65 /* 'e' */ :
1768		{
1769	<	match('e');
1769	>	match('e' /* charlit */ );
1770		break;
1771		}
1772		case 0x45 /* 'E' */ :
1773		{
1774	<	match('E');
1774	>	match('E' /* charlit */ );
1775		break;
1776		}
1777		case 0x64 /* 'd' */ :
1778		{
1779	<	match('d');
1779	>	match('d' /* charlit */ );
1780		break;
1781		}
1782		case 0x44 /* 'D' */ :
1783		{
1784	<	match('D');
1784	>	match('D' /* charlit */ );
1785		break;
1786		}
1787		default:
#	Line 1790 | Line 1794 | void MDLexer::mEXPONENT(bool _createToken) {
1794		switch ( LA(1)) {
1795		case 0x2b /* '+' */ :
1796		{
1797	<	match('+');
1797	>	match('+' /* charlit */ );
1798		break;
1799		}
1800		case 0x2d /* '-' */ :
1801		{
1802	<	match('-');
1802	>	match('-' /* charlit */ );
1803		break;
1804		}
1805		case 0x30 /* '0' */ :
#	Line 1818 | Line 1822 | void MDLexer::mEXPONENT(bool _createToken) {
1822		}
1823		}
1824		{ // ( ... )+
1825	<	int _cnt169=0;
1825	>	int _cnt181=0;
1826		for (;;) {
1827		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1828		matchRange('0','9');
1829		}
1830		else {
1831	<	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1831	>	if ( _cnt181>=1 ) { goto _loop181; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1832		}
1833
1834	<	_cnt169++;
1834	>	_cnt181++;
1835		}
1836	<	_loop169:;
1836	>	_loop181:;
1837		}  // ( ... )+
1838		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1839		_token = makeToken(_ttype);
#	Line 1840 | Line 1844 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1844		}
1845
1846		void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1847	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1847	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1848		_ttype = FLOAT_SUFFIX;
1849	<	int _saveIndex;
1849	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1850
1851		switch ( LA(1)) {
1852		case 0x66 /* 'f' */ :
1853		{
1854	<	match('f');
1854	>	match('f' /* charlit */ );
1855		break;
1856		}
1857		case 0x46 /* 'F' */ :
1858		{
1859	<	match('F');
1859	>	match('F' /* charlit */ );
1860		break;
1861		}
1862		case 0x64 /* 'd' */ :
1863		{
1864	<	match('d');
1864	>	match('d' /* charlit */ );
1865		break;
1866		}
1867		case 0x44 /* 'D' */ :
1868		{
1869	<	match('D');
1869	>	match('D' /* charlit */ );
1870		break;
1871		}
1872		default:
#	Line 1879 | Line 1883 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1883		}
1884
1885
1886	<	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1887	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1888	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1889	<	// \' ( ) + , - . / 0 1 2 3 4
1886	>	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1887	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1888	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1889	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8
1890		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1891	<	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1892	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1893	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1894	<	// \' ( ) * + , - . / 0 1 2 3 4
1891	>	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1892	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1893	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1894	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1895		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1896		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897	<	// " \' 0 1 2 3 4
1897	>	// \" \' 0 1 2 3 4 5 6 7
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1899	<	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1901	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1902	<	// ( ) * + , - . / 0 1 2 3 4
1899	>	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 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 8
1903		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1904		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905	<	// \' 0 1 2 3 4
1905	>	// \' 0 1 2 3 4 5 6 7 8
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1907	<	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1909	<	// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1910	<	// $ % & ( ) * + , - . / 0 1 2 3 4
1907	>	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1909	>	// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1910	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1911		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1912		const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1913		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1914		const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915	<	// + - 0 1 2 3 4
1915	>	// + - 0 1 2 3 4 5 6 7 8
1916		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1917		const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1919		const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	<	// 0 1 2 3 4
1920	>	// 0 1 2 3 4 5 6 7 8
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1922		const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923		// .

Comparing:
trunk/src/mdParser/MDLexer.cpp (property svn:keywords), Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
branches/development/src/mdParser/MDLexer.cpp (property svn:keywords), Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

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

Diff Legend

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