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 1969 by gezelter, Wed Feb 26 14:14:50 2014 UTC

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

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1969 by gezelter, Wed Feb 26 14:14:50 2014 UTC

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

Diff Legend

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