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

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20131114): "MDParser.g" -> "MDLexer.cpp"$ */
2		#include "MDLexer.hpp"
3		#include <antlr/CharBuffer.hpp>
4		#include <antlr/TokenStreamException.hpp>
#	Line 30 | Line 30 | void MDLexer::initLiterals()
30
31		void MDLexer::initLiterals()
32		{
33	<	literals["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"] = 23;
34	>	literals["satellites"] = 20;
35	>	literals["cutoffGroup"] = 14;
36	>	literals["RNEMD"] = 24;
37	>	literals["constraint"] = 15;
38	>	literals["distance"] = 16;
39	>	literals["rigidBody"] = 13;
40	>	literals["fragment"] = 17;
41	>	literals["zconstraint"] = 6;
42	>	literals["minimizer"] = 25;
43	>	literals["component"] = 4;
44	>	literals["center"] = 19;
45	>	literals["members"] = 18;
46	>	literals["position"] = 21;
47	>	literals["orientation"] = 22;
48	>	literals["bend"] = 10;
49	>	literals["torsion"] = 11;
50	>	literals["atom"] = 8;
51		literals["molecule"] = 5;
52	<	literals["atom"] = 7;
52	>	literals["restraint"] = 7;
53	>	literals["inversion"] = 12;
54	>	literals["bond"] = 9;
55		}
56
57		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 473 | Line 482 | void MDLexer::mWhitespace(bool _createToken) {
482
483		}
484		if ( inputState->guessing==0 ) {
485	<	#line 218 "MDParser.g"
485	>	#line 274 "MDParser.g"
486		newline();
487	<	#line 479 "MDLexer.cpp"
487	>	#line 488 "MDLexer.cpp"
488		}
489		break;
490		}
#	Line 501 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510
511		}
512		if ( inputState->guessing==0 ) {
513	<	#line 223 "MDParser.g"
513	>	#line 279 "MDParser.g"
514		printf("CPP_parser.g continuation line detected\n");
515		deferredNewline();
516	<	#line 508 "MDLexer.cpp"
516	>	#line 517 "MDLexer.cpp"
517		}
518		break;
519		}
#	Line 515 | Line 524 | void MDLexer::mWhitespace(bool _createToken) {
524		}
525		}
526		if ( inputState->guessing==0 ) {
527	<	#line 226 "MDParser.g"
527	>	#line 282 "MDParser.g"
528		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
529	<	#line 521 "MDLexer.cpp"
529	>	#line 530 "MDLexer.cpp"
530		}
531		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
532		_token = makeToken(_ttype);
#	Line 541 | Line 550 | void MDLexer::mComment(bool _createToken) {
550		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
551		mEndOfLine(false);
552		if ( inputState->guessing==0 ) {
553	<	#line 233 "MDParser.g"
553	>	#line 289 "MDParser.g"
554		deferredNewline();
555	<	#line 547 "MDLexer.cpp"
555	>	#line 556 "MDLexer.cpp"
556		}
557		}
558		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 561 | void MDLexer::mComment(bool _createToken) {
561		}
562		}
563		else {
564	<	goto _loop78;
564	>	goto _loop101;
565		}
566
567		}
568	<	_loop78:;
568	>	_loop101:;
569		} // ( ... )*
570		match("*/");
571		if ( inputState->guessing==0 ) {
572	<	#line 236 "MDParser.g"
572	>	#line 292 "MDParser.g"
573		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
574	<	#line 566 "MDLexer.cpp"
574	>	#line 575 "MDLexer.cpp"
575		}
576		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
577		_token = makeToken(_ttype);
#	Line 614 | Line 623 | void MDLexer::mCPPComment(bool _createToken) {
623		}
624		}
625		else {
626	<	goto _loop82;
626	>	goto _loop105;
627		}
628
629		}
630	<	_loop82:;
630	>	_loop105:;
631		} // ( ... )*
632		mEndOfLine(false);
633		if ( inputState->guessing==0 ) {
634	<	#line 242 "MDParser.g"
634	>	#line 298 "MDParser.g"
635		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
636	<	#line 628 "MDLexer.cpp"
636	>	#line 637 "MDLexer.cpp"
637		}
638		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
639		_token = makeToken(_ttype);
#	Line 642 | Line 651 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
651		match('#' /* charlit */ );
652		mLineDirective(false);
653		if ( inputState->guessing==0 ) {
654	<	#line 249 "MDParser.g"
654	>	#line 305 "MDParser.g"
655		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
656	<	#line 648 "MDLexer.cpp"
656	>	#line 657 "MDLexer.cpp"
657		}
658		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
659		_token = makeToken(_ttype);
#	Line 662 | Line 671 | void MDLexer::mLineDirective(bool _createToken) {
671		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
672
673		if ( inputState->guessing==0 ) {
674	<	#line 255 "MDParser.g"
674	>	#line 311 "MDParser.g"
675
676		deferredLineCount = 0;
677
678	<	#line 670 "MDLexer.cpp"
678	>	#line 679 "MDLexer.cpp"
679		}
680		{
681		switch ( LA(1)) {
#	Line 688 | Line 697 | void MDLexer::mLineDirective(bool _createToken) {
697		}
698		}
699		{ // ( ... )+
700	<	int _cnt87=0;
700	>	int _cnt110=0;
701		for (;;) {
702		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
703		mSpace(false);
704		}
705		else {
706	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
706	>	if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
707		}
708
709	<	_cnt87++;
709	>	_cnt110++;
710		}
711	<	_loop87:;
711	>	_loop110:;
712		}  // ( ... )+
713		mDecimal(true);
714		n=_returnToken;
715		if ( inputState->guessing==0 ) {
716	<	#line 260 "MDParser.g"
717	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
718	<	#line 710 "MDLexer.cpp"
716	>	#line 316 "MDParser.g"
717	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
718	>	#line 719 "MDLexer.cpp"
719		}
720		{ // ( ... )+
721	<	int _cnt89=0;
721	>	int _cnt112=0;
722		for (;;) {
723		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
724		mSpace(false);
725		}
726		else {
727	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
727	>	if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
728		}
729
730	<	_cnt89++;
730	>	_cnt112++;
731		}
732	<	_loop89:;
732	>	_loop112:;
733		}  // ( ... )+
734		{
735		mStringLiteral(true);
736		sl=_returnToken;
737		}
738		if ( inputState->guessing==0 ) {
739	<	#line 262 "MDParser.g"
739	>	#line 318 "MDParser.g"
740		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
741	<	#line 733 "MDLexer.cpp"
741	>	#line 742 "MDLexer.cpp"
742		}
743		{ // ( ... )*
744		for (;;) {
745		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746		{ // ( ... )+
747	<	int _cnt93=0;
747	>	int _cnt116=0;
748		for (;;) {
749		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
750		mSpace(false);
751		}
752		else {
753	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
753	>	if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
754		}
755
756	<	_cnt93++;
756	>	_cnt116++;
757		}
758	<	_loop93:;
758	>	_loop116:;
759		}  // ( ... )+
760		mDecimal(false);
761		}
762		else {
763	<	goto _loop94;
763	>	goto _loop117;
764		}
765
766		}
767	<	_loop94:;
767	>	_loop117:;
768		} // ( ... )*
769		mEndOfLine(false);
770		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 817 | void MDLexer::mDecimal(bool _createToken) {
817		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
818
819		{ // ( ... )+
820	<	int _cnt124=0;
820	>	int _cnt147=0;
821		for (;;) {
822		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
823		matchRange('0','9');
824		}
825		else {
826	<	if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
826	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
827		}
828
829	<	_cnt124++;
829	>	_cnt147++;
830		}
831	<	_loop124:;
831	>	_loop147:;
832		}  // ( ... )+
833		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
834		_token = makeToken(_ttype);
#	Line 857 | Line 866 | void MDLexer::mStringLiteral(bool _createToken) {
866
867		}
868		if ( inputState->guessing==0 ) {
869	<	#line 302 "MDParser.g"
869	>	#line 358 "MDParser.g"
870		deferredNewline();
871	<	#line 863 "MDLexer.cpp"
871	>	#line 872 "MDLexer.cpp"
872		}
873		}
874		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 877 | void MDLexer::mStringLiteral(bool _createToken) {
877		}
878		}
879		else {
880	<	goto _loop104;
880	>	goto _loop127;
881		}
882
883		}
884	<	_loop104:;
884	>	_loop127:;
885		} // ( ... )*
886		match('\"' /* charlit */ );
887		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1041 | void MDLexer::mEscape(bool _createToken) {
1041		{
1042		match('x' /* charlit */ );
1043		{ // ( ... )+
1044	<	int _cnt115=0;
1044	>	int _cnt138=0;
1045		for (;;) {
1046		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1047		mDigit(false);
#	Line 1044 | Line 1053 | void MDLexer::mEscape(bool _createToken) {
1053		matchRange('A','F');
1054		}
1055		else {
1056	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1056	>	if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1057		}
1058
1059	<	_cnt115++;
1059	>	_cnt138++;
1060		}
1061	<	_loop115:;
1061	>	_loop138:;
1062		}  // ( ... )+
1063		break;
1064		}
#	Line 1257 | Line 1266 | void MDLexer::mID(bool _createToken) {
1266		}
1267		default:
1268		{
1269	<	goto _loop120;
1269	>	goto _loop143;
1270		}
1271		}
1272		}
1273	<	_loop120:;
1273	>	_loop143:;
1274		} // ( ... )*
1275		_ttype = testLiteralsTable(_ttype);
1276		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1335 | Line 1344 | void MDLexer::mNUM_INT(bool _createToken) {
1344		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1345		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1346		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1347	<	#line 395 "MDParser.g"
1347	>	#line 451 "MDParser.g"
1348
1349		bool isDecimal = false;
1350		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1351
1352	<	#line 1344 "MDLexer.cpp"
1352	>	#line 1353 "MDLexer.cpp"
1353
1354		{
1355		switch ( LA(1)) {
#	Line 1380 | Line 1389 | void MDLexer::mNUM_INT(bool _createToken) {
1389		{
1390		match('.' /* charlit */ );
1391		if ( inputState->guessing==0 ) {
1392	<	#line 402 "MDParser.g"
1392	>	#line 458 "MDParser.g"
1393		_ttype = DOT;
1394	<	#line 1386 "MDLexer.cpp"
1394	>	#line 1395 "MDLexer.cpp"
1395		}
1396		{
1397		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398		{ // ( ... )+
1399	<	int _cnt132=0;
1399	>	int _cnt155=0;
1400		for (;;) {
1401		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1402		matchRange('0','9');
1403		}
1404		else {
1405	<	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1405	>	if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1406		}
1407
1408	<	_cnt132++;
1408	>	_cnt155++;
1409		}
1410	<	_loop132:;
1410	>	_loop155:;
1411		}  // ( ... )+
1412		{
1413	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1413	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1414		mEXPONENT(false);
1415		}
1416		else {
#	Line 1409 | Line 1418 | void MDLexer::mNUM_INT(bool _createToken) {
1418
1419		}
1420		{
1421	<	if ((_tokenSet_6.member(LA(1)))) {
1421	>	if ((_tokenSet_8.member(LA(1)))) {
1422		mFLOAT_SUFFIX(true);
1423		f1=_returnToken;
1424		if ( inputState->guessing==0 ) {
1425	<	#line 403 "MDParser.g"
1425	>	#line 459 "MDParser.g"
1426		t=f1;
1427	<	#line 1419 "MDLexer.cpp"
1427	>	#line 1428 "MDLexer.cpp"
1428		}
1429		}
1430		else {
#	Line 1423 | Line 1432 | void MDLexer::mNUM_INT(bool _createToken) {
1432
1433		}
1434		if ( inputState->guessing==0 ) {
1435	<	#line 404 "MDParser.g"
1435	>	#line 460 "MDParser.g"
1436
1437		if ( t &&
1438		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1434 | Line 1443 | void MDLexer::mNUM_INT(bool _createToken) {
1443		_ttype = NUM_DOUBLE; // assume double
1444		}
1445
1446	<	#line 1438 "MDLexer.cpp"
1446	>	#line 1447 "MDLexer.cpp"
1447		}
1448		}
1449		else {
#	Line 1460 | Line 1469 | void MDLexer::mNUM_INT(bool _createToken) {
1469		{
1470		match('0' /* charlit */ );
1471		if ( inputState->guessing==0 ) {
1472	<	#line 416 "MDParser.g"
1472	>	#line 472 "MDParser.g"
1473		isDecimal = true;
1474	<	#line 1466 "MDLexer.cpp"
1474	>	#line 1475 "MDLexer.cpp"
1475		}
1476		{
1477		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1485 | Line 1494 | void MDLexer::mNUM_INT(bool _createToken) {
1494		}
1495		}
1496		{ // ( ... )+
1497	<	int _cnt139=0;
1497	>	int _cnt162=0;
1498		for (;;) {
1499	<	if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1499	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1500		mHEX_DIGIT(false);
1501		}
1502		else {
1503	<	if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1503	>	if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1504		}
1505
1506	<	_cnt139++;
1506	>	_cnt162++;
1507		}
1508	<	_loop139:;
1508	>	_loop162:;
1509		}  // ( ... )+
1510		}
1511		else {
1512	<	bool synPredMatched144 = false;
1512	>	bool synPredMatched167 = false;
1513		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1514	<	int _m144 = mark();
1515	<	synPredMatched144 = true;
1514	>	int _m167 = mark();
1515	>	synPredMatched167 = true;
1516		inputState->guessing++;
1517		try {
1518		{
1519		{ // ( ... )+
1520	<	int _cnt142=0;
1520	>	int _cnt165=0;
1521		for (;;) {
1522		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1523		matchRange('0','9');
1524		}
1525		else {
1526	<	if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1526	>	if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1527		}
1528
1529	<	_cnt142++;
1529	>	_cnt165++;
1530		}
1531	<	_loop142:;
1531	>	_loop165:;
1532		}  // ( ... )+
1533		{
1534	<	switch ( LA(1)) {
1535	<	case 0x2e /* '.' */ :
1536	<	{
1534	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1535	>	mEXPONENT(false);
1536	>	}
1537	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1538		match('.' /* charlit */ );
1529	–	break;
1539		}
1540	<	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	<	{
1540	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1541		mFLOAT_SUFFIX(false);
1543	–	break;
1542		}
1543	<	default:
1546	<	{
1543	>	else {
1544		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1545		}
1546	+
1547		}
1548		}
1551	–	}
1549		}
1550		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1551	<	synPredMatched144 = false;
1551	>	synPredMatched167 = false;
1552		}
1553	<	rewind(_m144);
1553	>	rewind(_m167);
1554		inputState->guessing--;
1555		}
1556	<	if ( synPredMatched144 ) {
1556	>	if ( synPredMatched167 ) {
1557		{ // ( ... )+
1558	<	int _cnt146=0;
1558	>	int _cnt169=0;
1559		for (;;) {
1560		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1561		matchRange('0','9');
1562		}
1563		else {
1564	<	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1564	>	if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1565		}
1566
1567	<	_cnt146++;
1567	>	_cnt169++;
1568		}
1569	<	_loop146:;
1569	>	_loop169:;
1570		}  // ( ... )+
1571		}
1572		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1573		{ // ( ... )+
1574	<	int _cnt148=0;
1574	>	int _cnt171=0;
1575		for (;;) {
1576		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1577		matchRange('0','7');
1578		}
1579		else {
1580	<	if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1580	>	if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1581		}
1582
1583	<	_cnt148++;
1583	>	_cnt171++;
1584		}
1585	<	_loop148:;
1585	>	_loop171:;
1586		}  // ( ... )+
1587		}
1588		else {
#	Line 1613 | Line 1610 | void MDLexer::mNUM_INT(bool _createToken) {
1610		matchRange('0','9');
1611		}
1612		else {
1613	<	goto _loop151;
1613	>	goto _loop174;
1614		}
1615
1616		}
1617	<	_loop151:;
1617	>	_loop174:;
1618		} // ( ... )*
1619		if ( inputState->guessing==0 ) {
1620	<	#line 433 "MDParser.g"
1620	>	#line 489 "MDParser.g"
1621		isDecimal=true;
1622	<	#line 1626 "MDLexer.cpp"
1622	>	#line 1623 "MDLexer.cpp"
1623		}
1624		break;
1625		}
#	Line 1653 | Line 1650 | void MDLexer::mNUM_INT(bool _createToken) {
1650		}
1651		}
1652		if ( inputState->guessing==0 ) {
1653	<	#line 435 "MDParser.g"
1653	>	#line 491 "MDParser.g"
1654		_ttype = NUM_LONG;
1655	<	#line 1659 "MDLexer.cpp"
1655	>	#line 1656 "MDLexer.cpp"
1656		}
1657		}
1658	<	else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1658	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1659		{
1660	<	switch ( LA(1)) {
1661	<	case 0x2e /* '.' */ :
1662	<	{
1660	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1661	>	mEXPONENT(false);
1662	>	{
1663	>	if ((_tokenSet_8.member(LA(1)))) {
1664	>	mFLOAT_SUFFIX(true);
1665	>	f3=_returnToken;
1666	>	if ( inputState->guessing==0 ) {
1667	>	#line 496 "MDParser.g"
1668	>	t=f3;
1669	>	#line 1670 "MDLexer.cpp"
1670	>	}
1671	>	}
1672	>	else {
1673	>	}
1674	>
1675	>	}
1676	>	}
1677	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1678		match('.' /* charlit */ );
1679		{ // ( ... )*
1680		for (;;) {
#	Line 1670 | Line 1682 | void MDLexer::mNUM_INT(bool _createToken) {
1682		matchRange('0','9');
1683		}
1684		else {
1685	<	goto _loop156;
1685	>	goto _loop179;
1686		}
1687
1688		}
1689	<	_loop156:;
1689	>	_loop179:;
1690		} // ( ... )*
1691		{
1692	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1692	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1693		mEXPONENT(false);
1694		}
1695		else {
#	Line 1685 | Line 1697 | void MDLexer::mNUM_INT(bool _createToken) {
1697
1698		}
1699		{
1700	<	if ((_tokenSet_6.member(LA(1)))) {
1700	>	if ((_tokenSet_8.member(LA(1)))) {
1701		mFLOAT_SUFFIX(true);
1702		f2=_returnToken;
1703		if ( inputState->guessing==0 ) {
1704	<	#line 439 "MDParser.g"
1704	>	#line 495 "MDParser.g"
1705		t=f2;
1706	<	#line 1695 "MDLexer.cpp"
1706	>	#line 1707 "MDLexer.cpp"
1707		}
1708		}
1709		else {
1710		}
1711
1712		}
1701	–	break;
1713		}
1714	<	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	<	{
1714	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1715		mFLOAT_SUFFIX(true);
1716		f4=_returnToken;
1717		if ( inputState->guessing==0 ) {
1718	<	#line 441 "MDParser.g"
1718	>	#line 497 "MDParser.g"
1719		t=f4;
1720	<	#line 1734 "MDLexer.cpp"
1720	>	#line 1721 "MDLexer.cpp"
1721		}
1735	–	break;
1722		}
1723	<	default:
1738	<	{
1723	>	else {
1724		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1725		}
1726	+
1727		}
1742	–	}
1728		if ( inputState->guessing==0 ) {
1729	<	#line 443 "MDParser.g"
1729	>	#line 499 "MDParser.g"
1730
1731		if ( t &&
1732		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1752 | Line 1737 | void MDLexer::mNUM_INT(bool _createToken) {
1737		_ttype = NUM_DOUBLE; // assume double
1738		}
1739
1740	<	#line 1756 "MDLexer.cpp"
1740	>	#line 1741 "MDLexer.cpp"
1741		}
1742		}
1743		else {
#	Line 1792 | Line 1777 | void MDLexer::mEXPONENT(bool _createToken) {
1777		match('E' /* charlit */ );
1778		break;
1779		}
1780	+	case 0x64 /* 'd' */ :
1781	+	{
1782	+	match('d' /* charlit */ );
1783	+	break;
1784	+	}
1785	+	case 0x44 /* 'D' */ :
1786	+	{
1787	+	match('D' /* charlit */ );
1788	+	break;
1789	+	}
1790		default:
1791		{
1792		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 1830 | Line 1825 | void MDLexer::mEXPONENT(bool _createToken) {
1825		}
1826		}
1827		{ // ( ... )+
1828	<	int _cnt164=0;
1828	>	int _cnt187=0;
1829		for (;;) {
1830		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1831		matchRange('0','9');
1832		}
1833		else {
1834	<	if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1834	>	if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1835		}
1836
1837	<	_cnt164++;
1837	>	_cnt187++;
1838		}
1839	<	_loop164:;
1839	>	_loop187:;
1840		}  // ( ... )+
1841		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1842		_token = makeToken(_ttype);
#	Line 1894 | Line 1889 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1889		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1891		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1892	<	// \" # $ % & \' ( ) + , - . / 0 1 2
1892	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1893		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1894		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1897	<	// \" # $ % & \' ( ) * + , - . / 0 1 2
1897	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1899		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900	<	// \" \' 0 1 2
1900	>	// \" \' 0 1 2 3 4 5 6 7
1901		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1902		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1904		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1905	<	// # $ % & \' ( ) * + , - . / 0 1 2
1905	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1907		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908	<	// \' 0 1 2
1908	>	// \' 0 1 2 3 4 5 6 7 8 9
1909		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1910		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1912		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1913	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2
1913	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1914		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1915	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1917	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	<	// 0 1 2
1917	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918	>	// + - 0 1 2 3 4 5 6 7 8 9
1919		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1920	<	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	<	// .
1920	>	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1922	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	+	// 0 1 2 3 4 5 6 7 8 9
1924	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1925	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	+	// .
1927	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1928

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

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

Diff Legend

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