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 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1969 by gezelter, Wed Feb 26 14:14:50 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "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["members"] = 14;
34	<	literals["position"] = 15;
35	<	literals["torsion"] = 10;
36	<	literals["component"] = 4;
37	<	literals["rigidBody"] = 11;
38	<	literals["zconstraint"] = 6;
39	<	literals["cutoffGroup"] = 12;
40	<	literals["bend"] = 9;
41	<	literals["orientation"] = 16;
42	<	literals["fragment"] = 13;
43	<	literals["bond"] = 8;
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"] = 19;
45	>	literals["orientation"] = 20;
46	>	literals["bend"] = 10;
47	>	literals["torsion"] = 11;
48	>	literals["atom"] = 8;
49		literals["molecule"] = 5;
50	<	literals["atom"] = 7;
50	>	literals["restraint"] = 7;
51	>	literals["inversion"] = 12;
52	>	literals["bond"] = 9;
53		}
54
55		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 473 | Line 480 | void MDLexer::mWhitespace(bool _createToken) {
480
481		}
482		if ( inputState->guessing==0 ) {
483	<	#line 218 "MDParser.g"
483	>	#line 255 "MDParser.g"
484		newline();
485	<	#line 479 "MDLexer.cpp"
485	>	#line 486 "MDLexer.cpp"
486		}
487		break;
488		}
#	Line 501 | Line 508 | void MDLexer::mWhitespace(bool _createToken) {
508
509		}
510		if ( inputState->guessing==0 ) {
511	<	#line 223 "MDParser.g"
511	>	#line 260 "MDParser.g"
512		printf("CPP_parser.g continuation line detected\n");
513		deferredNewline();
514	<	#line 508 "MDLexer.cpp"
514	>	#line 515 "MDLexer.cpp"
515		}
516		break;
517		}
#	Line 515 | Line 522 | void MDLexer::mWhitespace(bool _createToken) {
522		}
523		}
524		if ( inputState->guessing==0 ) {
525	<	#line 226 "MDParser.g"
525	>	#line 263 "MDParser.g"
526		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
527	<	#line 521 "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 541 | 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 233 "MDParser.g"
551	>	#line 270 "MDParser.g"
552		deferredNewline();
553	<	#line 547 "MDLexer.cpp"
553	>	#line 554 "MDLexer.cpp"
554		}
555		}
556		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 559 | void MDLexer::mComment(bool _createToken) {
559		}
560		}
561		else {
562	<	goto _loop78;
562	>	goto _loop96;
563		}
564
565		}
566	<	_loop78:;
566	>	_loop96:;
567		} // ( ... )*
568		match("*/");
569		if ( inputState->guessing==0 ) {
570	<	#line 236 "MDParser.g"
570	>	#line 273 "MDParser.g"
571		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
572	<	#line 566 "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 614 | Line 621 | void MDLexer::mCPPComment(bool _createToken) {
621		}
622		}
623		else {
624	<	goto _loop82;
624	>	goto _loop100;
625		}
626
627		}
628	<	_loop82:;
628	>	_loop100:;
629		} // ( ... )*
630		mEndOfLine(false);
631		if ( inputState->guessing==0 ) {
632	<	#line 242 "MDParser.g"
632	>	#line 279 "MDParser.g"
633		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
634	<	#line 628 "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 642 | Line 649 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
649		match('#' /* charlit */ );
650		mLineDirective(false);
651		if ( inputState->guessing==0 ) {
652	<	#line 249 "MDParser.g"
652	>	#line 286 "MDParser.g"
653		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
654	<	#line 648 "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 662 | Line 669 | void MDLexer::mLineDirective(bool _createToken) {
669		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
670
671		if ( inputState->guessing==0 ) {
672	<	#line 255 "MDParser.g"
672	>	#line 292 "MDParser.g"
673
674		deferredLineCount = 0;
675
676	<	#line 670 "MDLexer.cpp"
676	>	#line 677 "MDLexer.cpp"
677		}
678		{
679		switch ( LA(1)) {
#	Line 688 | Line 695 | void MDLexer::mLineDirective(bool _createToken) {
695		}
696		}
697		{ // ( ... )+
698	<	int _cnt87=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 ( _cnt87>=1 ) { goto _loop87; } 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	<	_cnt87++;
707	>	_cnt105++;
708		}
709	<	_loop87:;
709	>	_loop105:;
710		}  // ( ... )+
711		mDecimal(true);
712		n=_returnToken;
713		if ( inputState->guessing==0 ) {
714	<	#line 260 "MDParser.g"
715	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
716	<	#line 710 "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 _cnt89=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 ( _cnt89>=1 ) { goto _loop89; } 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	<	_cnt89++;
728	>	_cnt107++;
729		}
730	<	_loop89:;
730	>	_loop107:;
731		}  // ( ... )+
732		{
733		mStringLiteral(true);
734		sl=_returnToken;
735		}
736		if ( inputState->guessing==0 ) {
737	<	#line 262 "MDParser.g"
737	>	#line 299 "MDParser.g"
738		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
739	<	#line 733 "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 _cnt93=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 ( _cnt93>=1 ) { goto _loop93; } 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	<	_cnt93++;
754	>	_cnt111++;
755		}
756	<	_loop93:;
756	>	_loop111:;
757		}  // ( ... )+
758		mDecimal(false);
759		}
760		else {
761	<	goto _loop94;
761	>	goto _loop112;
762		}
763
764		}
765	<	_loop94:;
765	>	_loop112:;
766		} // ( ... )*
767		mEndOfLine(false);
768		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 815 | void MDLexer::mDecimal(bool _createToken) {
815		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
816
817		{ // ( ... )+
818	<	int _cnt124=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 ( _cnt124>=1 ) { goto _loop124; } 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	<	_cnt124++;
827	>	_cnt142++;
828		}
829	<	_loop124:;
829	>	_loop142:;
830		}  // ( ... )+
831		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
832		_token = makeToken(_ttype);
#	Line 857 | Line 864 | void MDLexer::mStringLiteral(bool _createToken) {
864
865		}
866		if ( inputState->guessing==0 ) {
867	<	#line 302 "MDParser.g"
867	>	#line 339 "MDParser.g"
868		deferredNewline();
869	<	#line 863 "MDLexer.cpp"
869	>	#line 870 "MDLexer.cpp"
870		}
871		}
872		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 875 | void MDLexer::mStringLiteral(bool _createToken) {
875		}
876		}
877		else {
878	<	goto _loop104;
878	>	goto _loop122;
879		}
880
881		}
882	<	_loop104:;
882	>	_loop122:;
883		} // ( ... )*
884		match('\"' /* charlit */ );
885		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1039 | void MDLexer::mEscape(bool _createToken) {
1039		{
1040		match('x' /* charlit */ );
1041		{ // ( ... )+
1042	<	int _cnt115=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 1044 | Line 1051 | void MDLexer::mEscape(bool _createToken) {
1051		matchRange('A','F');
1052		}
1053		else {
1054	<	if ( _cnt115>=1 ) { goto _loop115; } 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	<	_cnt115++;
1057	>	_cnt133++;
1058		}
1059	<	_loop115:;
1059	>	_loop133:;
1060		}  // ( ... )+
1061		break;
1062		}
#	Line 1257 | Line 1264 | void MDLexer::mID(bool _createToken) {
1264		}
1265		default:
1266		{
1267	<	goto _loop120;
1267	>	goto _loop138;
1268		}
1269		}
1270		}
1271	<	_loop120:;
1271	>	_loop138:;
1272		} // ( ... )*
1273		_ttype = testLiteralsTable(_ttype);
1274		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1335 | 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 395 "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 1344 "MDLexer.cpp"
1350	>	#line 1351 "MDLexer.cpp"
1351
1352		{
1353		switch ( LA(1)) {
#	Line 1380 | Line 1387 | void MDLexer::mNUM_INT(bool _createToken) {
1387		{
1388		match('.' /* charlit */ );
1389		if ( inputState->guessing==0 ) {
1390	<	#line 402 "MDParser.g"
1390	>	#line 439 "MDParser.g"
1391		_ttype = DOT;
1392	<	#line 1386 "MDLexer.cpp"
1392	>	#line 1393 "MDLexer.cpp"
1393		}
1394		{
1395		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396		{ // ( ... )+
1397	<	int _cnt132=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 ( _cnt132>=1 ) { goto _loop132; } 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	<	_cnt132++;
1406	>	_cnt150++;
1407		}
1408	<	_loop132:;
1408	>	_loop150:;
1409		}  // ( ... )+
1410		{
1411	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1411	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1412		mEXPONENT(false);
1413		}
1414		else {
#	Line 1409 | Line 1416 | void MDLexer::mNUM_INT(bool _createToken) {
1416
1417		}
1418		{
1419	<	if ((_tokenSet_6.member(LA(1)))) {
1419	>	if ((_tokenSet_8.member(LA(1)))) {
1420		mFLOAT_SUFFIX(true);
1421		f1=_returnToken;
1422		if ( inputState->guessing==0 ) {
1423	<	#line 403 "MDParser.g"
1423	>	#line 440 "MDParser.g"
1424		t=f1;
1425	<	#line 1419 "MDLexer.cpp"
1425	>	#line 1426 "MDLexer.cpp"
1426		}
1427		}
1428		else {
#	Line 1423 | Line 1430 | void MDLexer::mNUM_INT(bool _createToken) {
1430
1431		}
1432		if ( inputState->guessing==0 ) {
1433	<	#line 404 "MDParser.g"
1433	>	#line 441 "MDParser.g"
1434
1435		if ( t &&
1436		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1434 | Line 1441 | void MDLexer::mNUM_INT(bool _createToken) {
1441		_ttype = NUM_DOUBLE; // assume double
1442		}
1443
1444	<	#line 1438 "MDLexer.cpp"
1444	>	#line 1445 "MDLexer.cpp"
1445		}
1446		}
1447		else {
#	Line 1460 | Line 1467 | void MDLexer::mNUM_INT(bool _createToken) {
1467		{
1468		match('0' /* charlit */ );
1469		if ( inputState->guessing==0 ) {
1470	<	#line 416 "MDParser.g"
1470	>	#line 453 "MDParser.g"
1471		isDecimal = true;
1472	<	#line 1466 "MDLexer.cpp"
1472	>	#line 1473 "MDLexer.cpp"
1473		}
1474		{
1475		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1485 | Line 1492 | void MDLexer::mNUM_INT(bool _createToken) {
1492		}
1493		}
1494		{ // ( ... )+
1495	<	int _cnt139=0;
1495	>	int _cnt157=0;
1496		for (;;) {
1497	<	if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1497	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1498		mHEX_DIGIT(false);
1499		}
1500		else {
1501	<	if ( _cnt139>=1 ) { goto _loop139; } 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	<	_cnt139++;
1504	>	_cnt157++;
1505		}
1506	<	_loop139:;
1506	>	_loop157:;
1507		}  // ( ... )+
1508		}
1509		else {
1510	<	bool synPredMatched144 = false;
1510	>	bool synPredMatched162 = false;
1511		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1512	<	int _m144 = mark();
1513	<	synPredMatched144 = true;
1512	>	int _m162 = mark();
1513	>	synPredMatched162 = true;
1514		inputState->guessing++;
1515		try {
1516		{
1517		{ // ( ... )+
1518	<	int _cnt142=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 ( _cnt142>=1 ) { goto _loop142; } 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	<	_cnt142++;
1527	>	_cnt160++;
1528		}
1529	<	_loop142:;
1529	>	_loop160:;
1530		}  // ( ... )+
1531		{
1532	<	switch ( LA(1)) {
1533	<	case 0x2e /* '.' */ :
1534	<	{
1532	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1533	>	mEXPONENT(false);
1534	>	}
1535	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1536		match('.' /* charlit */ );
1529	–	break;
1537		}
1538	<	case 0x45 /* 'E' */ :
1532	<	case 0x65 /* 'e' */ :
1533	<	{
1534	<	mEXPONENT(false);
1535	<	break;
1536	<	}
1537	<	case 0x44 /* 'D' */ :
1538	<	case 0x46 /* 'F' */ :
1539	<	case 0x64 /* 'd' */ :
1540	<	case 0x66 /* 'f' */ :
1541	<	{
1538	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1539		mFLOAT_SUFFIX(false);
1543	–	break;
1540		}
1541	<	default:
1546	<	{
1541	>	else {
1542		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1543		}
1544	+
1545		}
1546		}
1551	–	}
1547		}
1548		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1549	<	synPredMatched144 = false;
1549	>	synPredMatched162 = false;
1550		}
1551	<	rewind(_m144);
1551	>	rewind(_m162);
1552		inputState->guessing--;
1553		}
1554	<	if ( synPredMatched144 ) {
1554	>	if ( synPredMatched162 ) {
1555		{ // ( ... )+
1556	<	int _cnt146=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 ( _cnt146>=1 ) { goto _loop146; } 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	<	_cnt146++;
1565	>	_cnt164++;
1566		}
1567	<	_loop146:;
1567	>	_loop164:;
1568		}  // ( ... )+
1569		}
1570		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1571		{ // ( ... )+
1572	<	int _cnt148=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 ( _cnt148>=1 ) { goto _loop148; } 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	<	_cnt148++;
1581	>	_cnt166++;
1582		}
1583	<	_loop148:;
1583	>	_loop166:;
1584		}  // ( ... )+
1585		}
1586		else {
#	Line 1613 | Line 1608 | void MDLexer::mNUM_INT(bool _createToken) {
1608		matchRange('0','9');
1609		}
1610		else {
1611	<	goto _loop151;
1611	>	goto _loop169;
1612		}
1613
1614		}
1615	<	_loop151:;
1615	>	_loop169:;
1616		} // ( ... )*
1617		if ( inputState->guessing==0 ) {
1618	<	#line 433 "MDParser.g"
1618	>	#line 470 "MDParser.g"
1619		isDecimal=true;
1620	<	#line 1626 "MDLexer.cpp"
1620	>	#line 1621 "MDLexer.cpp"
1621		}
1622		break;
1623		}
#	Line 1653 | Line 1648 | void MDLexer::mNUM_INT(bool _createToken) {
1648		}
1649		}
1650		if ( inputState->guessing==0 ) {
1651	<	#line 435 "MDParser.g"
1651	>	#line 472 "MDParser.g"
1652		_ttype = NUM_LONG;
1653	<	#line 1659 "MDLexer.cpp"
1653	>	#line 1654 "MDLexer.cpp"
1654		}
1655		}
1656	<	else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1656	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1657		{
1658	<	switch ( LA(1)) {
1659	<	case 0x2e /* '.' */ :
1660	<	{
1658	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1659	>	mEXPONENT(false);
1660	>	{
1661	>	if ((_tokenSet_8.member(LA(1)))) {
1662	>	mFLOAT_SUFFIX(true);
1663	>	f3=_returnToken;
1664	>	if ( inputState->guessing==0 ) {
1665	>	#line 477 "MDParser.g"
1666	>	t=f3;
1667	>	#line 1668 "MDLexer.cpp"
1668	>	}
1669	>	}
1670	>	else {
1671	>	}
1672	>
1673	>	}
1674	>	}
1675	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1676		match('.' /* charlit */ );
1677		{ // ( ... )*
1678		for (;;) {
#	Line 1670 | Line 1680 | void MDLexer::mNUM_INT(bool _createToken) {
1680		matchRange('0','9');
1681		}
1682		else {
1683	<	goto _loop156;
1683	>	goto _loop174;
1684		}
1685
1686		}
1687	<	_loop156:;
1687	>	_loop174:;
1688		} // ( ... )*
1689		{
1690	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1690	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1691		mEXPONENT(false);
1692		}
1693		else {
#	Line 1685 | Line 1695 | void MDLexer::mNUM_INT(bool _createToken) {
1695
1696		}
1697		{
1698	<	if ((_tokenSet_6.member(LA(1)))) {
1698	>	if ((_tokenSet_8.member(LA(1)))) {
1699		mFLOAT_SUFFIX(true);
1700		f2=_returnToken;
1701		if ( inputState->guessing==0 ) {
1702	<	#line 439 "MDParser.g"
1702	>	#line 476 "MDParser.g"
1703		t=f2;
1704	<	#line 1695 "MDLexer.cpp"
1704	>	#line 1705 "MDLexer.cpp"
1705		}
1706		}
1707		else {
1708		}
1709
1710		}
1701	–	break;
1711		}
1712	<	case 0x45 /* 'E' */ :
1704	<	case 0x65 /* 'e' */ :
1705	<	{
1706	<	mEXPONENT(false);
1707	<	{
1708	<	if ((_tokenSet_6.member(LA(1)))) {
1709	<	mFLOAT_SUFFIX(true);
1710	<	f3=_returnToken;
1711	<	if ( inputState->guessing==0 ) {
1712	<	#line 440 "MDParser.g"
1713	<	t=f3;
1714	<	#line 1715 "MDLexer.cpp"
1715	<	}
1716	<	}
1717	<	else {
1718	<	}
1719	<
1720	<	}
1721	<	break;
1722	<	}
1723	<	case 0x44 /* 'D' */ :
1724	<	case 0x46 /* 'F' */ :
1725	<	case 0x64 /* 'd' */ :
1726	<	case 0x66 /* 'f' */ :
1727	<	{
1712	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1713		mFLOAT_SUFFIX(true);
1714		f4=_returnToken;
1715		if ( inputState->guessing==0 ) {
1716	<	#line 441 "MDParser.g"
1716	>	#line 478 "MDParser.g"
1717		t=f4;
1718	<	#line 1734 "MDLexer.cpp"
1718	>	#line 1719 "MDLexer.cpp"
1719		}
1735	–	break;
1720		}
1721	<	default:
1738	<	{
1721	>	else {
1722		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1723		}
1724	+
1725		}
1742	–	}
1726		if ( inputState->guessing==0 ) {
1727	<	#line 443 "MDParser.g"
1727	>	#line 480 "MDParser.g"
1728
1729		if ( t &&
1730		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1752 | Line 1735 | void MDLexer::mNUM_INT(bool _createToken) {
1735		_ttype = NUM_DOUBLE; // assume double
1736		}
1737
1738	<	#line 1756 "MDLexer.cpp"
1738	>	#line 1739 "MDLexer.cpp"
1739		}
1740		}
1741		else {
#	Line 1792 | Line 1775 | void MDLexer::mEXPONENT(bool _createToken) {
1775		match('E' /* charlit */ );
1776		break;
1777		}
1778	+	case 0x64 /* 'd' */ :
1779	+	{
1780	+	match('d' /* charlit */ );
1781	+	break;
1782	+	}
1783	+	case 0x44 /* 'D' */ :
1784	+	{
1785	+	match('D' /* charlit */ );
1786	+	break;
1787	+	}
1788		default:
1789		{
1790		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 1830 | Line 1823 | void MDLexer::mEXPONENT(bool _createToken) {
1823		}
1824		}
1825		{ // ( ... )+
1826	<	int _cnt164=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 ( _cnt164>=1 ) { goto _loop164; } 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	<	_cnt164++;
1835	>	_cnt182++;
1836		}
1837	<	_loop164:;
1837	>	_loop182:;
1838		}  // ( ... )+
1839		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1840		_token = makeToken(_ttype);
#	Line 1894 | 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
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
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
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
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
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
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, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
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, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916	<	// 0 1 2
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 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, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	<	// .
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 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	+	// .
1925	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1926

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 814 by tim, Fri Dec 16 02:57:00 2005 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