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 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1969 by gezelter, Wed Feb 26 14:14:50 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.7 (20090623): "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["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["center"] = 17;
43		literals["members"] = 16;
44	<	literals["position"] = 18;
44	>	literals["position"] = 19;
45	>	literals["orientation"] = 20;
46	>	literals["bend"] = 10;
47		literals["torsion"] = 11;
48	<	literals["component"] = 4;
48	>	literals["atom"] = 8;
49	>	literals["molecule"] = 5;
50		literals["restraint"] = 7;
38	–	literals["rigidBody"] = 13;
39	–	literals["center"] = 17;
51		literals["inversion"] = 12;
41	–	literals["zconstraint"] = 6;
42	–	literals["cutoffGroup"] = 14;
43	–	literals["bend"] = 10;
44	–	literals["orientation"] = 19;
45	–	literals["fragment"] = 15;
52		literals["bond"] = 9;
47	–	literals["molecule"] = 5;
48	–	literals["atom"] = 8;
53		}
54
55		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 476 | Line 480 | void MDLexer::mWhitespace(bool _createToken) {
480
481		}
482		if ( inputState->guessing==0 ) {
483	<	#line 233 "MDParser.g"
483	>	#line 255 "MDParser.g"
484		newline();
485	<	#line 482 "MDLexer.cpp"
485	>	#line 486 "MDLexer.cpp"
486		}
487		break;
488		}
#	Line 504 | Line 508 | void MDLexer::mWhitespace(bool _createToken) {
508
509		}
510		if ( inputState->guessing==0 ) {
511	<	#line 238 "MDParser.g"
511	>	#line 260 "MDParser.g"
512		printf("CPP_parser.g continuation line detected\n");
513		deferredNewline();
514	<	#line 511 "MDLexer.cpp"
514	>	#line 515 "MDLexer.cpp"
515		}
516		break;
517		}
#	Line 518 | Line 522 | void MDLexer::mWhitespace(bool _createToken) {
522		}
523		}
524		if ( inputState->guessing==0 ) {
525	<	#line 241 "MDParser.g"
525	>	#line 263 "MDParser.g"
526		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
527	<	#line 524 "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 544 | Line 548 | void MDLexer::mComment(bool _createToken) {
548		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
549		mEndOfLine(false);
550		if ( inputState->guessing==0 ) {
551	<	#line 248 "MDParser.g"
551	>	#line 270 "MDParser.g"
552		deferredNewline();
553	<	#line 550 "MDLexer.cpp"
553	>	#line 554 "MDLexer.cpp"
554		}
555		}
556		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 555 | Line 559 | void MDLexer::mComment(bool _createToken) {
559		}
560		}
561		else {
562	<	goto _loop86;
562	>	goto _loop96;
563		}
564
565		}
566	<	_loop86:;
566	>	_loop96:;
567		} // ( ... )*
568		match("*/");
569		if ( inputState->guessing==0 ) {
570	<	#line 251 "MDParser.g"
570	>	#line 273 "MDParser.g"
571		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
572	<	#line 569 "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 617 | Line 621 | void MDLexer::mCPPComment(bool _createToken) {
621		}
622		}
623		else {
624	<	goto _loop90;
624	>	goto _loop100;
625		}
626
627		}
628	<	_loop90:;
628	>	_loop100:;
629		} // ( ... )*
630		mEndOfLine(false);
631		if ( inputState->guessing==0 ) {
632	<	#line 257 "MDParser.g"
632	>	#line 279 "MDParser.g"
633		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
634	<	#line 631 "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 645 | Line 649 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
649		match('#' /* charlit */ );
650		mLineDirective(false);
651		if ( inputState->guessing==0 ) {
652	<	#line 264 "MDParser.g"
652	>	#line 286 "MDParser.g"
653		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
654	<	#line 651 "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 665 | Line 669 | void MDLexer::mLineDirective(bool _createToken) {
669		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
670
671		if ( inputState->guessing==0 ) {
672	<	#line 270 "MDParser.g"
672	>	#line 292 "MDParser.g"
673
674		deferredLineCount = 0;
675
676	<	#line 673 "MDLexer.cpp"
676	>	#line 677 "MDLexer.cpp"
677		}
678		{
679		switch ( LA(1)) {
#	Line 691 | Line 695 | void MDLexer::mLineDirective(bool _createToken) {
695		}
696		}
697		{ // ( ... )+
698	<	int _cnt95=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 ( _cnt95>=1 ) { goto _loop95; } 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	<	_cnt95++;
707	>	_cnt105++;
708		}
709	<	_loop95:;
709	>	_loop105:;
710		}  // ( ... )+
711		mDecimal(true);
712		n=_returnToken;
713		if ( inputState->guessing==0 ) {
714	<	#line 275 "MDParser.g"
714	>	#line 297 "MDParser.g"
715		setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
716	<	#line 713 "MDLexer.cpp"
716	>	#line 717 "MDLexer.cpp"
717		}
718		{ // ( ... )+
719	<	int _cnt97=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 ( _cnt97>=1 ) { goto _loop97; } 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	<	_cnt97++;
728	>	_cnt107++;
729		}
730	<	_loop97:;
730	>	_loop107:;
731		}  // ( ... )+
732		{
733		mStringLiteral(true);
734		sl=_returnToken;
735		}
736		if ( inputState->guessing==0 ) {
737	<	#line 277 "MDParser.g"
737	>	#line 299 "MDParser.g"
738		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
739	<	#line 736 "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 _cnt101=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 ( _cnt101>=1 ) { goto _loop101; } 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	<	_cnt101++;
754	>	_cnt111++;
755		}
756	<	_loop101:;
756	>	_loop111:;
757		}  // ( ... )+
758		mDecimal(false);
759		}
760		else {
761	<	goto _loop102;
761	>	goto _loop112;
762		}
763
764		}
765	<	_loop102:;
765	>	_loop112:;
766		} // ( ... )*
767		mEndOfLine(false);
768		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 811 | Line 815 | void MDLexer::mDecimal(bool _createToken) {
815		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
816
817		{ // ( ... )+
818	<	int _cnt132=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 ( _cnt132>=1 ) { goto _loop132; } 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	<	_cnt132++;
827	>	_cnt142++;
828		}
829	<	_loop132:;
829	>	_loop142:;
830		}  // ( ... )+
831		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
832		_token = makeToken(_ttype);
#	Line 860 | Line 864 | void MDLexer::mStringLiteral(bool _createToken) {
864
865		}
866		if ( inputState->guessing==0 ) {
867	<	#line 317 "MDParser.g"
867	>	#line 339 "MDParser.g"
868		deferredNewline();
869	<	#line 866 "MDLexer.cpp"
869	>	#line 870 "MDLexer.cpp"
870		}
871		}
872		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 871 | Line 875 | void MDLexer::mStringLiteral(bool _createToken) {
875		}
876		}
877		else {
878	<	goto _loop112;
878	>	goto _loop122;
879		}
880
881		}
882	<	_loop112:;
882	>	_loop122:;
883		} // ( ... )*
884		match('\"' /* charlit */ );
885		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1035 | Line 1039 | void MDLexer::mEscape(bool _createToken) {
1039		{
1040		match('x' /* charlit */ );
1041		{ // ( ... )+
1042	<	int _cnt123=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 1047 | Line 1051 | void MDLexer::mEscape(bool _createToken) {
1051		matchRange('A','F');
1052		}
1053		else {
1054	<	if ( _cnt123>=1 ) { goto _loop123; } 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	<	_cnt123++;
1057	>	_cnt133++;
1058		}
1059	<	_loop123:;
1059	>	_loop133:;
1060		}  // ( ... )+
1061		break;
1062		}
#	Line 1260 | Line 1264 | void MDLexer::mID(bool _createToken) {
1264		}
1265		default:
1266		{
1267	<	goto _loop128;
1267	>	goto _loop138;
1268		}
1269		}
1270		}
1271	<	_loop128:;
1271	>	_loop138:;
1272		} // ( ... )*
1273		_ttype = testLiteralsTable(_ttype);
1274		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1338 | Line 1342 | void MDLexer::mNUM_INT(bool _createToken) {
1342		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1343		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1344		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1345	<	#line 410 "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 1347 "MDLexer.cpp"
1350	>	#line 1351 "MDLexer.cpp"
1351
1352		{
1353		switch ( LA(1)) {
#	Line 1383 | Line 1387 | void MDLexer::mNUM_INT(bool _createToken) {
1387		{
1388		match('.' /* charlit */ );
1389		if ( inputState->guessing==0 ) {
1390	<	#line 417 "MDParser.g"
1390	>	#line 439 "MDParser.g"
1391		_ttype = DOT;
1392	<	#line 1389 "MDLexer.cpp"
1392	>	#line 1393 "MDLexer.cpp"
1393		}
1394		{
1395		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396		{ // ( ... )+
1397	<	int _cnt140=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 ( _cnt140>=1 ) { goto _loop140; } 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	<	_cnt140++;
1406	>	_cnt150++;
1407		}
1408	<	_loop140:;
1408	>	_loop150:;
1409		}  // ( ... )+
1410		{
1411		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1416 | Line 1420 | void MDLexer::mNUM_INT(bool _createToken) {
1420		mFLOAT_SUFFIX(true);
1421		f1=_returnToken;
1422		if ( inputState->guessing==0 ) {
1423	<	#line 418 "MDParser.g"
1423	>	#line 440 "MDParser.g"
1424		t=f1;
1425	<	#line 1422 "MDLexer.cpp"
1425	>	#line 1426 "MDLexer.cpp"
1426		}
1427		}
1428		else {
#	Line 1426 | Line 1430 | void MDLexer::mNUM_INT(bool _createToken) {
1430
1431		}
1432		if ( inputState->guessing==0 ) {
1433	<	#line 419 "MDParser.g"
1433	>	#line 441 "MDParser.g"
1434
1435		if ( t &&
1436		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1437 | Line 1441 | void MDLexer::mNUM_INT(bool _createToken) {
1441		_ttype = NUM_DOUBLE; // assume double
1442		}
1443
1444	<	#line 1441 "MDLexer.cpp"
1444	>	#line 1445 "MDLexer.cpp"
1445		}
1446		}
1447		else {
#	Line 1463 | Line 1467 | void MDLexer::mNUM_INT(bool _createToken) {
1467		{
1468		match('0' /* charlit */ );
1469		if ( inputState->guessing==0 ) {
1470	<	#line 431 "MDParser.g"
1470	>	#line 453 "MDParser.g"
1471		isDecimal = true;
1472	<	#line 1469 "MDLexer.cpp"
1472	>	#line 1473 "MDLexer.cpp"
1473		}
1474		{
1475		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1488 | Line 1492 | void MDLexer::mNUM_INT(bool _createToken) {
1492		}
1493		}
1494		{ // ( ... )+
1495	<	int _cnt147=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 ( _cnt147>=1 ) { goto _loop147; } 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	<	_cnt147++;
1504	>	_cnt157++;
1505		}
1506	<	_loop147:;
1506	>	_loop157:;
1507		}  // ( ... )+
1508		}
1509		else {
1510	<	bool synPredMatched152 = false;
1510	>	bool synPredMatched162 = false;
1511		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1512	<	int _m152 = mark();
1513	<	synPredMatched152 = true;
1512	>	int _m162 = mark();
1513	>	synPredMatched162 = true;
1514		inputState->guessing++;
1515		try {
1516		{
1517		{ // ( ... )+
1518	<	int _cnt150=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 ( _cnt150>=1 ) { goto _loop150; } 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	<	_cnt150++;
1527	>	_cnt160++;
1528		}
1529	<	_loop150:;
1529	>	_loop160:;
1530		}  // ( ... )+
1531		{
1532		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1542 | Line 1546 | void MDLexer::mNUM_INT(bool _createToken) {
1546		}
1547		}
1548		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1549	<	synPredMatched152 = false;
1549	>	synPredMatched162 = false;
1550		}
1551	<	rewind(_m152);
1551	>	rewind(_m162);
1552		inputState->guessing--;
1553		}
1554	<	if ( synPredMatched152 ) {
1554	>	if ( synPredMatched162 ) {
1555		{ // ( ... )+
1556	<	int _cnt154=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 ( _cnt154>=1 ) { goto _loop154; } 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	<	_cnt154++;
1565	>	_cnt164++;
1566		}
1567	<	_loop154:;
1567	>	_loop164:;
1568		}  // ( ... )+
1569		}
1570		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1571		{ // ( ... )+
1572	<	int _cnt156=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 ( _cnt156>=1 ) { goto _loop156; } 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	<	_cnt156++;
1581	>	_cnt166++;
1582		}
1583	<	_loop156:;
1583	>	_loop166:;
1584		}  // ( ... )+
1585		}
1586		else {
#	Line 1604 | Line 1608 | void MDLexer::mNUM_INT(bool _createToken) {
1608		matchRange('0','9');
1609		}
1610		else {
1611	<	goto _loop159;
1611	>	goto _loop169;
1612		}
1613
1614		}
1615	<	_loop159:;
1615	>	_loop169:;
1616		} // ( ... )*
1617		if ( inputState->guessing==0 ) {
1618	<	#line 448 "MDParser.g"
1618	>	#line 470 "MDParser.g"
1619		isDecimal=true;
1620	<	#line 1617 "MDLexer.cpp"
1620	>	#line 1621 "MDLexer.cpp"
1621		}
1622		break;
1623		}
#	Line 1644 | Line 1648 | void MDLexer::mNUM_INT(bool _createToken) {
1648		}
1649		}
1650		if ( inputState->guessing==0 ) {
1651	<	#line 450 "MDParser.g"
1651	>	#line 472 "MDParser.g"
1652		_ttype = NUM_LONG;
1653	<	#line 1650 "MDLexer.cpp"
1653	>	#line 1654 "MDLexer.cpp"
1654		}
1655		}
1656		else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
#	Line 1658 | Line 1662 | void MDLexer::mNUM_INT(bool _createToken) {
1662		mFLOAT_SUFFIX(true);
1663		f3=_returnToken;
1664		if ( inputState->guessing==0 ) {
1665	<	#line 455 "MDParser.g"
1665	>	#line 477 "MDParser.g"
1666		t=f3;
1667	<	#line 1664 "MDLexer.cpp"
1667	>	#line 1668 "MDLexer.cpp"
1668		}
1669		}
1670		else {
#	Line 1676 | Line 1680 | void MDLexer::mNUM_INT(bool _createToken) {
1680		matchRange('0','9');
1681		}
1682		else {
1683	<	goto _loop164;
1683	>	goto _loop174;
1684		}
1685
1686		}
1687	<	_loop164:;
1687	>	_loop174:;
1688		} // ( ... )*
1689		{
1690		if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
#	Line 1695 | Line 1699 | void MDLexer::mNUM_INT(bool _createToken) {
1699		mFLOAT_SUFFIX(true);
1700		f2=_returnToken;
1701		if ( inputState->guessing==0 ) {
1702	<	#line 454 "MDParser.g"
1702	>	#line 476 "MDParser.g"
1703		t=f2;
1704	<	#line 1701 "MDLexer.cpp"
1704	>	#line 1705 "MDLexer.cpp"
1705		}
1706		}
1707		else {
#	Line 1709 | Line 1713 | void MDLexer::mNUM_INT(bool _createToken) {
1713		mFLOAT_SUFFIX(true);
1714		f4=_returnToken;
1715		if ( inputState->guessing==0 ) {
1716	<	#line 456 "MDParser.g"
1716	>	#line 478 "MDParser.g"
1717		t=f4;
1718	<	#line 1715 "MDLexer.cpp"
1718	>	#line 1719 "MDLexer.cpp"
1719		}
1720		}
1721		else {
#	Line 1720 | Line 1724 | void MDLexer::mNUM_INT(bool _createToken) {
1724
1725		}
1726		if ( inputState->guessing==0 ) {
1727	<	#line 458 "MDParser.g"
1727	>	#line 480 "MDParser.g"
1728
1729		if ( t &&
1730		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1731 | Line 1735 | void MDLexer::mNUM_INT(bool _createToken) {
1735		_ttype = NUM_DOUBLE; // assume double
1736		}
1737
1738	<	#line 1735 "MDLexer.cpp"
1738	>	#line 1739 "MDLexer.cpp"
1739		}
1740		}
1741		else {
#	Line 1819 | Line 1823 | void MDLexer::mEXPONENT(bool _createToken) {
1823		}
1824		}
1825		{ // ( ... )+
1826	<	int _cnt172=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 ( _cnt172>=1 ) { goto _loop172; } 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	<	_cnt172++;
1835	>	_cnt182++;
1836		}
1837	<	_loop172:;
1837	>	_loop182:;
1838		}  // ( ... )+
1839		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1840		_token = makeToken(_ttype);
#	Line 1883 | Line 1887 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 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
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_[] = { 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
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 5
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_[] = { 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
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 5
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_[] = { 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
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 5
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 5
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 1390 by gezelter, Wed Nov 25 20:02:06 2009 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