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

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 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

Diff Legend

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