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 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.4: "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20141024): "MDParser.g" -> "MDLexer.cpp"$ */
2		#include "MDLexer.hpp"
3		#include <antlr/CharBuffer.hpp>
4		#include <antlr/TokenStreamException.hpp>
#	Line 30 | Line 30 | void MDLexer::initLiterals()
30
31		void MDLexer::initLiterals()
32		{
33	<	literals["torsion"] = 10;
34	<	literals["molecule"] = 5;
35	<	literals["inversion"] = 11;
36	<	literals["fragment"] = 14;
37	<	literals["bend"] = 9;
38	<	literals["orientation"] = 18;
39	<	literals["cutoffGroup"] = 13;
33	>	literals["Quartic"] = 29;
34	>	literals["UreyBradley"] = 33;
35	>	literals["Harmonic"] = 27;
36	>	literals["flucQ"] = 23;
37	>	literals["satellites"] = 20;
38	>	literals["Opls"] = 37;
39	>	literals["cutoffGroup"] = 14;
40	>	literals["RNEMD"] = 24;
41	>	literals["constraint"] = 15;
42	>	literals["Trappe"] = 38;
43	>	literals["distance"] = 16;
44	>	literals["Cosine"] = 34;
45	>	literals["rigidBody"] = 13;
46	>	literals["fragment"] = 17;
47	>	literals["charge"] = 43;
48		literals["zconstraint"] = 6;
49	<	literals["bond"] = 8;
50	<	literals["rigidBody"] = 12;
43	<	literals["center"] = 16;
49	>	literals["minimizer"] = 25;
50	>	literals["Cubic"] = 28;
51		literals["component"] = 4;
52	<	literals["position"] = 17;
53	<	literals["atom"] = 7;
54	<	literals["members"] = 15;
52	>	literals["GhostBend"] = 32;
53	>	literals["center"] = 19;
54	>	literals["members"] = 18;
55	>	literals["position"] = 21;
56	>	literals["Charmm"] = 36;
57	>	literals["AmberImproper"] = 39;
58	>	literals["Fixed"] = 26;
59	>	literals["Polynomial"] = 30;
60	>	literals["orientation"] = 22;
61	>	literals["bend"] = 10;
62	>	literals["torsion"] = 11;
63	>	literals["atom"] = 8;
64	>	literals["molecule"] = 5;
65	>	literals["CentralAtomHeight"] = 41;
66	>	literals["Morse"] = 31;
67	>	literals["restraint"] = 7;
68	>	literals["inversion"] = 12;
69	>	literals["bond"] = 9;
70	>	literals["GhostTorsion"] = 35;
71	>	literals["ImproperCosine"] = 40;
72	>	literals["Dreiding"] = 42;
73		}
74
75		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 139 | Line 164 | ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken(
164		theRetToken=_returnToken;
165		break;
166		}
167	<	case 0x22 /* '"' */ :
167	>	case 0x22 /* '\"' */ :
168		{
169		mStringLiteral(true);
170		theRetToken=_returnToken;
#	Line 266 | Line 291 | void MDLexer::mASSIGNEQUAL(bool _createToken) {
291		}
292
293		void MDLexer::mASSIGNEQUAL(bool _createToken) {
294	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
294	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
295		_ttype = ASSIGNEQUAL;
296	<	int _saveIndex;
296	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
297
298	<	match('=');
298	>	match('=' /* charlit */ );
299		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
300		_token = makeToken(_ttype);
301		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 280 | Line 305 | void MDLexer::mCOLON(bool _createToken) {
305		}
306
307		void MDLexer::mCOLON(bool _createToken) {
308	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
308	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
309		_ttype = COLON;
310	<	int _saveIndex;
310	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
311
312	<	match(':');
312	>	match(':' /* charlit */ );
313		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
314		_token = makeToken(_ttype);
315		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 294 | Line 319 | void MDLexer::mCOMMA(bool _createToken) {
319		}
320
321		void MDLexer::mCOMMA(bool _createToken) {
322	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
322	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
323		_ttype = COMMA;
324	<	int _saveIndex;
324	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
325
326	<	match(',');
326	>	match(',' /* charlit */ );
327		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
328		_token = makeToken(_ttype);
329		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 308 | Line 333 | void MDLexer::mQUESTIONMARK(bool _createToken) {
333		}
334
335		void MDLexer::mQUESTIONMARK(bool _createToken) {
336	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
336	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
337		_ttype = QUESTIONMARK;
338	<	int _saveIndex;
338	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
339
340	<	match('?');
340	>	match('?' /* charlit */ );
341		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
342		_token = makeToken(_ttype);
343		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 322 | Line 347 | void MDLexer::mSEMICOLON(bool _createToken) {
347		}
348
349		void MDLexer::mSEMICOLON(bool _createToken) {
350	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
350	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
351		_ttype = SEMICOLON;
352	<	int _saveIndex;
352	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
353
354	<	match(';');
354	>	match(';' /* charlit */ );
355		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
356		_token = makeToken(_ttype);
357		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 336 | Line 361 | void MDLexer::mLPAREN(bool _createToken) {
361		}
362
363		void MDLexer::mLPAREN(bool _createToken) {
364	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
364	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
365		_ttype = LPAREN;
366	<	int _saveIndex;
366	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
367
368	<	match('(');
368	>	match('(' /* charlit */ );
369		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
370		_token = makeToken(_ttype);
371		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 350 | Line 375 | void MDLexer::mRPAREN(bool _createToken) {
375		}
376
377		void MDLexer::mRPAREN(bool _createToken) {
378	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
378	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
379		_ttype = RPAREN;
380	<	int _saveIndex;
380	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
381
382	<	match(')');
382	>	match(')' /* charlit */ );
383		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
384		_token = makeToken(_ttype);
385		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 364 | Line 389 | void MDLexer::mLBRACKET(bool _createToken) {
389		}
390
391		void MDLexer::mLBRACKET(bool _createToken) {
392	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
392	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
393		_ttype = LBRACKET;
394	<	int _saveIndex;
394	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
395
396	<	match('[');
396	>	match('[' /* charlit */ );
397		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
398		_token = makeToken(_ttype);
399		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 378 | Line 403 | void MDLexer::mRBRACKET(bool _createToken) {
403		}
404
405		void MDLexer::mRBRACKET(bool _createToken) {
406	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
406	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
407		_ttype = RBRACKET;
408	<	int _saveIndex;
408	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
409
410	<	match(']');
410	>	match(']' /* charlit */ );
411		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
412		_token = makeToken(_ttype);
413		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 392 | Line 417 | void MDLexer::mLCURLY(bool _createToken) {
417		}
418
419		void MDLexer::mLCURLY(bool _createToken) {
420	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
420	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
421		_ttype = LCURLY;
422	<	int _saveIndex;
422	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
423
424	<	match('{');
424	>	match('{' /* charlit */ );
425		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
426		_token = makeToken(_ttype);
427		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 406 | Line 431 | void MDLexer::mRCURLY(bool _createToken) {
431		}
432
433		void MDLexer::mRCURLY(bool _createToken) {
434	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
434	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
435		_ttype = RCURLY;
436	<	int _saveIndex;
436	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
437
438	<	match('}');
438	>	match('}' /* charlit */ );
439		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
440		_token = makeToken(_ttype);
441		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 420 | Line 445 | void MDLexer::mWhitespace(bool _createToken) {
445		}
446
447		void MDLexer::mWhitespace(bool _createToken) {
448	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
448	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
449		_ttype = Whitespace;
450	<	int _saveIndex;
450	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
451
452		{
453		switch ( LA(1)) {
#	Line 434 | Line 459 | void MDLexer::mWhitespace(bool _createToken) {
459		switch ( LA(1)) {
460		case 0x20 /* ' ' */ :
461		{
462	<	match(' ');
462	>	match(' ' /* charlit */ );
463		break;
464		}
465		case 0x9 /* '\t' */ :
466		{
467	<	match('\t');
467	>	match('\t' /* charlit */ );
468		break;
469		}
470		case 0xc /* '\14' */ :
471		{
472	<	match('\14');
472	>	match('\14' /* charlit */ );
473		break;
474		}
475		default:
#	Line 460 | Line 485 | void MDLexer::mWhitespace(bool _createToken) {
485		{
486		{
487		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
488	<	match('\r');
489	<	match('\n');
488	>	match('\r' /* charlit */ );
489	>	match('\n' /* charlit */ );
490		}
491		else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
492	<	match('\r');
492	>	match('\r' /* charlit */ );
493		}
494		else if ((LA(1) == 0xa /* '\n' */ )) {
495	<	match('\n');
495	>	match('\n' /* charlit */ );
496		}
497		else {
498		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 475 | Line 500 | void MDLexer::mWhitespace(bool _createToken) {
500
501		}
502		if ( inputState->guessing==0 ) {
503	<	#line 227 "MDParser.g"
503	>	#line 321 "MDParser.g"
504		newline();
505	<	#line 481 "MDLexer.cpp"
505	>	#line 506 "MDLexer.cpp"
506		}
507		break;
508		}
#	Line 485 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510		{
511		{
512		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
513	<	match('\\');
514	<	match('\r');
515	<	match('\n');
513	>	match('\\' /* charlit */ );
514	>	match('\r' /* charlit */ );
515	>	match('\n' /* charlit */ );
516		}
517		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (true)) {
518	<	match('\\');
519	<	match('\r');
518	>	match('\\' /* charlit */ );
519	>	match('\r' /* charlit */ );
520		}
521		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
522	<	match('\\');
523	<	match('\n');
522	>	match('\\' /* charlit */ );
523	>	match('\n' /* charlit */ );
524		}
525		else {
526		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 503 | Line 528 | void MDLexer::mWhitespace(bool _createToken) {
528
529		}
530		if ( inputState->guessing==0 ) {
531	<	#line 232 "MDParser.g"
531	>	#line 326 "MDParser.g"
532		printf("CPP_parser.g continuation line detected\n");
533		deferredNewline();
534	<	#line 510 "MDLexer.cpp"
534	>	#line 535 "MDLexer.cpp"
535		}
536		break;
537		}
#	Line 517 | Line 542 | void MDLexer::mWhitespace(bool _createToken) {
542		}
543		}
544		if ( inputState->guessing==0 ) {
545	<	#line 235 "MDParser.g"
545	>	#line 329 "MDParser.g"
546		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
547	<	#line 523 "MDLexer.cpp"
547	>	#line 548 "MDLexer.cpp"
548		}
549		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
550		_token = makeToken(_ttype);
#	Line 530 | Line 555 | void MDLexer::mComment(bool _createToken) {
555		}
556
557		void MDLexer::mComment(bool _createToken) {
558	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
558	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
559		_ttype = Comment;
560	<	int _saveIndex;
560	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
561
562		match("/*");
563		{ // ( ... )*
564		for (;;) {
565	<	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
566	<	match('*');
565	>	if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&(LA(2) != '/')) {
566	>	match('*' /* charlit */ );
567		}
568		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
569		mEndOfLine(false);
570		if ( inputState->guessing==0 ) {
571	<	#line 242 "MDParser.g"
571	>	#line 336 "MDParser.g"
572		deferredNewline();
573	<	#line 549 "MDLexer.cpp"
573	>	#line 574 "MDLexer.cpp"
574		}
575		}
576		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 554 | Line 579 | void MDLexer::mComment(bool _createToken) {
579		}
580		}
581		else {
582	<	goto _loop83;
582	>	goto _loop101;
583		}
584
585		}
586	<	_loop83:;
586	>	_loop101:;
587		} // ( ... )*
588		match("*/");
589		if ( inputState->guessing==0 ) {
590	<	#line 245 "MDParser.g"
590	>	#line 339 "MDParser.g"
591		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
592	<	#line 568 "MDLexer.cpp"
592	>	#line 593 "MDLexer.cpp"
593		}
594		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
595		_token = makeToken(_ttype);
#	Line 575 | Line 600 | void MDLexer::mEndOfLine(bool _createToken) {
600		}
601
602		void MDLexer::mEndOfLine(bool _createToken) {
603	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
603	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
604		_ttype = EndOfLine;
605	<	int _saveIndex;
605	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
606
607		{
608		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true)) {
609		match("\r\n");
610		}
611		else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true)) {
612	<	match('\r');
612	>	match('\r' /* charlit */ );
613		}
614		else if ((LA(1) == 0xa /* '\n' */ )) {
615	<	match('\n');
615	>	match('\n' /* charlit */ );
616		}
617		else {
618		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 603 | Line 628 | void MDLexer::mCPPComment(bool _createToken) {
628		}
629
630		void MDLexer::mCPPComment(bool _createToken) {
631	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
631	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
632		_ttype = CPPComment;
633	<	int _saveIndex;
633	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
634
635		match("//");
636		{ // ( ... )*
#	Line 616 | Line 641 | void MDLexer::mCPPComment(bool _createToken) {
641		}
642		}
643		else {
644	<	goto _loop87;
644	>	goto _loop105;
645		}
646
647		}
648	<	_loop87:;
648	>	_loop105:;
649		} // ( ... )*
650		mEndOfLine(false);
651		if ( inputState->guessing==0 ) {
652	<	#line 251 "MDParser.g"
652	>	#line 345 "MDParser.g"
653		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
654	<	#line 630 "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 637 | Line 662 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
662		}
663
664		void MDLexer::mPREPROC_DIRECTIVE(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 = PREPROC_DIRECTIVE;
667	<	int _saveIndex;
667	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
668
669	<	match('#');
669	>	match('#' /* charlit */ );
670		mLineDirective(false);
671		if ( inputState->guessing==0 ) {
672	<	#line 258 "MDParser.g"
672	>	#line 352 "MDParser.g"
673		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
674	<	#line 650 "MDLexer.cpp"
674	>	#line 675 "MDLexer.cpp"
675		}
676		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
677		_token = makeToken(_ttype);
#	Line 657 | Line 682 | void MDLexer::mLineDirective(bool _createToken) {
682		}
683
684		void MDLexer::mLineDirective(bool _createToken) {
685	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
685	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
686		_ttype = LineDirective;
687	<	int _saveIndex;
687	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
688		ANTLR_USE_NAMESPACE(antlr)RefToken n;
689		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
690
691		if ( inputState->guessing==0 ) {
692	<	#line 264 "MDParser.g"
692	>	#line 358 "MDParser.g"
693
694		deferredLineCount = 0;
695
696	<	#line 672 "MDLexer.cpp"
696	>	#line 697 "MDLexer.cpp"
697		}
698		{
699		switch ( LA(1)) {
#	Line 690 | Line 715 | void MDLexer::mLineDirective(bool _createToken) {
715		}
716		}
717		{ // ( ... )+
718	<	int _cnt92=0;
718	>	int _cnt110=0;
719		for (;;) {
720		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
721		mSpace(false);
722		}
723		else {
724	<	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
725		}
726
727	<	_cnt92++;
727	>	_cnt110++;
728		}
729	<	_loop92:;
729	>	_loop110:;
730		}  // ( ... )+
731		mDecimal(true);
732		n=_returnToken;
733		if ( inputState->guessing==0 ) {
734	<	#line 269 "MDParser.g"
735	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
736	<	#line 712 "MDLexer.cpp"
734	>	#line 363 "MDParser.g"
735	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
736	>	#line 737 "MDLexer.cpp"
737		}
738		{ // ( ... )+
739	<	int _cnt94=0;
739	>	int _cnt112=0;
740		for (;;) {
741		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
742		mSpace(false);
743		}
744		else {
745	<	if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
745	>	if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
746		}
747
748	<	_cnt94++;
748	>	_cnt112++;
749		}
750	<	_loop94:;
750	>	_loop112:;
751		}  // ( ... )+
752		{
753		mStringLiteral(true);
754		sl=_returnToken;
755		}
756		if ( inputState->guessing==0 ) {
757	<	#line 271 "MDParser.g"
757	>	#line 365 "MDParser.g"
758		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
759	<	#line 735 "MDLexer.cpp"
759	>	#line 760 "MDLexer.cpp"
760		}
761		{ // ( ... )*
762		for (;;) {
763		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
764		{ // ( ... )+
765	<	int _cnt98=0;
765	>	int _cnt116=0;
766		for (;;) {
767		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
768		mSpace(false);
769		}
770		else {
771	<	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
771	>	if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
772		}
773
774	<	_cnt98++;
774	>	_cnt116++;
775		}
776	<	_loop98:;
776	>	_loop116:;
777		}  // ( ... )+
778		mDecimal(false);
779		}
780		else {
781	<	goto _loop99;
781	>	goto _loop117;
782		}
783
784		}
785	<	_loop99:;
785	>	_loop117:;
786		} // ( ... )*
787		mEndOfLine(false);
788		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 769 | Line 794 | void MDLexer::mSpace(bool _createToken) {
794		}
795
796		void MDLexer::mSpace(bool _createToken) {
797	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
797	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
798		_ttype = Space;
799	<	int _saveIndex;
799	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
800
801		{
802		switch ( LA(1)) {
803		case 0x20 /* ' ' */ :
804		{
805	<	match(' ');
805	>	match(' ' /* charlit */ );
806		break;
807		}
808		case 0x9 /* '\t' */ :
809		{
810	<	match('\t');
810	>	match('\t' /* charlit */ );
811		break;
812		}
813		case 0xc /* '\14' */ :
814		{
815	<	match('\14');
815	>	match('\14' /* charlit */ );
816		break;
817		}
818		default:
#	Line 805 | Line 830 | void MDLexer::mDecimal(bool _createToken) {
830		}
831
832		void MDLexer::mDecimal(bool _createToken) {
833	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
833	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
834		_ttype = Decimal;
835	<	int _saveIndex;
835	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
836
837		{ // ( ... )+
838	<	int _cnt129=0;
838	>	int _cnt147=0;
839		for (;;) {
840		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
841		matchRange('0','9');
842		}
843		else {
844	<	if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
844	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
845		}
846
847	<	_cnt129++;
847	>	_cnt147++;
848		}
849	<	_loop129:;
849	>	_loop147:;
850		}  // ( ... )+
851		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
852		_token = makeToken(_ttype);
#	Line 832 | Line 857 | void MDLexer::mStringLiteral(bool _createToken) {
857		}
858
859		void MDLexer::mStringLiteral(bool _createToken) {
860	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
860	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
861		_ttype = StringLiteral;
862	<	int _saveIndex;
862	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
863
864	<	match('"');
864	>	match('\"' /* charlit */ );
865		{ // ( ... )*
866		for (;;) {
867		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2)))) {
#	Line 845 | Line 870 | void MDLexer::mStringLiteral(bool _createToken) {
870		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */  || LA(2) == 0xd /* '\r' */ )) {
871		{
872		if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (LA(3) == 0xa /* '\n' */ )) {
873	<	match("\\r\n");
873	>	match("\\\r\n");
874		}
875		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xd /* '\r' */ ) && (_tokenSet_1.member(LA(3)))) {
876	<	match("\\r");
876	>	match("\\\r");
877		}
878		else if ((LA(1) == 0x5c /* '\\' */ ) && (LA(2) == 0xa /* '\n' */ )) {
879	<	match("\\n");
879	>	match("\\\n");
880		}
881		else {
882		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 859 | Line 884 | void MDLexer::mStringLiteral(bool _createToken) {
884
885		}
886		if ( inputState->guessing==0 ) {
887	<	#line 311 "MDParser.g"
887	>	#line 405 "MDParser.g"
888		deferredNewline();
889	<	#line 865 "MDLexer.cpp"
889	>	#line 890 "MDLexer.cpp"
890		}
891		}
892		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 870 | Line 895 | void MDLexer::mStringLiteral(bool _createToken) {
895		}
896		}
897		else {
898	<	goto _loop109;
898	>	goto _loop127;
899		}
900
901		}
902	<	_loop109:;
902	>	_loop127:;
903		} // ( ... )*
904	<	match('"');
904	>	match('\"' /* charlit */ );
905		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
906		_token = makeToken(_ttype);
907		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 886 | Line 911 | void MDLexer::mCharLiteral(bool _createToken) {
911		}
912
913		void MDLexer::mCharLiteral(bool _createToken) {
914	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
914	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
915		_ttype = CharLiteral;
916	<	int _saveIndex;
916	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
917
918	<	match('\'');
918	>	match('\'' /* charlit */ );
919		{
920		if ((LA(1) == 0x5c /* '\\' */ ) && (_tokenSet_2.member(LA(2))) && (_tokenSet_4.member(LA(3)))) {
921		mEscape(false);
#	Line 905 | Line 930 | void MDLexer::mCharLiteral(bool _createToken) {
930		}
931
932		}
933	<	match('\'');
933	>	match('\'' /* charlit */ );
934		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
935		_token = makeToken(_ttype);
936		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 915 | Line 940 | void MDLexer::mEscape(bool _createToken) {
940		}
941
942		void MDLexer::mEscape(bool _createToken) {
943	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
943	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
944		_ttype = Escape;
945	<	int _saveIndex;
945	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
946
947	<	match('\\');
947	>	match('\\' /* charlit */ );
948		{
949		switch ( LA(1)) {
950		case 0x61 /* 'a' */ :
951		{
952	<	match('a');
952	>	match('a' /* charlit */ );
953		break;
954		}
955		case 0x62 /* 'b' */ :
956		{
957	<	match('b');
957	>	match('b' /* charlit */ );
958		break;
959		}
960		case 0x66 /* 'f' */ :
961		{
962	<	match('f');
962	>	match('f' /* charlit */ );
963		break;
964		}
965		case 0x6e /* 'n' */ :
966		{
967	<	match('n');
967	>	match('n' /* charlit */ );
968		break;
969		}
970		case 0x72 /* 'r' */ :
971		{
972	<	match('r');
972	>	match('r' /* charlit */ );
973		break;
974		}
975		case 0x74 /* 't' */ :
976		{
977	<	match('t');
977	>	match('t' /* charlit */ );
978		break;
979		}
980		case 0x76 /* 'v' */ :
981		{
982	<	match('v');
982	>	match('v' /* charlit */ );
983		break;
984		}
985	<	case 0x22 /* '"' */ :
985	>	case 0x22 /* '\"' */ :
986		{
987	<	match('"');
987	>	match('\"' /* charlit */ );
988		break;
989		}
990		case 0x27 /* '\'' */ :
991		{
992	<	match('\'');
992	>	match('\'' /* charlit */ );
993		break;
994		}
995		case 0x5c /* '\\' */ :
996		{
997	<	match('\\');
997	>	match('\\' /* charlit */ );
998		break;
999		}
1000		case 0x3f /* '?' */ :
1001		{
1002	<	match('?');
1002	>	match('?' /* charlit */ );
1003		break;
1004		}
1005		case 0x30 /* '0' */ :
#	Line 1032 | Line 1057 | void MDLexer::mEscape(bool _createToken) {
1057		}
1058		case 0x78 /* 'x' */ :
1059		{
1060	<	match('x');
1060	>	match('x' /* charlit */ );
1061		{ // ( ... )+
1062	<	int _cnt120=0;
1062	>	int _cnt138=0;
1063		for (;;) {
1064		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1065		mDigit(false);
#	Line 1046 | Line 1071 | void MDLexer::mEscape(bool _createToken) {
1071		matchRange('A','F');
1072		}
1073		else {
1074	<	if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1074	>	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1075		}
1076
1077	<	_cnt120++;
1077	>	_cnt138++;
1078		}
1079	<	_loop120:;
1079	>	_loop138:;
1080		}  // ( ... )+
1081		break;
1082		}
#	Line 1070 | Line 1095 | void MDLexer::mDigit(bool _createToken) {
1095		}
1096
1097		void MDLexer::mDigit(bool _createToken) {
1098	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1098	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1099		_ttype = Digit;
1100	<	int _saveIndex;
1100	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1101
1102		matchRange('0','9');
1103		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1084 | Line 1109 | void MDLexer::mVocabulary(bool _createToken) {
1109		}
1110
1111		void MDLexer::mVocabulary(bool _createToken) {
1112	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1112	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1113		_ttype = Vocabulary;
1114	<	int _saveIndex;
1114	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1115
1116	<	matchRange('\3',static_cast<unsigned char>(255));
1116	>	matchRange('\3',static_cast<unsigned char>('\377'));
1117		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1118		_token = makeToken(_ttype);
1119		_token->setText(text.substr(_begin, text.length()-_begin));
#	Line 1098 | Line 1123 | void MDLexer::mID(bool _createToken) {
1123		}
1124
1125		void MDLexer::mID(bool _createToken) {
1126	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1126	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1127		_ttype = ID;
1128	<	int _saveIndex;
1128	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1129
1130		{
1131		switch ( LA(1)) {
#	Line 1166 | Line 1191 | void MDLexer::mID(bool _createToken) {
1191		}
1192		case 0x5f /* '_' */ :
1193		{
1194	<	match('_');
1194	>	match('_' /* charlit */ );
1195		break;
1196		}
1197		default:
#	Line 1240 | Line 1265 | void MDLexer::mID(bool _createToken) {
1265		}
1266		case 0x5f /* '_' */ :
1267		{
1268	<	match('_');
1268	>	match('_' /* charlit */ );
1269		break;
1270		}
1271		case 0x30 /* '0' */ :
#	Line 1259 | Line 1284 | void MDLexer::mID(bool _createToken) {
1284		}
1285		default:
1286		{
1287	<	goto _loop125;
1287	>	goto _loop143;
1288		}
1289		}
1290		}
1291	<	_loop125:;
1291	>	_loop143:;
1292		} // ( ... )*
1293		_ttype = testLiteralsTable(_ttype);
1294		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1275 | Line 1300 | void MDLexer::mHEX_DIGIT(bool _createToken) {
1300		}
1301
1302		void MDLexer::mHEX_DIGIT(bool _createToken) {
1303	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1303	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1304		_ttype = HEX_DIGIT;
1305	<	int _saveIndex;
1305	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1306
1307		{
1308		switch ( LA(1)) {
#	Line 1330 | Line 1355 | void MDLexer::mNUM_INT(bool _createToken) {
1355		}
1356
1357		void MDLexer::mNUM_INT(bool _createToken) {
1358	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1358	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1359		_ttype = NUM_INT;
1360	<	int _saveIndex;
1360	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1361		ANTLR_USE_NAMESPACE(antlr)RefToken f1;
1362		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1363		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1364		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1365	<	#line 404 "MDParser.g"
1365	>	#line 498 "MDParser.g"
1366
1367		bool isDecimal = false;
1368		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1369
1370	<	#line 1346 "MDLexer.cpp"
1370	>	#line 1371 "MDLexer.cpp"
1371
1372		{
1373		switch ( LA(1)) {
1374		case 0x2b /* '+' */ :
1375		{
1376	<	match('+');
1376	>	match('+' /* charlit */ );
1377		break;
1378		}
1379		case 0x2d /* '-' */ :
1380		{
1381	<	match('-');
1381	>	match('-' /* charlit */ );
1382		break;
1383		}
1384		case 0x2e /* '.' */ :
#	Line 1380 | Line 1405 | void MDLexer::mNUM_INT(bool _createToken) {
1405		switch ( LA(1)) {
1406		case 0x2e /* '.' */ :
1407		{
1408	<	match('.');
1408	>	match('.' /* charlit */ );
1409		if ( inputState->guessing==0 ) {
1410	<	#line 411 "MDParser.g"
1410	>	#line 505 "MDParser.g"
1411		_ttype = DOT;
1412	<	#line 1388 "MDLexer.cpp"
1412	>	#line 1413 "MDLexer.cpp"
1413		}
1414		{
1415		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1416		{ // ( ... )+
1417	<	int _cnt137=0;
1417	>	int _cnt155=0;
1418		for (;;) {
1419		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1420		matchRange('0','9');
1421		}
1422		else {
1423	<	if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1423	>	if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1424		}
1425
1426	<	_cnt137++;
1426	>	_cnt155++;
1427		}
1428	<	_loop137:;
1428	>	_loop155:;
1429		}  // ( ... )+
1430		{
1431		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1415 | Line 1440 | void MDLexer::mNUM_INT(bool _createToken) {
1440		mFLOAT_SUFFIX(true);
1441		f1=_returnToken;
1442		if ( inputState->guessing==0 ) {
1443	<	#line 412 "MDParser.g"
1443	>	#line 506 "MDParser.g"
1444		t=f1;
1445	<	#line 1421 "MDLexer.cpp"
1445	>	#line 1446 "MDLexer.cpp"
1446		}
1447		}
1448		else {
#	Line 1425 | Line 1450 | void MDLexer::mNUM_INT(bool _createToken) {
1450
1451		}
1452		if ( inputState->guessing==0 ) {
1453	<	#line 413 "MDParser.g"
1453	>	#line 507 "MDParser.g"
1454
1455		if ( t &&
1456		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1436 | Line 1461 | void MDLexer::mNUM_INT(bool _createToken) {
1461		_ttype = NUM_DOUBLE; // assume double
1462		}
1463
1464	<	#line 1440 "MDLexer.cpp"
1464	>	#line 1465 "MDLexer.cpp"
1465		}
1466		}
1467		else {
#	Line 1460 | Line 1485 | void MDLexer::mNUM_INT(bool _createToken) {
1485		switch ( LA(1)) {
1486		case 0x30 /* '0' */ :
1487		{
1488	<	match('0');
1488	>	match('0' /* charlit */ );
1489		if ( inputState->guessing==0 ) {
1490	<	#line 425 "MDParser.g"
1490	>	#line 519 "MDParser.g"
1491		isDecimal = true;
1492	<	#line 1468 "MDLexer.cpp"
1492	>	#line 1493 "MDLexer.cpp"
1493		}
1494		{
1495		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1472 | Line 1497 | void MDLexer::mNUM_INT(bool _createToken) {
1497		switch ( LA(1)) {
1498		case 0x78 /* 'x' */ :
1499		{
1500	<	match('x');
1500	>	match('x' /* charlit */ );
1501		break;
1502		}
1503		case 0x58 /* 'X' */ :
1504		{
1505	<	match('X');
1505	>	match('X' /* charlit */ );
1506		break;
1507		}
1508		default:
#	Line 1487 | Line 1512 | void MDLexer::mNUM_INT(bool _createToken) {
1512		}
1513		}
1514		{ // ( ... )+
1515	<	int _cnt144=0;
1515	>	int _cnt162=0;
1516		for (;;) {
1517		if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1518		mHEX_DIGIT(false);
1519		}
1520		else {
1521	<	if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521	>	if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1522		}
1523
1524	<	_cnt144++;
1524	>	_cnt162++;
1525		}
1526	<	_loop144:;
1526	>	_loop162:;
1527		}  // ( ... )+
1528		}
1529		else {
1530	<	bool synPredMatched149 = false;
1530	>	bool synPredMatched167 = false;
1531		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1532	<	int _m149 = mark();
1533	<	synPredMatched149 = true;
1532	>	int _m167 = mark();
1533	>	synPredMatched167 = true;
1534		inputState->guessing++;
1535		try {
1536		{
1537		{ // ( ... )+
1538	<	int _cnt147=0;
1538	>	int _cnt165=0;
1539		for (;;) {
1540		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1541		matchRange('0','9');
1542		}
1543		else {
1544	<	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1544	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1545		}
1546
1547	<	_cnt147++;
1547	>	_cnt165++;
1548		}
1549	<	_loop147:;
1549	>	_loop165:;
1550		}  // ( ... )+
1551		{
1552		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1553		mEXPONENT(false);
1554		}
1555		else if ((LA(1) == 0x2e /* '.' */ )) {
1556	<	match('.');
1556	>	match('.' /* charlit */ );
1557		}
1558		else if ((_tokenSet_8.member(LA(1))) && (true)) {
1559		mFLOAT_SUFFIX(false);
#	Line 1541 | Line 1566 | void MDLexer::mNUM_INT(bool _createToken) {
1566		}
1567		}
1568		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1569	<	synPredMatched149 = false;
1569	>	synPredMatched167 = false;
1570		}
1571	<	rewind(_m149);
1571	>	rewind(_m167);
1572		inputState->guessing--;
1573		}
1574	<	if ( synPredMatched149 ) {
1574	>	if ( synPredMatched167 ) {
1575		{ // ( ... )+
1576	<	int _cnt151=0;
1576	>	int _cnt169=0;
1577		for (;;) {
1578		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1579		matchRange('0','9');
1580		}
1581		else {
1582	<	if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1582	>	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1583		}
1584
1585	<	_cnt151++;
1585	>	_cnt169++;
1586		}
1587	<	_loop151:;
1587	>	_loop169:;
1588		}  // ( ... )+
1589		}
1590		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1591		{ // ( ... )+
1592	<	int _cnt153=0;
1592	>	int _cnt171=0;
1593		for (;;) {
1594		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1595		matchRange('0','7');
1596		}
1597		else {
1598	<	if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1598	>	if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1599		}
1600
1601	<	_cnt153++;
1601	>	_cnt171++;
1602		}
1603	<	_loop153:;
1603	>	_loop171:;
1604		}  // ( ... )+
1605		}
1606		else {
#	Line 1603 | Line 1628 | void MDLexer::mNUM_INT(bool _createToken) {
1628		matchRange('0','9');
1629		}
1630		else {
1631	<	goto _loop156;
1631	>	goto _loop174;
1632		}
1633
1634		}
1635	<	_loop156:;
1635	>	_loop174:;
1636		} // ( ... )*
1637		if ( inputState->guessing==0 ) {
1638	<	#line 442 "MDParser.g"
1638	>	#line 536 "MDParser.g"
1639		isDecimal=true;
1640	<	#line 1616 "MDLexer.cpp"
1640	>	#line 1641 "MDLexer.cpp"
1641		}
1642		break;
1643		}
#	Line 1628 | Line 1653 | void MDLexer::mNUM_INT(bool _createToken) {
1653		switch ( LA(1)) {
1654		case 0x6c /* 'l' */ :
1655		{
1656	<	match('l');
1656	>	match('l' /* charlit */ );
1657		break;
1658		}
1659		case 0x4c /* 'L' */ :
1660		{
1661	<	match('L');
1661	>	match('L' /* charlit */ );
1662		break;
1663		}
1664		default:
#	Line 1643 | Line 1668 | void MDLexer::mNUM_INT(bool _createToken) {
1668		}
1669		}
1670		if ( inputState->guessing==0 ) {
1671	<	#line 444 "MDParser.g"
1671	>	#line 538 "MDParser.g"
1672		_ttype = NUM_LONG;
1673	<	#line 1649 "MDLexer.cpp"
1673	>	#line 1674 "MDLexer.cpp"
1674		}
1675		}
1676		else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
#	Line 1657 | Line 1682 | void MDLexer::mNUM_INT(bool _createToken) {
1682		mFLOAT_SUFFIX(true);
1683		f3=_returnToken;
1684		if ( inputState->guessing==0 ) {
1685	<	#line 449 "MDParser.g"
1685	>	#line 543 "MDParser.g"
1686		t=f3;
1687	<	#line 1663 "MDLexer.cpp"
1687	>	#line 1688 "MDLexer.cpp"
1688		}
1689		}
1690		else {
#	Line 1668 | Line 1693 | void MDLexer::mNUM_INT(bool _createToken) {
1693		}
1694		}
1695		else if ((LA(1) == 0x2e /* '.' */ )) {
1696	<	match('.');
1696	>	match('.' /* charlit */ );
1697		{ // ( ... )*
1698		for (;;) {
1699		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1700		matchRange('0','9');
1701		}
1702		else {
1703	<	goto _loop161;
1703	>	goto _loop179;
1704		}
1705
1706		}
1707	<	_loop161:;
1707	>	_loop179:;
1708		} // ( ... )*
1709		{
1710		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1694 | Line 1719 | void MDLexer::mNUM_INT(bool _createToken) {
1719		mFLOAT_SUFFIX(true);
1720		f2=_returnToken;
1721		if ( inputState->guessing==0 ) {
1722	<	#line 448 "MDParser.g"
1722	>	#line 542 "MDParser.g"
1723		t=f2;
1724	<	#line 1700 "MDLexer.cpp"
1724	>	#line 1725 "MDLexer.cpp"
1725		}
1726		}
1727		else {
#	Line 1708 | Line 1733 | void MDLexer::mNUM_INT(bool _createToken) {
1733		mFLOAT_SUFFIX(true);
1734		f4=_returnToken;
1735		if ( inputState->guessing==0 ) {
1736	<	#line 450 "MDParser.g"
1736	>	#line 544 "MDParser.g"
1737		t=f4;
1738	<	#line 1714 "MDLexer.cpp"
1738	>	#line 1739 "MDLexer.cpp"
1739		}
1740		}
1741		else {
#	Line 1719 | Line 1744 | void MDLexer::mNUM_INT(bool _createToken) {
1744
1745		}
1746		if ( inputState->guessing==0 ) {
1747	<	#line 452 "MDParser.g"
1747	>	#line 546 "MDParser.g"
1748
1749		if ( t &&
1750		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1730 | Line 1755 | void MDLexer::mNUM_INT(bool _createToken) {
1755		_ttype = NUM_DOUBLE; // assume double
1756		}
1757
1758	<	#line 1734 "MDLexer.cpp"
1758	>	#line 1759 "MDLexer.cpp"
1759		}
1760		}
1761		else {
#	Line 1754 | Line 1779 | void MDLexer::mEXPONENT(bool _createToken) {
1779		}
1780
1781		void MDLexer::mEXPONENT(bool _createToken) {
1782	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1782	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1783		_ttype = EXPONENT;
1784	<	int _saveIndex;
1784	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1785
1786		{
1787		switch ( LA(1)) {
1788		case 0x65 /* 'e' */ :
1789		{
1790	<	match('e');
1790	>	match('e' /* charlit */ );
1791		break;
1792		}
1793		case 0x45 /* 'E' */ :
1794		{
1795	<	match('E');
1795	>	match('E' /* charlit */ );
1796		break;
1797		}
1798		case 0x64 /* 'd' */ :
1799		{
1800	<	match('d');
1800	>	match('d' /* charlit */ );
1801		break;
1802		}
1803		case 0x44 /* 'D' */ :
1804		{
1805	<	match('D');
1805	>	match('D' /* charlit */ );
1806		break;
1807		}
1808		default:
#	Line 1790 | Line 1815 | void MDLexer::mEXPONENT(bool _createToken) {
1815		switch ( LA(1)) {
1816		case 0x2b /* '+' */ :
1817		{
1818	<	match('+');
1818	>	match('+' /* charlit */ );
1819		break;
1820		}
1821		case 0x2d /* '-' */ :
1822		{
1823	<	match('-');
1823	>	match('-' /* charlit */ );
1824		break;
1825		}
1826		case 0x30 /* '0' */ :
#	Line 1818 | Line 1843 | void MDLexer::mEXPONENT(bool _createToken) {
1843		}
1844		}
1845		{ // ( ... )+
1846	<	int _cnt169=0;
1846	>	int _cnt187=0;
1847		for (;;) {
1848		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1849		matchRange('0','9');
1850		}
1851		else {
1852	<	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1852	>	if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1853		}
1854
1855	<	_cnt169++;
1855	>	_cnt187++;
1856		}
1857	<	_loop169:;
1857	>	_loop187:;
1858		}  // ( ... )+
1859		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1860		_token = makeToken(_ttype);
#	Line 1840 | Line 1865 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1865		}
1866
1867		void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1868	<	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
1868	>	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
1869		_ttype = FLOAT_SUFFIX;
1870	<	int _saveIndex;
1870	>	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
1871
1872		switch ( LA(1)) {
1873		case 0x66 /* 'f' */ :
1874		{
1875	<	match('f');
1875	>	match('f' /* charlit */ );
1876		break;
1877		}
1878		case 0x46 /* 'F' */ :
1879		{
1880	<	match('F');
1880	>	match('F' /* charlit */ );
1881		break;
1882		}
1883		case 0x64 /* 'd' */ :
1884		{
1885	<	match('d');
1885	>	match('d' /* charlit */ );
1886		break;
1887		}
1888		case 0x44 /* 'D' */ :
1889		{
1890	<	match('D');
1890	>	match('D' /* charlit */ );
1891		break;
1892		}
1893		default:
#	Line 1879 | Line 1904 | void MDLexer::mFLOAT_SUFFIX(bool _createToken) {
1904		}
1905
1906
1907	<	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1909	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1910	<	// \' ( ) + , - . / 0 1 2 3 4
1907	>	const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1909	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1910	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C
1911	>	// D E F G H I J K L M
1912		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1913	<	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1915	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " # $ % &
1916	<	// \' ( ) * + , - . / 0 1 2 3 4
1913	>	const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1915	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1916	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
1917	>	// C D E F G H I J K L M
1918		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1919		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	<	// " \' 0 1 2 3 4
1920	>	// \" \' 0 1 2 3 4 5 6 7 ?
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1922	<	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
1924	<	// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! # $ % & \'
1925	<	// ( ) * + , - . / 0 1 2 3 4
1922	>	const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1924	>	// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1925	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D
1926	>	// E F G H I J K L M
1927		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1928		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1929	<	// \' 0 1 2 3 4
1929	>	// \' 0 1 2 3 4 5 6 7 8 9 A B C D E F
1930		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1931	<	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967288UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1932	<	// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
1933	<	// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! " #
1934	<	// $ % & ( ) * + , - . / 0 1 2 3 4
1931	>	const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1932	>	// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1933	>	// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1934	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
1935	>	// @ A B C D E F G H I J K L M
1936		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1937		const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1938	+	// D E
1939		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1940		const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1941	<	// + - 0 1 2 3 4
1941	>	// + - 0 1 2 3 4 5 6 7 8 9
1942		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1943		const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1944	+	// D F
1945		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1946		const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1947	<	// 0 1 2 3 4
1947	>	// 0 1 2 3 4 5 6 7 8 9 A B C D E F
1948		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1949		const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1950	<	// .
1950	>	// . D E F
1951		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1952

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

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

Diff Legend

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