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 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20131114): "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["flucQ"] = 23;
34	>	literals["satellites"] = 20;
35	>	literals["cutoffGroup"] = 14;
36	>	literals["RNEMD"] = 24;
37	>	literals["constraint"] = 15;
38	>	literals["distance"] = 16;
39	>	literals["rigidBody"] = 13;
40	>	literals["fragment"] = 17;
41	>	literals["zconstraint"] = 6;
42	>	literals["minimizer"] = 25;
43		literals["component"] = 4;
44	<	literals["position"] = 17;
45	<	literals["atom"] = 7;
46	<	literals["members"] = 15;
44	>	literals["center"] = 19;
45	>	literals["members"] = 18;
46	>	literals["position"] = 21;
47	>	literals["orientation"] = 22;
48	>	literals["bend"] = 10;
49	>	literals["torsion"] = 11;
50	>	literals["atom"] = 8;
51	>	literals["molecule"] = 5;
52	>	literals["restraint"] = 7;
53	>	literals["inversion"] = 12;
54	>	literals["bond"] = 9;
55		}
56
57		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 139 | Line 146 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
146		theRetToken=_returnToken;
147		break;
148		}
149	<	case 0x22 /* '"' */ :
149	>	case 0x22 /* '\"' */ :
150		{
151		mStringLiteral(true);
152		theRetToken=_returnToken;
#	Line 266 | Line 273 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
273		}
274
275		void MDLexer::mASSIGNEQUAL(bool _createToken) {
276	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
276	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
277		_ttype = ASSIGNEQUAL;
278	<	int _saveIndex;
278	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
279
280	<	match('=');
280	>	match('=' /* charlit */ );
281		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
282		_token = makeToken(_ttype);
283		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 280 | Line 287 | void MDLexer::mCOLON(bool _createToken) {
287		}
288
289		void MDLexer::mCOLON(bool _createToken) {
290	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
290	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
291		_ttype = COLON;
292	<	int _saveIndex;
292	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
293
294	<	match(':');
294	>	match(':' /* charlit */ );
295		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
296		_token = makeToken(_ttype);
297		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 294 | Line 301 | void MDLexer::mCOMMA(bool _createToken) {
301		}
302
303		void MDLexer::mCOMMA(bool _createToken) {
304	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
304	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
305		_ttype = COMMA;
306	<	int _saveIndex;
306	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
307
308	<	match(',');
308	>	match(',' /* charlit */ );
309		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
310		_token = makeToken(_ttype);
311		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 308 | Line 315 | void MDLexer::mQUESTIONMARK(bool _createToken) {
315		}
316
317		void MDLexer::mQUESTIONMARK(bool _createToken) {
318	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
318	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
319		_ttype = QUESTIONMARK;
320	<	int _saveIndex;
320	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
321
322	<	match('?');
322	>	match('?' /* charlit */ );
323		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
324		_token = makeToken(_ttype);
325		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 322 | Line 329 | void MDLexer::mSEMICOLON(bool _createToken) {
329		}
330
331		void MDLexer::mSEMICOLON(bool _createToken) {
332	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
332	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
333		_ttype = SEMICOLON;
334	<	int _saveIndex;
334	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
335
336	<	match(';');
336	>	match(';' /* charlit */ );
337		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
338		_token = makeToken(_ttype);
339		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 336 | Line 343 | void MDLexer::mLPAREN(bool _createToken) {
343		}
344
345		void MDLexer::mLPAREN(bool _createToken) {
346	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
346	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
347		_ttype = LPAREN;
348	<	int _saveIndex;
348	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
349
350	<	match('(');
350	>	match('(' /* charlit */ );
351		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
352		_token = makeToken(_ttype);
353		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 350 | Line 357 | void MDLexer::mRPAREN(bool _createToken) {
357		}
358
359		void MDLexer::mRPAREN(bool _createToken) {
360	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
360	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
361		_ttype = RPAREN;
362	<	int _saveIndex;
362	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
363
364	<	match(')');
364	>	match(')' /* charlit */ );
365		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
366		_token = makeToken(_ttype);
367		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 364 | Line 371 | void MDLexer::mLBRACKET(bool _createToken) {
371		}
372
373		void MDLexer::mLBRACKET(bool _createToken) {
374	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
374	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
375		_ttype = LBRACKET;
376	<	int _saveIndex;
376	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
377
378	<	match('[');
378	>	match('[' /* charlit */ );
379		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
380		_token = makeToken(_ttype);
381		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 378 | Line 385 | void MDLexer::mRBRACKET(bool _createToken) {
385		}
386
387		void MDLexer::mRBRACKET(bool _createToken) {
388	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
388	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
389		_ttype = RBRACKET;
390	<	int _saveIndex;
390	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
391
392	<	match(']');
392	>	match(']' /* charlit */ );
393		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
394		_token = makeToken(_ttype);
395		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 392 | Line 399 | void MDLexer::mLCURLY(bool _createToken) {
399		}
400
401		void MDLexer::mLCURLY(bool _createToken) {
402	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
402	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
403		_ttype = LCURLY;
404	<	int _saveIndex;
404	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
405
406	<	match('{');
406	>	match('{' /* charlit */ );
407		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
408		_token = makeToken(_ttype);
409		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 406 | Line 413 | void MDLexer::mRCURLY(bool _createToken) {
413		}
414
415		void MDLexer::mRCURLY(bool _createToken) {
416	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
416	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
417		_ttype = RCURLY;
418	<	int _saveIndex;
418	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
419
420	<	match('}');
420	>	match('}' /* charlit */ );
421		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
422		_token = makeToken(_ttype);
423		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 420 | Line 427 | void MDLexer::mWhitespace(bool _createToken) {
427		}
428
429		void MDLexer::mWhitespace(bool _createToken) {
430	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
430	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
431		_ttype = Whitespace;
432	<	int _saveIndex;
432	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
433
434		{
435		switch ( LA(1)) {
#	Line 434 | Line 441 | void MDLexer::mWhitespace(bool _createToken) {
441		switch ( LA(1)) {
442		case 0x20 /* ' ' */ :
443		{
444	<	match(' ');
444	>	match(' ' /* charlit */ );
445		break;
446		}
447		case 0x9 /* '\t' */ :
448		{
449	<	match('\t');
449	>	match('\t' /* charlit */ );
450		break;
451		}
452		case 0xc /* '\14' */ :
453		{
454	<	match('\14');
454	>	match('\14' /* charlit */ );
455		break;
456		}
457		default:
#	Line 460 | Line 467 | void MDLexer::mWhitespace(bool _createToken) {
467		{
468		{
469		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
470	<	match('\r');
471	<	match('\n');
470	>	match('\r' /* charlit */ );
471	>	match('\n' /* charlit */ );
472		}
473		else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
474	<	match('\r');
474	>	match('\r' /* charlit */ );
475		}
476		else if ((LA(1) == 0xa /* '\n' */ )) {
477	<	match('\n');
477	>	match('\n' /* charlit */ );
478		}
479		else {
480		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 475 | Line 482 | void MDLexer::mWhitespace(bool _createToken) {
482
483		}
484		if ( inputState->guessing==0 ) {
485	<	#line 227 "MDParser.g"
485	>	#line 274 "MDParser.g"
486		newline();
487	<	#line 481 "MDLexer.cpp"
487	>	#line 488 "MDLexer.cpp"
488		}
489		break;
490		}
#	Line 485 | Line 492 | void MDLexer::mWhitespace(bool _createToken) {
492		{
493		{
494		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
495	<	match('\\');
496	<	match('\r');
497	<	match('\n');
495	>	match('\\' /* charlit */ );
496	>	match('\r' /* charlit */ );
497	>	match('\n' /* charlit */ );
498		}
499		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
500	<	match('\\');
501	<	match('\r');
500	>	match('\\' /* charlit */ );
501	>	match('\r' /* charlit */ );
502		}
503		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
504	<	match('\\');
505	<	match('\n');
504	>	match('\\' /* charlit */ );
505	>	match('\n' /* charlit */ );
506		}
507		else {
508		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 503 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510
511		}
512		if ( inputState->guessing==0 ) {
513	<	#line 232 "MDParser.g"
513	>	#line 279 "MDParser.g"
514		printf("CPP_parser.g continuation line detected\n");
515		deferredNewline();
516	<	#line 510 "MDLexer.cpp"
516	>	#line 517 "MDLexer.cpp"
517		}
518		break;
519		}
#	Line 517 | Line 524 | void MDLexer::mWhitespace(bool _createToken) {
524		}
525		}
526		if ( inputState->guessing==0 ) {
527	<	#line 235 "MDParser.g"
527	>	#line 282 "MDParser.g"
528		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
529	<	#line 523 "MDLexer.cpp"
529	>	#line 530 "MDLexer.cpp"
530		}
531		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
532		_token = makeToken(_ttype);
#	Line 530 | Line 537 | void MDLexer::mComment(bool _createToken) {
537		}
538
539		void MDLexer::mComment(bool _createToken) {
540	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
540	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
541		_ttype = Comment;
542	<	int _saveIndex;
542	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
543
544		match("/*");
545		{ // ( ... )*
546		for (;;) {
547	<	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
548	<	match('*');
547	>	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
548	>	match('*' /* charlit */ );
549		}
550		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
551		mEndOfLine(false);
552		if ( inputState->guessing==0 ) {
553	<	#line 242 "MDParser.g"
553	>	#line 289 "MDParser.g"
554		deferredNewline();
555	<	#line 549 "MDLexer.cpp"
555	>	#line 556 "MDLexer.cpp"
556		}
557		}
558		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 554 | Line 561 | void MDLexer::mComment(bool _createToken) {
561		}
562		}
563		else {
564	<	goto _loop83;
564	>	goto _loop101;
565		}
566
567		}
568	<	_loop83:;
568	>	_loop101:;
569		} // ( ... )*
570		match("*/");
571		if ( inputState->guessing==0 ) {
572	<	#line 245 "MDParser.g"
572	>	#line 292 "MDParser.g"
573		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
574	<	#line 568 "MDLexer.cpp"
574	>	#line 575 "MDLexer.cpp"
575		}
576		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
577		_token = makeToken(_ttype);
#	Line 575 | Line 582 | void MDLexer::mEndOfLine(bool _createToken) {
582		}
583
584		void MDLexer::mEndOfLine(bool _createToken) {
585	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
585	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
586		_ttype = EndOfLine;
587	<	int _saveIndex;
587	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
588
589		{
590		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
591		match("\r\n");
592		}
593		else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
594	<	match('\r');
594	>	match('\r' /* charlit */ );
595		}
596		else if ((LA(1) == 0xa /* '\n' */ )) {
597	<	match('\n');
597	>	match('\n' /* charlit */ );
598		}
599		else {
600		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 603 | Line 610 | void MDLexer::mCPPComment(bool _createToken) {
610		}
611
612		void MDLexer::mCPPComment(bool _createToken) {
613	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
613	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
614		_ttype = CPPComment;
615	<	int _saveIndex;
615	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
616
617		match("//");
618		{ // ( ... )*
#	Line 616 | Line 623 | void MDLexer::mCPPComment(bool _createToken) {
623		}
624		}
625		else {
626	<	goto _loop87;
626	>	goto _loop105;
627		}
628
629		}
630	<	_loop87:;
630	>	_loop105:;
631		} // ( ... )*
632		mEndOfLine(false);
633		if ( inputState->guessing==0 ) {
634	<	#line 251 "MDParser.g"
634	>	#line 298 "MDParser.g"
635		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
636	<	#line 630 "MDLexer.cpp"
636	>	#line 637 "MDLexer.cpp"
637		}
638		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
639		_token = makeToken(_ttype);
#	Line 637 | Line 644 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
644		}
645
646		void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
647	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
647	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
648		_ttype = PREPROC_DIRECTIVE;
649	<	int _saveIndex;
649	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
650
651	<	match('#');
651	>	match('#' /* charlit */ );
652		mLineDirective(false);
653		if ( inputState->guessing==0 ) {
654	<	#line 258 "MDParser.g"
654	>	#line 305 "MDParser.g"
655		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
656	<	#line 650 "MDLexer.cpp"
656	>	#line 657 "MDLexer.cpp"
657		}
658		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
659		_token = makeToken(_ttype);
#	Line 657 | Line 664 | void MDLexer::mLineDirective(bool _createToken) {
664		}
665
666		void MDLexer::mLineDirective(bool _createToken) {
667	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
667	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
668		_ttype = LineDirective;
669	<	int _saveIndex;
669	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
670		ANTLR_USE_NAMESPACE(antlr)RefToken n;
671		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
672
673		if ( inputState->guessing==0 ) {
674	<	#line 264 "MDParser.g"
674	>	#line 311 "MDParser.g"
675
676		deferredLineCount = 0;
677
678	<	#line 672 "MDLexer.cpp"
678	>	#line 679 "MDLexer.cpp"
679		}
680		{
681		switch ( LA(1)) {
#	Line 690 | Line 697 | void MDLexer::mLineDirective(bool _createToken) {
697		}
698		}
699		{ // ( ... )+
700	<	int _cnt92=0;
700	>	int _cnt110=0;
701		for (;;) {
702		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
703		mSpace(false);
704		}
705		else {
706	<	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
706	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
707		}
708
709	<	_cnt92++;
709	>	_cnt110++;
710		}
711	<	_loop92:;
711	>	_loop110:;
712		}  // ( ... )+
713		mDecimal(true);
714		n=_returnToken;
715		if ( inputState->guessing==0 ) {
716	<	#line 269 "MDParser.g"
717	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
718	<	#line 712 "MDLexer.cpp"
716	>	#line 316 "MDParser.g"
717	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
718	>	#line 719 "MDLexer.cpp"
719		}
720		{ // ( ... )+
721	<	int _cnt94=0;
721	>	int _cnt112=0;
722		for (;;) {
723		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
724		mSpace(false);
725		}
726		else {
727	<	if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
727	>	if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
728		}
729
730	<	_cnt94++;
730	>	_cnt112++;
731		}
732	<	_loop94:;
732	>	_loop112:;
733		}  // ( ... )+
734		{
735		mStringLiteral(true);
736		sl=_returnToken;
737		}
738		if ( inputState->guessing==0 ) {
739	<	#line 271 "MDParser.g"
739	>	#line 318 "MDParser.g"
740		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
741	<	#line 735 "MDLexer.cpp"
741	>	#line 742 "MDLexer.cpp"
742		}
743		{ // ( ... )*
744		for (;;) {
745		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746		{ // ( ... )+
747	<	int _cnt98=0;
747	>	int _cnt116=0;
748		for (;;) {
749		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
750		mSpace(false);
751		}
752		else {
753	<	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
753	>	if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
754		}
755
756	<	_cnt98++;
756	>	_cnt116++;
757		}
758	<	_loop98:;
758	>	_loop116:;
759		}  // ( ... )+
760		mDecimal(false);
761		}
762		else {
763	<	goto _loop99;
763	>	goto _loop117;
764		}
765
766		}
767	<	_loop99:;
767	>	_loop117:;
768		} // ( ... )*
769		mEndOfLine(false);
770		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 769 | Line 776 | void MDLexer::mSpace(bool _createToken) {
776		}
777
778		void MDLexer::mSpace(bool _createToken) {
779	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
779	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
780		_ttype = Space;
781	<	int _saveIndex;
781	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
782
783		{
784		switch ( LA(1)) {
785		case 0x20 /* ' ' */ :
786		{
787	<	match(' ');
787	>	match(' ' /* charlit */ );
788		break;
789		}
790		case 0x9 /* '\t' */ :
791		{
792	<	match('\t');
792	>	match('\t' /* charlit */ );
793		break;
794		}
795		case 0xc /* '\14' */ :
796		{
797	<	match('\14');
797	>	match('\14' /* charlit */ );
798		break;
799		}
800		default:
#	Line 805 | Line 812 | void MDLexer::mDecimal(bool _createToken) {
812		}
813
814		void MDLexer::mDecimal(bool _createToken) {
815	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
815	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
816		_ttype = Decimal;
817	<	int _saveIndex;
817	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
818
819		{ // ( ... )+
820	<	int _cnt129=0;
820	>	int _cnt147=0;
821		for (;;) {
822		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
823		matchRange('0','9');
824		}
825		else {
826	<	if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
826	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
827		}
828
829	<	_cnt129++;
829	>	_cnt147++;
830		}
831	<	_loop129:;
831	>	_loop147:;
832		}  // ( ... )+
833		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
834		_token = makeToken(_ttype);
#	Line 832 | Line 839 | void MDLexer::mStringLiteral(bool _createToken) {
839		}
840
841		void MDLexer::mStringLiteral(bool _createToken) {
842	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
842	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
843		_ttype = StringLiteral;
844	<	int _saveIndex;
844	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
845
846	<	match('"');
846	>	match('\"' /* charlit */ );
847		{ // ( ... )*
848		for (;;) {
849		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
#	Line 845 | Line 852 | void MDLexer::mStringLiteral(bool _createToken) {
852		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
853		{
854		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
855	<	match("\\r\n");
855	>	match("\\\r\n");
856		}
857		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
858	<	match("\\r");
858	>	match("\\\r");
859		}
860		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
861	<	match("\\n");
861	>	match("\\\n");
862		}
863		else {
864		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 859 | Line 866 | void MDLexer::mStringLiteral(bool _createToken) {
866
867		}
868		if ( inputState->guessing==0 ) {
869	<	#line 311 "MDParser.g"
869	>	#line 358 "MDParser.g"
870		deferredNewline();
871	<	#line 865 "MDLexer.cpp"
871	>	#line 872 "MDLexer.cpp"
872		}
873		}
874		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 870 | Line 877 | void MDLexer::mStringLiteral(bool _createToken) {
877		}
878		}
879		else {
880	<	goto _loop109;
880	>	goto _loop127;
881		}
882
883		}
884	<	_loop109:;
884	>	_loop127:;
885		} // ( ... )*
886	<	match('"');
886	>	match('\"' /* charlit */ );
887		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
888		_token = makeToken(_ttype);
889		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 886 | Line 893 | void MDLexer::mCharLiteral(bool _createToken) {
893		}
894
895		void MDLexer::mCharLiteral(bool _createToken) {
896	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
896	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
897		_ttype = CharLiteral;
898	<	int _saveIndex;
898	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
899
900	<	match('\'');
900	>	match('\'' /* charlit */ );
901		{
902		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
903		mEscape(false);
#	Line 905 | Line 912 | void MDLexer::mCharLiteral(bool _createToken) {
912		}
913
914		}
915	<	match('\'');
915	>	match('\'' /* charlit */ );
916		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
917		_token = makeToken(_ttype);
918		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 915 | Line 922 | void MDLexer::mEscape(bool _createToken) {
922		}
923
924		void MDLexer::mEscape(bool _createToken) {
925	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
925	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
926		_ttype = Escape;
927	<	int _saveIndex;
927	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
928
929	<	match('\\');
929	>	match('\\' /* charlit */ );
930		{
931		switch ( LA(1)) {
932		case 0x61 /* 'a' */ :
933		{
934	<	match('a');
934	>	match('a' /* charlit */ );
935		break;
936		}
937		case 0x62 /* 'b' */ :
938		{
939	<	match('b');
939	>	match('b' /* charlit */ );
940		break;
941		}
942		case 0x66 /* 'f' */ :
943		{
944	<	match('f');
944	>	match('f' /* charlit */ );
945		break;
946		}
947		case 0x6e /* 'n' */ :
948		{
949	<	match('n');
949	>	match('n' /* charlit */ );
950		break;
951		}
952		case 0x72 /* 'r' */ :
953		{
954	<	match('r');
954	>	match('r' /* charlit */ );
955		break;
956		}
957		case 0x74 /* 't' */ :
958		{
959	<	match('t');
959	>	match('t' /* charlit */ );
960		break;
961		}
962		case 0x76 /* 'v' */ :
963		{
964	<	match('v');
964	>	match('v' /* charlit */ );
965		break;
966		}
967	<	case 0x22 /* '"' */ :
967	>	case 0x22 /* '\"' */ :
968		{
969	<	match('"');
969	>	match('\"' /* charlit */ );
970		break;
971		}
972		case 0x27 /* '\'' */ :
973		{
974	<	match('\'');
974	>	match('\'' /* charlit */ );
975		break;
976		}
977		case 0x5c /* '\\' */ :
978		{
979	<	match('\\');
979	>	match('\\' /* charlit */ );
980		break;
981		}
982		case 0x3f /* '?' */ :
983		{
984	<	match('?');
984	>	match('?' /* charlit */ );
985		break;
986		}
987		case 0x30 /* '0' */ :
#	Line 1032 | Line 1039 | void MDLexer::mEscape(bool _createToken) {
1039		}
1040		case 0x78 /* 'x' */ :
1041		{
1042	<	match('x');
1042	>	match('x' /* charlit */ );
1043		{ // ( ... )+
1044	<	int _cnt120=0;
1044	>	int _cnt138=0;
1045		for (;;) {
1046		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1047		mDigit(false);
#	Line 1046 | Line 1053 | void MDLexer::mEscape(bool _createToken) {
1053		matchRange('A','F');
1054		}
1055		else {
1056	<	if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1056	>	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1057		}
1058
1059	<	_cnt120++;
1059	>	_cnt138++;
1060		}
1061	<	_loop120:;
1061	>	_loop138:;
1062		}  // ( ... )+
1063		break;
1064		}
#	Line 1070 | Line 1077 | void MDLexer::mDigit(bool _createToken) {
1077		}
1078
1079		void MDLexer::mDigit(bool _createToken) {
1080	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1080	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1081		_ttype = Digit;
1082	<	int _saveIndex;
1082	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1083
1084		matchRange('0','9');
1085		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1084 | Line 1091 | void MDLexer::mVocabulary(bool _createToken) {
1091		}
1092
1093		void MDLexer::mVocabulary(bool _createToken) {
1094	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1094	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1095		_ttype = Vocabulary;
1096	<	int _saveIndex;
1096	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1097
1098	<	matchRange('\3',static_cast<unsigned char>(255));
1098	>	matchRange('\3',static_cast<unsigned char>('\377'));
1099		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1100		_token = makeToken(_ttype);
1101		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1098 | Line 1105 | void MDLexer::mID(bool _createToken) {
1105		}
1106
1107		void MDLexer::mID(bool _createToken) {
1108	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1108	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1109		_ttype = ID;
1110	<	int _saveIndex;
1110	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1111
1112		{
1113		switch ( LA(1)) {
#	Line 1166 | Line 1173 | void MDLexer::mID(bool _createToken) {
1173		}
1174		case 0x5f /* '_' */ :
1175		{
1176	<	match('_');
1176	>	match('_' /* charlit */ );
1177		break;
1178		}
1179		default:
#	Line 1240 | Line 1247 | void MDLexer::mID(bool _createToken) {
1247		}
1248		case 0x5f /* '_' */ :
1249		{
1250	<	match('_');
1250	>	match('_' /* charlit */ );
1251		break;
1252		}
1253		case 0x30 /* '0' */ :
#	Line 1259 | Line 1266 | void MDLexer::mID(bool _createToken) {
1266		}
1267		default:
1268		{
1269	<	goto _loop125;
1269	>	goto _loop143;
1270		}
1271		}
1272		}
1273	<	_loop125:;
1273	>	_loop143:;
1274		} // ( ... )*
1275		_ttype = testLiteralsTable(_ttype);
1276		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1275 | Line 1282 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1282		}
1283
1284		void MDLexer::mHEX_DIGIT(bool _createToken) {
1285	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1285	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1286		_ttype = HEX_DIGIT;
1287	<	int _saveIndex;
1287	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1288
1289		{
1290		switch ( LA(1)) {
#	Line 1330 | Line 1337 | void MDLexer::mNUM_INT(bool _createToken) {
1337		}
1338
1339		void MDLexer::mNUM_INT(bool _createToken) {
1340	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1340	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1341		_ttype = NUM_INT;
1342	<	int _saveIndex;
1342	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1343		ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1344		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1345		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1346		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1347	<	#line 404 "MDParser.g"
1347	>	#line 451 "MDParser.g"
1348
1349		bool isDecimal = false;
1350		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1351
1352	<	#line 1346 "MDLexer.cpp"
1352	>	#line 1353 "MDLexer.cpp"
1353
1354		{
1355		switch ( LA(1)) {
1356		case 0x2b /* '+' */ :
1357		{
1358	<	match('+');
1358	>	match('+' /* charlit */ );
1359		break;
1360		}
1361		case 0x2d /* '-' */ :
1362		{
1363	<	match('-');
1363	>	match('-' /* charlit */ );
1364		break;
1365		}
1366		case 0x2e /* '.' */ :
#	Line 1380 | Line 1387 | void MDLexer::mNUM_INT(bool _createToken) {
1387		switch ( LA(1)) {
1388		case 0x2e /* '.' */ :
1389		{
1390	<	match('.');
1390	>	match('.' /* charlit */ );
1391		if ( inputState->guessing==0 ) {
1392	<	#line 411 "MDParser.g"
1392	>	#line 458 "MDParser.g"
1393		_ttype = DOT;
1394	<	#line 1388 "MDLexer.cpp"
1394	>	#line 1395 "MDLexer.cpp"
1395		}
1396		{
1397		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398		{ // ( ... )+
1399	<	int _cnt137=0;
1399	>	int _cnt155=0;
1400		for (;;) {
1401		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1402		matchRange('0','9');
1403		}
1404		else {
1405	<	if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1405	>	if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1406		}
1407
1408	<	_cnt137++;
1408	>	_cnt155++;
1409		}
1410	<	_loop137:;
1410	>	_loop155:;
1411		}  // ( ... )+
1412		{
1413		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1415 | Line 1422 | void MDLexer::mNUM_INT(bool _createToken) {
1422		mFLOAT_SUFFIX(true);
1423		f1=_returnToken;
1424		if ( inputState->guessing==0 ) {
1425	<	#line 412 "MDParser.g"
1425	>	#line 459 "MDParser.g"
1426		t=f1;
1427	<	#line 1421 "MDLexer.cpp"
1427	>	#line 1428 "MDLexer.cpp"
1428		}
1429		}
1430		else {
#	Line 1425 | Line 1432 | void MDLexer::mNUM_INT(bool _createToken) {
1432
1433		}
1434		if ( inputState->guessing==0 ) {
1435	<	#line 413 "MDParser.g"
1435	>	#line 460 "MDParser.g"
1436
1437		if ( t &&
1438		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1436 | Line 1443 | void MDLexer::mNUM_INT(bool _createToken) {
1443		_ttype = NUM_DOUBLE; // assume double
1444		}
1445
1446	<	#line 1440 "MDLexer.cpp"
1446	>	#line 1447 "MDLexer.cpp"
1447		}
1448		}
1449		else {
#	Line 1460 | Line 1467 | void MDLexer::mNUM_INT(bool _createToken) {
1467		switch ( LA(1)) {
1468		case 0x30 /* '0' */ :
1469		{
1470	<	match('0');
1470	>	match('0' /* charlit */ );
1471		if ( inputState->guessing==0 ) {
1472	<	#line 425 "MDParser.g"
1472	>	#line 472 "MDParser.g"
1473		isDecimal = true;
1474	<	#line 1468 "MDLexer.cpp"
1474	>	#line 1475 "MDLexer.cpp"
1475		}
1476		{
1477		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1472 | Line 1479 | void MDLexer::mNUM_INT(bool _createToken) {
1479		switch ( LA(1)) {
1480		case 0x78 /* 'x' */ :
1481		{
1482	<	match('x');
1482	>	match('x' /* charlit */ );
1483		break;
1484		}
1485		case 0x58 /* 'X' */ :
1486		{
1487	<	match('X');
1487	>	match('X' /* charlit */ );
1488		break;
1489		}
1490		default:
#	Line 1487 | Line 1494 | void MDLexer::mNUM_INT(bool _createToken) {
1494		}
1495		}
1496		{ // ( ... )+
1497	<	int _cnt144=0;
1497	>	int _cnt162=0;
1498		for (;;) {
1499		if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1500		mHEX_DIGIT(false);
1501		}
1502		else {
1503	<	if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1503	>	if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1504		}
1505
1506	<	_cnt144++;
1506	>	_cnt162++;
1507		}
1508	<	_loop144:;
1508	>	_loop162:;
1509		}  // ( ... )+
1510		}
1511		else {
1512	<	bool synPredMatched149 = false;
1512	>	bool synPredMatched167 = false;
1513		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1514	<	int _m149 = mark();
1515	<	synPredMatched149 = true;
1514	>	int _m167 = mark();
1515	>	synPredMatched167 = true;
1516		inputState->guessing++;
1517		try {
1518		{
1519		{ // ( ... )+
1520	<	int _cnt147=0;
1520	>	int _cnt165=0;
1521		for (;;) {
1522		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1523		matchRange('0','9');
1524		}
1525		else {
1526	<	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1526	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1527		}
1528
1529	<	_cnt147++;
1529	>	_cnt165++;
1530		}
1531	<	_loop147:;
1531	>	_loop165:;
1532		}  // ( ... )+
1533		{
1534		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1535		mEXPONENT(false);
1536		}
1537		else if ((LA(1) == 0x2e /* '.' */ )) {
1538	<	match('.');
1538	>	match('.' /* charlit */ );
1539		}
1540		else if ((_tokenSet_8.member(LA(1))) && (true)) {
1541		mFLOAT_SUFFIX(false);
#	Line 1541 | Line 1548 | void MDLexer::mNUM_INT(bool _createToken) {
1548		}
1549		}
1550		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1551	<	synPredMatched149 = false;
1551	>	synPredMatched167 = false;
1552		}
1553	<	rewind(_m149);
1553	>	rewind(_m167);
1554		inputState->guessing--;
1555		}
1556	<	if ( synPredMatched149 ) {
1556	>	if ( synPredMatched167 ) {
1557		{ // ( ... )+
1558	<	int _cnt151=0;
1558	>	int _cnt169=0;
1559		for (;;) {
1560		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1561		matchRange('0','9');
1562		}
1563		else {
1564	<	if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1564	>	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1565		}
1566
1567	<	_cnt151++;
1567	>	_cnt169++;
1568		}
1569	<	_loop151:;
1569	>	_loop169:;
1570		}  // ( ... )+
1571		}
1572		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1573		{ // ( ... )+
1574	<	int _cnt153=0;
1574	>	int _cnt171=0;
1575		for (;;) {
1576		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1577		matchRange('0','7');
1578		}
1579		else {
1580	<	if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1580	>	if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1581		}
1582
1583	<	_cnt153++;
1583	>	_cnt171++;
1584		}
1585	<	_loop153:;
1585	>	_loop171:;
1586		}  // ( ... )+
1587		}
1588		else {
#	Line 1603 | Line 1610 | void MDLexer::mNUM_INT(bool _createToken) {
1610		matchRange('0','9');
1611		}
1612		else {
1613	<	goto _loop156;
1613	>	goto _loop174;
1614		}
1615
1616		}
1617	<	_loop156:;
1617	>	_loop174:;
1618		} // ( ... )*
1619		if ( inputState->guessing==0 ) {
1620	<	#line 442 "MDParser.g"
1620	>	#line 489 "MDParser.g"
1621		isDecimal=true;
1622	<	#line 1616 "MDLexer.cpp"
1622	>	#line 1623 "MDLexer.cpp"
1623		}
1624		break;
1625		}
#	Line 1628 | Line 1635 | void MDLexer::mNUM_INT(bool _createToken) {
1635		switch ( LA(1)) {
1636		case 0x6c /* 'l' */ :
1637		{
1638	<	match('l');
1638	>	match('l' /* charlit */ );
1639		break;
1640		}
1641		case 0x4c /* 'L' */ :
1642		{
1643	<	match('L');
1643	>	match('L' /* charlit */ );
1644		break;
1645		}
1646		default:
#	Line 1643 | Line 1650 | void MDLexer::mNUM_INT(bool _createToken) {
1650		}
1651		}
1652		if ( inputState->guessing==0 ) {
1653	<	#line 444 "MDParser.g"
1653	>	#line 491 "MDParser.g"
1654		_ttype = NUM_LONG;
1655	<	#line 1649 "MDLexer.cpp"
1655	>	#line 1656 "MDLexer.cpp"
1656		}
1657		}
1658		else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
#	Line 1657 | Line 1664 | void MDLexer::mNUM_INT(bool _createToken) {
1664		mFLOAT_SUFFIX(true);
1665		f3=_returnToken;
1666		if ( inputState->guessing==0 ) {
1667	<	#line 449 "MDParser.g"
1667	>	#line 496 "MDParser.g"
1668		t=f3;
1669	<	#line 1663 "MDLexer.cpp"
1669	>	#line 1670 "MDLexer.cpp"
1670		}
1671		}
1672		else {
#	Line 1668 | Line 1675 | void MDLexer::mNUM_INT(bool _createToken) {
1675		}
1676		}
1677		else if ((LA(1) == 0x2e /* '.' */ )) {
1678	<	match('.');
1678	>	match('.' /* charlit */ );
1679		{ // ( ... )*
1680		for (;;) {
1681		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1682		matchRange('0','9');
1683		}
1684		else {
1685	<	goto _loop161;
1685	>	goto _loop179;
1686		}
1687
1688		}
1689	<	_loop161:;
1689	>	_loop179:;
1690		} // ( ... )*
1691		{
1692		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1694 | Line 1701 | void MDLexer::mNUM_INT(bool _createToken) {
1701		mFLOAT_SUFFIX(true);
1702		f2=_returnToken;
1703		if ( inputState->guessing==0 ) {
1704	<	#line 448 "MDParser.g"
1704	>	#line 495 "MDParser.g"
1705		t=f2;
1706	<	#line 1700 "MDLexer.cpp"
1706	>	#line 1707 "MDLexer.cpp"
1707		}
1708		}
1709		else {
#	Line 1708 | Line 1715 | void MDLexer::mNUM_INT(bool _createToken) {
1715		mFLOAT_SUFFIX(true);
1716		f4=_returnToken;
1717		if ( inputState->guessing==0 ) {
1718	<	#line 450 "MDParser.g"
1718	>	#line 497 "MDParser.g"
1719		t=f4;
1720	<	#line 1714 "MDLexer.cpp"
1720	>	#line 1721 "MDLexer.cpp"
1721		}
1722		}
1723		else {
#	Line 1719 | Line 1726 | void MDLexer::mNUM_INT(bool _createToken) {
1726
1727		}
1728		if ( inputState->guessing==0 ) {
1729	<	#line 452 "MDParser.g"
1729	>	#line 499 "MDParser.g"
1730
1731		if ( t &&
1732		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1730 | Line 1737 | void MDLexer::mNUM_INT(bool _createToken) {
1737		_ttype = NUM_DOUBLE; // assume double
1738		}
1739
1740	<	#line 1734 "MDLexer.cpp"
1740	>	#line 1741 "MDLexer.cpp"
1741		}
1742		}
1743		else {
#	Line 1754 | Line 1761 | void MDLexer::mEXPONENT(bool _createToken) {
1761		}
1762
1763		void MDLexer::mEXPONENT(bool _createToken) {
1764	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1764	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1765		_ttype = EXPONENT;
1766	<	int _saveIndex;
1766	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1767
1768		{
1769		switch ( LA(1)) {
1770		case 0x65 /* 'e' */ :
1771		{
1772	<	match('e');
1772	>	match('e' /* charlit */ );
1773		break;
1774		}
1775		case 0x45 /* 'E' */ :
1776		{
1777	<	match('E');
1777	>	match('E' /* charlit */ );
1778		break;
1779		}
1780		case 0x64 /* 'd' */ :
1781		{
1782	<	match('d');
1782	>	match('d' /* charlit */ );
1783		break;
1784		}
1785		case 0x44 /* 'D' */ :
1786		{
1787	<	match('D');
1787	>	match('D' /* charlit */ );
1788		break;
1789		}
1790		default:
#	Line 1790 | Line 1797 | void MDLexer::mEXPONENT(bool _createToken) {
1797		switch ( LA(1)) {
1798		case 0x2b /* '+' */ :
1799		{
1800	<	match('+');
1800	>	match('+' /* charlit */ );
1801		break;
1802		}
1803		case 0x2d /* '-' */ :
1804		{
1805	<	match('-');
1805	>	match('-' /* charlit */ );
1806		break;
1807		}
1808		case 0x30 /* '0' */ :
#	Line 1818 | Line 1825 | void MDLexer::mEXPONENT(bool _createToken) {
1825		}
1826		}
1827		{ // ( ... )+
1828	<	int _cnt169=0;
1828	>	int _cnt187=0;
1829		for (;;) {
1830		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1831		matchRange('0','9');
1832		}
1833		else {
1834	<	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1834	>	if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1835		}
1836
1837	<	_cnt169++;
1837	>	_cnt187++;
1838		}
1839	<	_loop169:;
1839	>	_loop187:;
1840		}  // ( ... )+
1841		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1842		_token = makeToken(_ttype);
#	Line 1840 | Line 1847 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1847		}
1848
1849		void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1850	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1850	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1851		_ttype = FLOAT_SUFFIX;
1852	<	int _saveIndex;
1852	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1853
1854		switch ( LA(1)) {
1855		case 0x66 /* 'f' */ :
1856		{
1857	<	match('f');
1857	>	match('f' /* charlit */ );
1858		break;
1859		}
1860		case 0x46 /* 'F' */ :
1861		{
1862	<	match('F');
1862	>	match('F' /* charlit */ );
1863		break;
1864		}
1865		case 0x64 /* 'd' */ :
1866		{
1867	<	match('d');
1867	>	match('d' /* charlit */ );
1868		break;
1869		}
1870		case 0x44 /* 'D' */ :
1871		{
1872	<	match('D');
1872	>	match('D' /* charlit */ );
1873		break;
1874		}
1875		default:
#	Line 1879 | Line 1886 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1886		}
1887
1888
1889	<	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1891	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1892	<	// \' ( ) + , - . / 0 1 2 3 4
1889	>	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1891	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1892	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1893		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1894	<	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1896	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1897	<	// \' ( ) * + , - . / 0 1 2 3 4
1894	>	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1897	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1899		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900	<	// " \' 0 1 2 3 4
1900	>	// \" \' 0 1 2 3 4 5 6 7
1901		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1902	<	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1904	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1905	<	// ( ) * + , - . / 0 1 2 3 4
1902	>	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1904	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1905	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1907		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	<	// \' 0 1 2 3 4
1908	>	// \' 0 1 2 3 4 5 6 7 8 9
1909		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1910	<	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1912	<	// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1913	<	// $ % & ( ) * + , - . / 0 1 2 3 4
1910	>	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1912	>	// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1913	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1914		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1915		const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1917		const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	<	// + - 0 1 2 3 4
1918	>	// + - 0 1 2 3 4 5 6 7 8 9
1919		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1920		const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1922		const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	<	// 0 1 2 3 4
1923	>	// 0 1 2 3 4 5 6 7 8 9
1924		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1925		const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926		// .

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

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

Diff Legend

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