ViewVC Help

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

root/OpenMD/trunk/src/mdParser/MDLexer.cpp

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1558 by gezelter, Wed May 11 16:32:48 2011 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20101020): "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		}
50
51		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 139 | Line 140 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
140		theRetToken=_returnToken;
141		break;
142		}
143	<	case 0x22 /* '"' */ :
143	>	case 0x22 /* '\"' */ :
144		{
145		mStringLiteral(true);
146		theRetToken=_returnToken;
#	Line 266 | Line 267 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
267		}
268
269		void MDLexer::mASSIGNEQUAL(bool _createToken) {
270	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
270	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
271		_ttype = ASSIGNEQUAL;
272	<	int _saveIndex;
272	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
273
274	<	match('=');
274	>	match('=' /* charlit */ );
275		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
276		_token = makeToken(_ttype);
277		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 280 | Line 281 | void MDLexer::mCOLON(bool _createToken) {
281		}
282
283		void MDLexer::mCOLON(bool _createToken) {
284	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
284	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
285		_ttype = COLON;
286	<	int _saveIndex;
286	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
287
288	<	match(':');
288	>	match(':' /* charlit */ );
289		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
290		_token = makeToken(_ttype);
291		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 294 | Line 295 | void MDLexer::mCOMMA(bool _createToken) {
295		}
296
297		void MDLexer::mCOMMA(bool _createToken) {
298	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
298	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
299		_ttype = COMMA;
300	<	int _saveIndex;
300	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
301
302	<	match(',');
302	>	match(',' /* charlit */ );
303		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
304		_token = makeToken(_ttype);
305		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 308 | Line 309 | void MDLexer::mQUESTIONMARK(bool _createToken) {
309		}
310
311		void MDLexer::mQUESTIONMARK(bool _createToken) {
312	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
312	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
313		_ttype = QUESTIONMARK;
314	<	int _saveIndex;
314	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
315
316	<	match('?');
316	>	match('?' /* charlit */ );
317		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
318		_token = makeToken(_ttype);
319		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 322 | Line 323 | void MDLexer::mSEMICOLON(bool _createToken) {
323		}
324
325		void MDLexer::mSEMICOLON(bool _createToken) {
326	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
326	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
327		_ttype = SEMICOLON;
328	<	int _saveIndex;
328	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
329
330	<	match(';');
330	>	match(';' /* charlit */ );
331		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
332		_token = makeToken(_ttype);
333		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 336 | Line 337 | void MDLexer::mLPAREN(bool _createToken) {
337		}
338
339		void MDLexer::mLPAREN(bool _createToken) {
340	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
340	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
341		_ttype = LPAREN;
342	<	int _saveIndex;
342	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
343
344	<	match('(');
344	>	match('(' /* charlit */ );
345		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
346		_token = makeToken(_ttype);
347		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 350 | Line 351 | void MDLexer::mRPAREN(bool _createToken) {
351		}
352
353		void MDLexer::mRPAREN(bool _createToken) {
354	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
354	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
355		_ttype = RPAREN;
356	<	int _saveIndex;
356	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
357
358	<	match(')');
358	>	match(')' /* charlit */ );
359		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
360		_token = makeToken(_ttype);
361		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 364 | Line 365 | void MDLexer::mLBRACKET(bool _createToken) {
365		}
366
367		void MDLexer::mLBRACKET(bool _createToken) {
368	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
368	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
369		_ttype = LBRACKET;
370	<	int _saveIndex;
370	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
371
372	<	match('[');
372	>	match('[' /* charlit */ );
373		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
374		_token = makeToken(_ttype);
375		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 378 | Line 379 | void MDLexer::mRBRACKET(bool _createToken) {
379		}
380
381		void MDLexer::mRBRACKET(bool _createToken) {
382	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
382	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
383		_ttype = RBRACKET;
384	<	int _saveIndex;
384	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
385
386	<	match(']');
386	>	match(']' /* charlit */ );
387		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
388		_token = makeToken(_ttype);
389		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 392 | Line 393 | void MDLexer::mLCURLY(bool _createToken) {
393		}
394
395		void MDLexer::mLCURLY(bool _createToken) {
396	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
396	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
397		_ttype = LCURLY;
398	<	int _saveIndex;
398	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
399
400	<	match('{');
400	>	match('{' /* charlit */ );
401		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
402		_token = makeToken(_ttype);
403		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 406 | Line 407 | void MDLexer::mRCURLY(bool _createToken) {
407		}
408
409		void MDLexer::mRCURLY(bool _createToken) {
410	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
410	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
411		_ttype = RCURLY;
412	<	int _saveIndex;
412	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
413
414	<	match('}');
414	>	match('}' /* charlit */ );
415		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
416		_token = makeToken(_ttype);
417		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 420 | Line 421 | void MDLexer::mWhitespace(bool _createToken) {
421		}
422
423		void MDLexer::mWhitespace(bool _createToken) {
424	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
424	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
425		_ttype = Whitespace;
426	<	int _saveIndex;
426	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
427
428		{
429		switch ( LA(1)) {
#	Line 434 | Line 435 | void MDLexer::mWhitespace(bool _createToken) {
435		switch ( LA(1)) {
436		case 0x20 /* ' ' */ :
437		{
438	<	match(' ');
438	>	match(' ' /* charlit */ );
439		break;
440		}
441		case 0x9 /* '\t' */ :
442		{
443	<	match('\t');
443	>	match('\t' /* charlit */ );
444		break;
445		}
446		case 0xc /* '\14' */ :
447		{
448	<	match('\14');
448	>	match('\14' /* charlit */ );
449		break;
450		}
451		default:
#	Line 460 | Line 461 | void MDLexer::mWhitespace(bool _createToken) {
461		{
462		{
463		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
464	<	match('\r');
465	<	match('\n');
464	>	match('\r' /* charlit */ );
465	>	match('\n' /* charlit */ );
466		}
467		else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
468	<	match('\r');
468	>	match('\r' /* charlit */ );
469		}
470		else if ((LA(1) == 0xa /* '\n' */ )) {
471	<	match('\n');
471	>	match('\n' /* charlit */ );
472		}
473		else {
474		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 475 | Line 476 | void MDLexer::mWhitespace(bool _createToken) {
476
477		}
478		if ( inputState->guessing==0 ) {
479	<	#line 227 "MDParser.g"
479	>	#line 233 "MDParser.g"
480		newline();
481	<	#line 481 "MDLexer.cpp"
481	>	#line 482 "MDLexer.cpp"
482		}
483		break;
484		}
#	Line 485 | Line 486 | void MDLexer::mWhitespace(bool _createToken) {
486		{
487		{
488		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
489	<	match('\\');
490	<	match('\r');
491	<	match('\n');
489	>	match('\\' /* charlit */ );
490	>	match('\r' /* charlit */ );
491	>	match('\n' /* charlit */ );
492		}
493		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
494	<	match('\\');
495	<	match('\r');
494	>	match('\\' /* charlit */ );
495	>	match('\r' /* charlit */ );
496		}
497		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
498	<	match('\\');
499	<	match('\n');
498	>	match('\\' /* charlit */ );
499	>	match('\n' /* charlit */ );
500		}
501		else {
502		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 503 | Line 504 | void MDLexer::mWhitespace(bool _createToken) {
504
505		}
506		if ( inputState->guessing==0 ) {
507	<	#line 232 "MDParser.g"
507	>	#line 238 "MDParser.g"
508		printf("CPP_parser.g continuation line detected\n");
509		deferredNewline();
510	<	#line 510 "MDLexer.cpp"
510	>	#line 511 "MDLexer.cpp"
511		}
512		break;
513		}
#	Line 517 | Line 518 | void MDLexer::mWhitespace(bool _createToken) {
518		}
519		}
520		if ( inputState->guessing==0 ) {
521	<	#line 235 "MDParser.g"
521	>	#line 241 "MDParser.g"
522		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
523	<	#line 523 "MDLexer.cpp"
523	>	#line 524 "MDLexer.cpp"
524		}
525		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
526		_token = makeToken(_ttype);
#	Line 530 | Line 531 | void MDLexer::mComment(bool _createToken) {
531		}
532
533		void MDLexer::mComment(bool _createToken) {
534	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
534	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
535		_ttype = Comment;
536	<	int _saveIndex;
536	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
537
538		match("/*");
539		{ // ( ... )*
540		for (;;) {
541	<	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
542	<	match('*');
541	>	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
542	>	match('*' /* charlit */ );
543		}
544		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
545		mEndOfLine(false);
546		if ( inputState->guessing==0 ) {
547	<	#line 242 "MDParser.g"
547	>	#line 248 "MDParser.g"
548		deferredNewline();
549	<	#line 549 "MDLexer.cpp"
549	>	#line 550 "MDLexer.cpp"
550		}
551		}
552		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 554 | Line 555 | void MDLexer::mComment(bool _createToken) {
555		}
556		}
557		else {
558	<	goto _loop83;
558	>	goto _loop86;
559		}
560
561		}
562	<	_loop83:;
562	>	_loop86:;
563		} // ( ... )*
564		match("*/");
565		if ( inputState->guessing==0 ) {
566	<	#line 245 "MDParser.g"
566	>	#line 251 "MDParser.g"
567		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
568	<	#line 568 "MDLexer.cpp"
568	>	#line 569 "MDLexer.cpp"
569		}
570		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
571		_token = makeToken(_ttype);
#	Line 575 | Line 576 | void MDLexer::mEndOfLine(bool _createToken) {
576		}
577
578		void MDLexer::mEndOfLine(bool _createToken) {
579	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
579	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
580		_ttype = EndOfLine;
581	<	int _saveIndex;
581	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
582
583		{
584		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
585		match("\r\n");
586		}
587		else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
588	<	match('\r');
588	>	match('\r' /* charlit */ );
589		}
590		else if ((LA(1) == 0xa /* '\n' */ )) {
591	<	match('\n');
591	>	match('\n' /* charlit */ );
592		}
593		else {
594		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 603 | Line 604 | void MDLexer::mCPPComment(bool _createToken) {
604		}
605
606		void MDLexer::mCPPComment(bool _createToken) {
607	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
607	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
608		_ttype = CPPComment;
609	<	int _saveIndex;
609	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
610
611		match("//");
612		{ // ( ... )*
#	Line 616 | Line 617 | void MDLexer::mCPPComment(bool _createToken) {
617		}
618		}
619		else {
620	<	goto _loop87;
620	>	goto _loop90;
621		}
622
623		}
624	<	_loop87:;
624	>	_loop90:;
625		} // ( ... )*
626		mEndOfLine(false);
627		if ( inputState->guessing==0 ) {
628	<	#line 251 "MDParser.g"
628	>	#line 257 "MDParser.g"
629		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
630	<	#line 630 "MDLexer.cpp"
630	>	#line 631 "MDLexer.cpp"
631		}
632		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
633		_token = makeToken(_ttype);
#	Line 637 | Line 638 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
638		}
639
640		void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
641	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
641	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
642		_ttype = PREPROC_DIRECTIVE;
643	<	int _saveIndex;
643	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
644
645	<	match('#');
645	>	match('#' /* charlit */ );
646		mLineDirective(false);
647		if ( inputState->guessing==0 ) {
648	<	#line 258 "MDParser.g"
648	>	#line 264 "MDParser.g"
649		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
650	<	#line 650 "MDLexer.cpp"
650	>	#line 651 "MDLexer.cpp"
651		}
652		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
653		_token = makeToken(_ttype);
#	Line 657 | Line 658 | void MDLexer::mLineDirective(bool _createToken) {
658		}
659
660		void MDLexer::mLineDirective(bool _createToken) {
661	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
661	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
662		_ttype = LineDirective;
663	<	int _saveIndex;
663	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
664		ANTLR_USE_NAMESPACE(antlr)RefToken n;
665		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
666
667		if ( inputState->guessing==0 ) {
668	<	#line 264 "MDParser.g"
668	>	#line 270 "MDParser.g"
669
670		deferredLineCount = 0;
671
672	<	#line 672 "MDLexer.cpp"
672	>	#line 673 "MDLexer.cpp"
673		}
674		{
675		switch ( LA(1)) {
#	Line 690 | Line 691 | void MDLexer::mLineDirective(bool _createToken) {
691		}
692		}
693		{ // ( ... )+
694	<	int _cnt92=0;
694	>	int _cnt95=0;
695		for (;;) {
696		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
697		mSpace(false);
698		}
699		else {
700	<	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
700	>	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
701		}
702
703	<	_cnt92++;
703	>	_cnt95++;
704		}
705	<	_loop92:;
705	>	_loop95:;
706		}  // ( ... )+
707		mDecimal(true);
708		n=_returnToken;
709		if ( inputState->guessing==0 ) {
710	<	#line 269 "MDParser.g"
711	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
712	<	#line 712 "MDLexer.cpp"
710	>	#line 275 "MDParser.g"
711	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
712	>	#line 713 "MDLexer.cpp"
713		}
714		{ // ( ... )+
715	<	int _cnt94=0;
715	>	int _cnt97=0;
716		for (;;) {
717		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
718		mSpace(false);
719		}
720		else {
721	<	if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
721	>	if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
722		}
723
724	<	_cnt94++;
724	>	_cnt97++;
725		}
726	<	_loop94:;
726	>	_loop97:;
727		}  // ( ... )+
728		{
729		mStringLiteral(true);
730		sl=_returnToken;
731		}
732		if ( inputState->guessing==0 ) {
733	<	#line 271 "MDParser.g"
733	>	#line 277 "MDParser.g"
734		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
735	<	#line 735 "MDLexer.cpp"
735	>	#line 736 "MDLexer.cpp"
736		}
737		{ // ( ... )*
738		for (;;) {
739		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
740		{ // ( ... )+
741	<	int _cnt98=0;
741	>	int _cnt101=0;
742		for (;;) {
743		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
744		mSpace(false);
745		}
746		else {
747	<	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
747	>	if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
748		}
749
750	<	_cnt98++;
750	>	_cnt101++;
751		}
752	<	_loop98:;
752	>	_loop101:;
753		}  // ( ... )+
754		mDecimal(false);
755		}
756		else {
757	<	goto _loop99;
757	>	goto _loop102;
758		}
759
760		}
761	<	_loop99:;
761	>	_loop102:;
762		} // ( ... )*
763		mEndOfLine(false);
764		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 769 | Line 770 | void MDLexer::mSpace(bool _createToken) {
770		}
771
772		void MDLexer::mSpace(bool _createToken) {
773	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
773	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
774		_ttype = Space;
775	<	int _saveIndex;
775	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
776
777		{
778		switch ( LA(1)) {
779		case 0x20 /* ' ' */ :
780		{
781	<	match(' ');
781	>	match(' ' /* charlit */ );
782		break;
783		}
784		case 0x9 /* '\t' */ :
785		{
786	<	match('\t');
786	>	match('\t' /* charlit */ );
787		break;
788		}
789		case 0xc /* '\14' */ :
790		{
791	<	match('\14');
791	>	match('\14' /* charlit */ );
792		break;
793		}
794		default:
#	Line 805 | Line 806 | void MDLexer::mDecimal(bool _createToken) {
806		}
807
808		void MDLexer::mDecimal(bool _createToken) {
809	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
809	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
810		_ttype = Decimal;
811	<	int _saveIndex;
811	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
812
813		{ // ( ... )+
814	<	int _cnt129=0;
814	>	int _cnt132=0;
815		for (;;) {
816		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
817		matchRange('0','9');
818		}
819		else {
820	<	if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
820	>	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
821		}
822
823	<	_cnt129++;
823	>	_cnt132++;
824		}
825	<	_loop129:;
825	>	_loop132:;
826		}  // ( ... )+
827		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
828		_token = makeToken(_ttype);
#	Line 832 | Line 833 | void MDLexer::mStringLiteral(bool _createToken) {
833		}
834
835		void MDLexer::mStringLiteral(bool _createToken) {
836	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
836	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
837		_ttype = StringLiteral;
838	<	int _saveIndex;
838	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
839
840	<	match('"');
840	>	match('\"' /* charlit */ );
841		{ // ( ... )*
842		for (;;) {
843		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
#	Line 845 | Line 846 | void MDLexer::mStringLiteral(bool _createToken) {
846		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
847		{
848		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
849	<	match("\\r\n");
849	>	match("\\\r\n");
850		}
851		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
852	<	match("\\r");
852	>	match("\\\r");
853		}
854		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
855	<	match("\\n");
855	>	match("\\\n");
856		}
857		else {
858		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 859 | Line 860 | void MDLexer::mStringLiteral(bool _createToken) {
860
861		}
862		if ( inputState->guessing==0 ) {
863	<	#line 311 "MDParser.g"
863	>	#line 317 "MDParser.g"
864		deferredNewline();
865	<	#line 865 "MDLexer.cpp"
865	>	#line 866 "MDLexer.cpp"
866		}
867		}
868		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 870 | Line 871 | void MDLexer::mStringLiteral(bool _createToken) {
871		}
872		}
873		else {
874	<	goto _loop109;
874	>	goto _loop112;
875		}
876
877		}
878	<	_loop109:;
878	>	_loop112:;
879		} // ( ... )*
880	<	match('"');
880	>	match('\"' /* charlit */ );
881		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
882		_token = makeToken(_ttype);
883		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 886 | Line 887 | void MDLexer::mCharLiteral(bool _createToken) {
887		}
888
889		void MDLexer::mCharLiteral(bool _createToken) {
890	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
890	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
891		_ttype = CharLiteral;
892	<	int _saveIndex;
892	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
893
894	<	match('\'');
894	>	match('\'' /* charlit */ );
895		{
896		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
897		mEscape(false);
#	Line 905 | Line 906 | void MDLexer::mCharLiteral(bool _createToken) {
906		}
907
908		}
909	<	match('\'');
909	>	match('\'' /* charlit */ );
910		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
911		_token = makeToken(_ttype);
912		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 915 | Line 916 | void MDLexer::mEscape(bool _createToken) {
916		}
917
918		void MDLexer::mEscape(bool _createToken) {
919	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
919	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
920		_ttype = Escape;
921	<	int _saveIndex;
921	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
922
923	<	match('\\');
923	>	match('\\' /* charlit */ );
924		{
925		switch ( LA(1)) {
926		case 0x61 /* 'a' */ :
927		{
928	<	match('a');
928	>	match('a' /* charlit */ );
929		break;
930		}
931		case 0x62 /* 'b' */ :
932		{
933	<	match('b');
933	>	match('b' /* charlit */ );
934		break;
935		}
936		case 0x66 /* 'f' */ :
937		{
938	<	match('f');
938	>	match('f' /* charlit */ );
939		break;
940		}
941		case 0x6e /* 'n' */ :
942		{
943	<	match('n');
943	>	match('n' /* charlit */ );
944		break;
945		}
946		case 0x72 /* 'r' */ :
947		{
948	<	match('r');
948	>	match('r' /* charlit */ );
949		break;
950		}
951		case 0x74 /* 't' */ :
952		{
953	<	match('t');
953	>	match('t' /* charlit */ );
954		break;
955		}
956		case 0x76 /* 'v' */ :
957		{
958	<	match('v');
958	>	match('v' /* charlit */ );
959		break;
960		}
961	<	case 0x22 /* '"' */ :
961	>	case 0x22 /* '\"' */ :
962		{
963	<	match('"');
963	>	match('\"' /* charlit */ );
964		break;
965		}
966		case 0x27 /* '\'' */ :
967		{
968	<	match('\'');
968	>	match('\'' /* charlit */ );
969		break;
970		}
971		case 0x5c /* '\\' */ :
972		{
973	<	match('\\');
973	>	match('\\' /* charlit */ );
974		break;
975		}
976		case 0x3f /* '?' */ :
977		{
978	<	match('?');
978	>	match('?' /* charlit */ );
979		break;
980		}
981		case 0x30 /* '0' */ :
#	Line 1032 | Line 1033 | void MDLexer::mEscape(bool _createToken) {
1033		}
1034		case 0x78 /* 'x' */ :
1035		{
1036	<	match('x');
1036	>	match('x' /* charlit */ );
1037		{ // ( ... )+
1038	<	int _cnt120=0;
1038	>	int _cnt123=0;
1039		for (;;) {
1040		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1041		mDigit(false);
#	Line 1046 | Line 1047 | void MDLexer::mEscape(bool _createToken) {
1047		matchRange('A','F');
1048		}
1049		else {
1050	<	if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1050	>	if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1051		}
1052
1053	<	_cnt120++;
1053	>	_cnt123++;
1054		}
1055	<	_loop120:;
1055	>	_loop123:;
1056		}  // ( ... )+
1057		break;
1058		}
#	Line 1070 | Line 1071 | void MDLexer::mDigit(bool _createToken) {
1071		}
1072
1073		void MDLexer::mDigit(bool _createToken) {
1074	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1074	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1075		_ttype = Digit;
1076	<	int _saveIndex;
1076	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1077
1078		matchRange('0','9');
1079		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1084 | Line 1085 | void MDLexer::mVocabulary(bool _createToken) {
1085		}
1086
1087		void MDLexer::mVocabulary(bool _createToken) {
1088	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1088	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1089		_ttype = Vocabulary;
1090	<	int _saveIndex;
1090	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1091
1092	<	matchRange('\3',static_cast<unsigned char>(255));
1092	>	matchRange('\3',static_cast<unsigned char>('\377'));
1093		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1094		_token = makeToken(_ttype);
1095		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1098 | Line 1099 | void MDLexer::mID(bool _createToken) {
1099		}
1100
1101		void MDLexer::mID(bool _createToken) {
1102	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1102	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1103		_ttype = ID;
1104	<	int _saveIndex;
1104	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1105
1106		{
1107		switch ( LA(1)) {
#	Line 1166 | Line 1167 | void MDLexer::mID(bool _createToken) {
1167		}
1168		case 0x5f /* '_' */ :
1169		{
1170	<	match('_');
1170	>	match('_' /* charlit */ );
1171		break;
1172		}
1173		default:
#	Line 1240 | Line 1241 | void MDLexer::mID(bool _createToken) {
1241		}
1242		case 0x5f /* '_' */ :
1243		{
1244	<	match('_');
1244	>	match('_' /* charlit */ );
1245		break;
1246		}
1247		case 0x30 /* '0' */ :
#	Line 1259 | Line 1260 | void MDLexer::mID(bool _createToken) {
1260		}
1261		default:
1262		{
1263	<	goto _loop125;
1263	>	goto _loop128;
1264		}
1265		}
1266		}
1267	<	_loop125:;
1267	>	_loop128:;
1268		} // ( ... )*
1269		_ttype = testLiteralsTable(_ttype);
1270		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1275 | Line 1276 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1276		}
1277
1278		void MDLexer::mHEX_DIGIT(bool _createToken) {
1279	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1279	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1280		_ttype = HEX_DIGIT;
1281	<	int _saveIndex;
1281	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1282
1283		{
1284		switch ( LA(1)) {
#	Line 1330 | Line 1331 | void MDLexer::mNUM_INT(bool _createToken) {
1331		}
1332
1333		void MDLexer::mNUM_INT(bool _createToken) {
1334	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1334	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1335		_ttype = NUM_INT;
1336	<	int _saveIndex;
1336	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1337		ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1338		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1339		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1340		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1341	<	#line 404 "MDParser.g"
1341	>	#line 410 "MDParser.g"
1342
1343		bool isDecimal = false;
1344		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1345
1346	<	#line 1346 "MDLexer.cpp"
1346	>	#line 1347 "MDLexer.cpp"
1347
1348		{
1349		switch ( LA(1)) {
1350		case 0x2b /* '+' */ :
1351		{
1352	<	match('+');
1352	>	match('+' /* charlit */ );
1353		break;
1354		}
1355		case 0x2d /* '-' */ :
1356		{
1357	<	match('-');
1357	>	match('-' /* charlit */ );
1358		break;
1359		}
1360		case 0x2e /* '.' */ :
#	Line 1380 | Line 1381 | void MDLexer::mNUM_INT(bool _createToken) {
1381		switch ( LA(1)) {
1382		case 0x2e /* '.' */ :
1383		{
1384	<	match('.');
1384	>	match('.' /* charlit */ );
1385		if ( inputState->guessing==0 ) {
1386	<	#line 411 "MDParser.g"
1386	>	#line 417 "MDParser.g"
1387		_ttype = DOT;
1388	<	#line 1388 "MDLexer.cpp"
1388	>	#line 1389 "MDLexer.cpp"
1389		}
1390		{
1391		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1392		{ // ( ... )+
1393	<	int _cnt137=0;
1393	>	int _cnt140=0;
1394		for (;;) {
1395		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396		matchRange('0','9');
1397		}
1398		else {
1399	<	if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1399	>	if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1400		}
1401
1402	<	_cnt137++;
1402	>	_cnt140++;
1403		}
1404	<	_loop137:;
1404	>	_loop140:;
1405		}  // ( ... )+
1406		{
1407		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1415 | Line 1416 | void MDLexer::mNUM_INT(bool _createToken) {
1416		mFLOAT_SUFFIX(true);
1417		f1=_returnToken;
1418		if ( inputState->guessing==0 ) {
1419	<	#line 412 "MDParser.g"
1419	>	#line 418 "MDParser.g"
1420		t=f1;
1421	<	#line 1421 "MDLexer.cpp"
1421	>	#line 1422 "MDLexer.cpp"
1422		}
1423		}
1424		else {
#	Line 1425 | Line 1426 | void MDLexer::mNUM_INT(bool _createToken) {
1426
1427		}
1428		if ( inputState->guessing==0 ) {
1429	<	#line 413 "MDParser.g"
1429	>	#line 419 "MDParser.g"
1430
1431		if ( t &&
1432		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1436 | Line 1437 | void MDLexer::mNUM_INT(bool _createToken) {
1437		_ttype = NUM_DOUBLE; // assume double
1438		}
1439
1440	<	#line 1440 "MDLexer.cpp"
1440	>	#line 1441 "MDLexer.cpp"
1441		}
1442		}
1443		else {
#	Line 1460 | Line 1461 | void MDLexer::mNUM_INT(bool _createToken) {
1461		switch ( LA(1)) {
1462		case 0x30 /* '0' */ :
1463		{
1464	<	match('0');
1464	>	match('0' /* charlit */ );
1465		if ( inputState->guessing==0 ) {
1466	<	#line 425 "MDParser.g"
1466	>	#line 431 "MDParser.g"
1467		isDecimal = true;
1468	<	#line 1468 "MDLexer.cpp"
1468	>	#line 1469 "MDLexer.cpp"
1469		}
1470		{
1471		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1472 | Line 1473 | void MDLexer::mNUM_INT(bool _createToken) {
1473		switch ( LA(1)) {
1474		case 0x78 /* 'x' */ :
1475		{
1476	<	match('x');
1476	>	match('x' /* charlit */ );
1477		break;
1478		}
1479		case 0x58 /* 'X' */ :
1480		{
1481	<	match('X');
1481	>	match('X' /* charlit */ );
1482		break;
1483		}
1484		default:
#	Line 1487 | Line 1488 | void MDLexer::mNUM_INT(bool _createToken) {
1488		}
1489		}
1490		{ // ( ... )+
1491	<	int _cnt144=0;
1491	>	int _cnt147=0;
1492		for (;;) {
1493		if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1494		mHEX_DIGIT(false);
1495		}
1496		else {
1497	<	if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1497	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1498		}
1499
1500	<	_cnt144++;
1500	>	_cnt147++;
1501		}
1502	<	_loop144:;
1502	>	_loop147:;
1503		}  // ( ... )+
1504		}
1505		else {
1506	<	bool synPredMatched149 = false;
1506	>	bool synPredMatched152 = false;
1507		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1508	<	int _m149 = mark();
1509	<	synPredMatched149 = true;
1508	>	int _m152 = mark();
1509	>	synPredMatched152 = true;
1510		inputState->guessing++;
1511		try {
1512		{
1513		{ // ( ... )+
1514	<	int _cnt147=0;
1514	>	int _cnt150=0;
1515		for (;;) {
1516		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1517		matchRange('0','9');
1518		}
1519		else {
1520	<	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1520	>	if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521		}
1522
1523	<	_cnt147++;
1523	>	_cnt150++;
1524		}
1525	<	_loop147:;
1525	>	_loop150:;
1526		}  // ( ... )+
1527		{
1528		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1529		mEXPONENT(false);
1530		}
1531		else if ((LA(1) == 0x2e /* '.' */ )) {
1532	<	match('.');
1532	>	match('.' /* charlit */ );
1533		}
1534		else if ((_tokenSet_8.member(LA(1))) && (true)) {
1535		mFLOAT_SUFFIX(false);
#	Line 1541 | Line 1542 | void MDLexer::mNUM_INT(bool _createToken) {
1542		}
1543		}
1544		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1545	<	synPredMatched149 = false;
1545	>	synPredMatched152 = false;
1546		}
1547	<	rewind(_m149);
1547	>	rewind(_m152);
1548		inputState->guessing--;
1549		}
1550	<	if ( synPredMatched149 ) {
1550	>	if ( synPredMatched152 ) {
1551		{ // ( ... )+
1552	<	int _cnt151=0;
1552	>	int _cnt154=0;
1553		for (;;) {
1554		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1555		matchRange('0','9');
1556		}
1557		else {
1558	<	if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1558	>	if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1559		}
1560
1561	<	_cnt151++;
1561	>	_cnt154++;
1562		}
1563	<	_loop151:;
1563	>	_loop154:;
1564		}  // ( ... )+
1565		}
1566		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1567		{ // ( ... )+
1568	<	int _cnt153=0;
1568	>	int _cnt156=0;
1569		for (;;) {
1570		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1571		matchRange('0','7');
1572		}
1573		else {
1574	<	if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1574	>	if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575		}
1576
1577	<	_cnt153++;
1577	>	_cnt156++;
1578		}
1579	<	_loop153:;
1579	>	_loop156:;
1580		}  // ( ... )+
1581		}
1582		else {
#	Line 1603 | Line 1604 | void MDLexer::mNUM_INT(bool _createToken) {
1604		matchRange('0','9');
1605		}
1606		else {
1607	<	goto _loop156;
1607	>	goto _loop159;
1608		}
1609
1610		}
1611	<	_loop156:;
1611	>	_loop159:;
1612		} // ( ... )*
1613		if ( inputState->guessing==0 ) {
1614	<	#line 442 "MDParser.g"
1614	>	#line 448 "MDParser.g"
1615		isDecimal=true;
1616	<	#line 1616 "MDLexer.cpp"
1616	>	#line 1617 "MDLexer.cpp"
1617		}
1618		break;
1619		}
#	Line 1628 | Line 1629 | void MDLexer::mNUM_INT(bool _createToken) {
1629		switch ( LA(1)) {
1630		case 0x6c /* 'l' */ :
1631		{
1632	<	match('l');
1632	>	match('l' /* charlit */ );
1633		break;
1634		}
1635		case 0x4c /* 'L' */ :
1636		{
1637	<	match('L');
1637	>	match('L' /* charlit */ );
1638		break;
1639		}
1640		default:
#	Line 1643 | Line 1644 | void MDLexer::mNUM_INT(bool _createToken) {
1644		}
1645		}
1646		if ( inputState->guessing==0 ) {
1647	<	#line 444 "MDParser.g"
1647	>	#line 450 "MDParser.g"
1648		_ttype = NUM_LONG;
1649	<	#line 1649 "MDLexer.cpp"
1649	>	#line 1650 "MDLexer.cpp"
1650		}
1651		}
1652		else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
#	Line 1657 | Line 1658 | void MDLexer::mNUM_INT(bool _createToken) {
1658		mFLOAT_SUFFIX(true);
1659		f3=_returnToken;
1660		if ( inputState->guessing==0 ) {
1661	<	#line 449 "MDParser.g"
1661	>	#line 455 "MDParser.g"
1662		t=f3;
1663	<	#line 1663 "MDLexer.cpp"
1663	>	#line 1664 "MDLexer.cpp"
1664		}
1665		}
1666		else {
#	Line 1668 | Line 1669 | void MDLexer::mNUM_INT(bool _createToken) {
1669		}
1670		}
1671		else if ((LA(1) == 0x2e /* '.' */ )) {
1672	<	match('.');
1672	>	match('.' /* charlit */ );
1673		{ // ( ... )*
1674		for (;;) {
1675		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1676		matchRange('0','9');
1677		}
1678		else {
1679	<	goto _loop161;
1679	>	goto _loop164;
1680		}
1681
1682		}
1683	<	_loop161:;
1683	>	_loop164:;
1684		} // ( ... )*
1685		{
1686		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1694 | Line 1695 | void MDLexer::mNUM_INT(bool _createToken) {
1695		mFLOAT_SUFFIX(true);
1696		f2=_returnToken;
1697		if ( inputState->guessing==0 ) {
1698	<	#line 448 "MDParser.g"
1698	>	#line 454 "MDParser.g"
1699		t=f2;
1700	<	#line 1700 "MDLexer.cpp"
1700	>	#line 1701 "MDLexer.cpp"
1701		}
1702		}
1703		else {
#	Line 1708 | Line 1709 | void MDLexer::mNUM_INT(bool _createToken) {
1709		mFLOAT_SUFFIX(true);
1710		f4=_returnToken;
1711		if ( inputState->guessing==0 ) {
1712	<	#line 450 "MDParser.g"
1712	>	#line 456 "MDParser.g"
1713		t=f4;
1714	<	#line 1714 "MDLexer.cpp"
1714	>	#line 1715 "MDLexer.cpp"
1715		}
1716		}
1717		else {
#	Line 1719 | Line 1720 | void MDLexer::mNUM_INT(bool _createToken) {
1720
1721		}
1722		if ( inputState->guessing==0 ) {
1723	<	#line 452 "MDParser.g"
1723	>	#line 458 "MDParser.g"
1724
1725		if ( t &&
1726		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1730 | Line 1731 | void MDLexer::mNUM_INT(bool _createToken) {
1731		_ttype = NUM_DOUBLE; // assume double
1732		}
1733
1734	<	#line 1734 "MDLexer.cpp"
1734	>	#line 1735 "MDLexer.cpp"
1735		}
1736		}
1737		else {
#	Line 1754 | Line 1755 | void MDLexer::mEXPONENT(bool _createToken) {
1755		}
1756
1757		void MDLexer::mEXPONENT(bool _createToken) {
1758	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1758	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1759		_ttype = EXPONENT;
1760	<	int _saveIndex;
1760	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1761
1762		{
1763		switch ( LA(1)) {
1764		case 0x65 /* 'e' */ :
1765		{
1766	<	match('e');
1766	>	match('e' /* charlit */ );
1767		break;
1768		}
1769		case 0x45 /* 'E' */ :
1770		{
1771	<	match('E');
1771	>	match('E' /* charlit */ );
1772		break;
1773		}
1774		case 0x64 /* 'd' */ :
1775		{
1776	<	match('d');
1776	>	match('d' /* charlit */ );
1777		break;
1778		}
1779		case 0x44 /* 'D' */ :
1780		{
1781	<	match('D');
1781	>	match('D' /* charlit */ );
1782		break;
1783		}
1784		default:
#	Line 1790 | Line 1791 | void MDLexer::mEXPONENT(bool _createToken) {
1791		switch ( LA(1)) {
1792		case 0x2b /* '+' */ :
1793		{
1794	<	match('+');
1794	>	match('+' /* charlit */ );
1795		break;
1796		}
1797		case 0x2d /* '-' */ :
1798		{
1799	<	match('-');
1799	>	match('-' /* charlit */ );
1800		break;
1801		}
1802		case 0x30 /* '0' */ :
#	Line 1818 | Line 1819 | void MDLexer::mEXPONENT(bool _createToken) {
1819		}
1820		}
1821		{ // ( ... )+
1822	<	int _cnt169=0;
1822	>	int _cnt172=0;
1823		for (;;) {
1824		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1825		matchRange('0','9');
1826		}
1827		else {
1828	<	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1828	>	if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1829		}
1830
1831	<	_cnt169++;
1831	>	_cnt172++;
1832		}
1833	<	_loop169:;
1833	>	_loop172:;
1834		}  // ( ... )+
1835		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1836		_token = makeToken(_ttype);
#	Line 1840 | Line 1841 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1841		}
1842
1843		void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1844	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1844	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1845		_ttype = FLOAT_SUFFIX;
1846	<	int _saveIndex;
1846	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1847
1848		switch ( LA(1)) {
1849		case 0x66 /* 'f' */ :
1850		{
1851	<	match('f');
1851	>	match('f' /* charlit */ );
1852		break;
1853		}
1854		case 0x46 /* 'F' */ :
1855		{
1856	<	match('F');
1856	>	match('F' /* charlit */ );
1857		break;
1858		}
1859		case 0x64 /* 'd' */ :
1860		{
1861	<	match('d');
1861	>	match('d' /* charlit */ );
1862		break;
1863		}
1864		case 0x44 /* 'D' */ :
1865		{
1866	<	match('D');
1866	>	match('D' /* charlit */ );
1867		break;
1868		}
1869		default:
#	Line 1879 | Line 1880 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1880		}
1881
1882
1883	<	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1885	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1886	<	// \' ( ) + , - . / 0 1 2 3 4
1883	>	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1885	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1886	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1887		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1888	<	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1889	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1890	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1891	<	// \' ( ) * + , - . / 0 1 2 3 4
1888	>	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1889	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1890	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1891	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1892		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1893		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1894	<	// " \' 0 1 2 3 4
1894	>	// \" \' 0 1 2 3 4 5
1895		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1896	<	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1898	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1899	<	// ( ) * + , - . / 0 1 2 3 4
1896	>	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1898	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1899	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1900		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1901		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1902	<	// \' 0 1 2 3 4
1902	>	// \' 0 1 2 3 4 5
1903		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1904	<	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1906	<	// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1907	<	// $ % & ( ) * + , - . / 0 1 2 3 4
1904	>	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1906	>	// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1907	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1908		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1909		const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1910		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1911		const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912	<	// + - 0 1 2 3 4
1912	>	// + - 0 1 2 3 4 5
1913		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1914		const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1916		const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917	<	// 0 1 2 3 4
1917	>	// 0 1 2 3 4 5
1918		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1919		const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920		// .

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1558 by gezelter, Wed May 11 16:32:48 2011 UTC

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

Diff Legend

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