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 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20090623): "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;
33	>	literals["members"] = 16;
34	>	literals["position"] = 18;
35	>	literals["torsion"] = 11;
36		literals["component"] = 4;
37	<	literals["rigidBody"] = 11;
37	>	literals["restraint"] = 7;
38	>	literals["rigidBody"] = 13;
39	>	literals["center"] = 17;
40	>	literals["inversion"] = 12;
41		literals["zconstraint"] = 6;
42	<	literals["cutoffGroup"] = 12;
43	<	literals["bend"] = 9;
44	<	literals["orientation"] = 16;
45	<	literals["fragment"] = 13;
46	<	literals["bond"] = 8;
42	>	literals["cutoffGroup"] = 14;
43	>	literals["bend"] = 10;
44	>	literals["orientation"] = 19;
45	>	literals["fragment"] = 15;
46	>	literals["bond"] = 9;
47		literals["molecule"] = 5;
48	<	literals["atom"] = 7;
48	>	literals["atom"] = 8;
49		}
50
51		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 473 | Line 476 | void MDLexer::mWhitespace(bool _createToken) {
476
477		}
478		if ( inputState->guessing==0 ) {
479	<	#line 218 "MDParser.g"
479	>	#line 233 "MDParser.g"
480		newline();
481	<	#line 479 "MDLexer.cpp"
481	>	#line 482 "MDLexer.cpp"
482		}
483		break;
484		}
#	Line 501 | Line 504 | void MDLexer::mWhitespace(bool _createToken) {
504
505		}
506		if ( inputState->guessing==0 ) {
507	<	#line 223 "MDParser.g"
507	>	#line 238 "MDParser.g"
508		printf("CPP_parser.g continuation line detected\n");
509		deferredNewline();
510	<	#line 508 "MDLexer.cpp"
510	>	#line 511 "MDLexer.cpp"
511		}
512		break;
513		}
#	Line 515 | Line 518 | void MDLexer::mWhitespace(bool _createToken) {
518		}
519		}
520		if ( inputState->guessing==0 ) {
521	<	#line 226 "MDParser.g"
521	>	#line 241 "MDParser.g"
522		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
523	<	#line 521 "MDLexer.cpp"
523	>	#line 524 "MDLexer.cpp"
524		}
525		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
526		_token = makeToken(_ttype);
#	Line 541 | Line 544 | void MDLexer::mComment(bool _createToken) {
544		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
545		mEndOfLine(false);
546		if ( inputState->guessing==0 ) {
547	<	#line 233 "MDParser.g"
547	>	#line 248 "MDParser.g"
548		deferredNewline();
549	<	#line 547 "MDLexer.cpp"
549	>	#line 550 "MDLexer.cpp"
550		}
551		}
552		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 555 | void MDLexer::mComment(bool _createToken) {
555		}
556		}
557		else {
558	<	goto _loop78;
558	>	goto _loop86;
559		}
560
561		}
562	<	_loop78:;
562	>	_loop86:;
563		} // ( ... )*
564		match("*/");
565		if ( inputState->guessing==0 ) {
566	<	#line 236 "MDParser.g"
566	>	#line 251 "MDParser.g"
567		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
568	<	#line 566 "MDLexer.cpp"
568	>	#line 569 "MDLexer.cpp"
569		}
570		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
571		_token = makeToken(_ttype);
#	Line 614 | Line 617 | void MDLexer::mCPPComment(bool _createToken) {
617		}
618		}
619		else {
620	<	goto _loop82;
620	>	goto _loop90;
621		}
622
623		}
624	<	_loop82:;
624	>	_loop90:;
625		} // ( ... )*
626		mEndOfLine(false);
627		if ( inputState->guessing==0 ) {
628	<	#line 242 "MDParser.g"
628	>	#line 257 "MDParser.g"
629		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
630	<	#line 628 "MDLexer.cpp"
630	>	#line 631 "MDLexer.cpp"
631		}
632		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
633		_token = makeToken(_ttype);
#	Line 642 | Line 645 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
645		match('#' /* charlit */ );
646		mLineDirective(false);
647		if ( inputState->guessing==0 ) {
648	<	#line 249 "MDParser.g"
648	>	#line 264 "MDParser.g"
649		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
650	<	#line 648 "MDLexer.cpp"
650	>	#line 651 "MDLexer.cpp"
651		}
652		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
653		_token = makeToken(_ttype);
#	Line 662 | Line 665 | void MDLexer::mLineDirective(bool _createToken) {
665		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
666
667		if ( inputState->guessing==0 ) {
668	<	#line 255 "MDParser.g"
668	>	#line 270 "MDParser.g"
669
670		deferredLineCount = 0;
671
672	<	#line 670 "MDLexer.cpp"
672	>	#line 673 "MDLexer.cpp"
673		}
674		{
675		switch ( LA(1)) {
#	Line 688 | Line 691 | void MDLexer::mLineDirective(bool _createToken) {
691		}
692		}
693		{ // ( ... )+
694	<	int _cnt87=0;
694	>	int _cnt95=0;
695		for (;;) {
696		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
697		mSpace(false);
698		}
699		else {
700	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
700	>	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
701		}
702
703	<	_cnt87++;
703	>	_cnt95++;
704		}
705	<	_loop87:;
705	>	_loop95:;
706		}  // ( ... )+
707		mDecimal(true);
708		n=_returnToken;
709		if ( inputState->guessing==0 ) {
710	<	#line 260 "MDParser.g"
711	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
712	<	#line 710 "MDLexer.cpp"
710	>	#line 275 "MDParser.g"
711	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
712	>	#line 713 "MDLexer.cpp"
713		}
714		{ // ( ... )+
715	<	int _cnt89=0;
715	>	int _cnt97=0;
716		for (;;) {
717		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
718		mSpace(false);
719		}
720		else {
721	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
721	>	if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
722		}
723
724	<	_cnt89++;
724	>	_cnt97++;
725		}
726	<	_loop89:;
726	>	_loop97:;
727		}  // ( ... )+
728		{
729		mStringLiteral(true);
730		sl=_returnToken;
731		}
732		if ( inputState->guessing==0 ) {
733	<	#line 262 "MDParser.g"
733	>	#line 277 "MDParser.g"
734		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
735	<	#line 733 "MDLexer.cpp"
735	>	#line 736 "MDLexer.cpp"
736		}
737		{ // ( ... )*
738		for (;;) {
739		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
740		{ // ( ... )+
741	<	int _cnt93=0;
741	>	int _cnt101=0;
742		for (;;) {
743		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
744		mSpace(false);
745		}
746		else {
747	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
747	>	if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
748		}
749
750	<	_cnt93++;
750	>	_cnt101++;
751		}
752	<	_loop93:;
752	>	_loop101:;
753		}  // ( ... )+
754		mDecimal(false);
755		}
756		else {
757	<	goto _loop94;
757	>	goto _loop102;
758		}
759
760		}
761	<	_loop94:;
761	>	_loop102:;
762		} // ( ... )*
763		mEndOfLine(false);
764		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 811 | void MDLexer::mDecimal(bool _createToken) {
811		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
812
813		{ // ( ... )+
814	<	int _cnt124=0;
814	>	int _cnt132=0;
815		for (;;) {
816		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
817		matchRange('0','9');
818		}
819		else {
820	<	if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
820	>	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
821		}
822
823	<	_cnt124++;
823	>	_cnt132++;
824		}
825	<	_loop124:;
825	>	_loop132:;
826		}  // ( ... )+
827		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
828		_token = makeToken(_ttype);
#	Line 857 | Line 860 | void MDLexer::mStringLiteral(bool _createToken) {
860
861		}
862		if ( inputState->guessing==0 ) {
863	<	#line 302 "MDParser.g"
863	>	#line 317 "MDParser.g"
864		deferredNewline();
865	<	#line 863 "MDLexer.cpp"
865	>	#line 866 "MDLexer.cpp"
866		}
867		}
868		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 871 | void MDLexer::mStringLiteral(bool _createToken) {
871		}
872		}
873		else {
874	<	goto _loop104;
874	>	goto _loop112;
875		}
876
877		}
878	<	_loop104:;
878	>	_loop112:;
879		} // ( ... )*
880		match('\"' /* charlit */ );
881		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1035 | void MDLexer::mEscape(bool _createToken) {
1035		{
1036		match('x' /* charlit */ );
1037		{ // ( ... )+
1038	<	int _cnt115=0;
1038	>	int _cnt123=0;
1039		for (;;) {
1040		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1041		mDigit(false);
#	Line 1044 | Line 1047 | void MDLexer::mEscape(bool _createToken) {
1047		matchRange('A','F');
1048		}
1049		else {
1050	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1050	>	if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1051		}
1052
1053	<	_cnt115++;
1053	>	_cnt123++;
1054		}
1055	<	_loop115:;
1055	>	_loop123:;
1056		}  // ( ... )+
1057		break;
1058		}
#	Line 1257 | Line 1260 | void MDLexer::mID(bool _createToken) {
1260		}
1261		default:
1262		{
1263	<	goto _loop120;
1263	>	goto _loop128;
1264		}
1265		}
1266		}
1267	<	_loop120:;
1267	>	_loop128:;
1268		} // ( ... )*
1269		_ttype = testLiteralsTable(_ttype);
1270		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1335 | Line 1338 | void MDLexer::mNUM_INT(bool _createToken) {
1338		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1339		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1340		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1341	<	#line 395 "MDParser.g"
1341	>	#line 410 "MDParser.g"
1342
1343		bool isDecimal = false;
1344		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1345
1346	<	#line 1344 "MDLexer.cpp"
1346	>	#line 1347 "MDLexer.cpp"
1347
1348		{
1349		switch ( LA(1)) {
#	Line 1380 | Line 1383 | void MDLexer::mNUM_INT(bool _createToken) {
1383		{
1384		match('.' /* charlit */ );
1385		if ( inputState->guessing==0 ) {
1386	<	#line 402 "MDParser.g"
1386	>	#line 417 "MDParser.g"
1387		_ttype = DOT;
1388	<	#line 1386 "MDLexer.cpp"
1388	>	#line 1389 "MDLexer.cpp"
1389		}
1390		{
1391		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1392		{ // ( ... )+
1393	<	int _cnt132=0;
1393	>	int _cnt140=0;
1394		for (;;) {
1395		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396		matchRange('0','9');
1397		}
1398		else {
1399	<	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1399	>	if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1400		}
1401
1402	<	_cnt132++;
1402	>	_cnt140++;
1403		}
1404	<	_loop132:;
1404	>	_loop140:;
1405		}  // ( ... )+
1406		{
1407	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1407	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1408		mEXPONENT(false);
1409		}
1410		else {
#	Line 1409 | Line 1412 | void MDLexer::mNUM_INT(bool _createToken) {
1412
1413		}
1414		{
1415	<	if ((_tokenSet_6.member(LA(1)))) {
1415	>	if ((_tokenSet_8.member(LA(1)))) {
1416		mFLOAT_SUFFIX(true);
1417		f1=_returnToken;
1418		if ( inputState->guessing==0 ) {
1419	<	#line 403 "MDParser.g"
1419	>	#line 418 "MDParser.g"
1420		t=f1;
1421	<	#line 1419 "MDLexer.cpp"
1421	>	#line 1422 "MDLexer.cpp"
1422		}
1423		}
1424		else {
#	Line 1423 | Line 1426 | void MDLexer::mNUM_INT(bool _createToken) {
1426
1427		}
1428		if ( inputState->guessing==0 ) {
1429	<	#line 404 "MDParser.g"
1429	>	#line 419 "MDParser.g"
1430
1431		if ( t &&
1432		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1434 | Line 1437 | void MDLexer::mNUM_INT(bool _createToken) {
1437		_ttype = NUM_DOUBLE; // assume double
1438		}
1439
1440	<	#line 1438 "MDLexer.cpp"
1440	>	#line 1441 "MDLexer.cpp"
1441		}
1442		}
1443		else {
#	Line 1460 | Line 1463 | void MDLexer::mNUM_INT(bool _createToken) {
1463		{
1464		match('0' /* charlit */ );
1465		if ( inputState->guessing==0 ) {
1466	<	#line 416 "MDParser.g"
1466	>	#line 431 "MDParser.g"
1467		isDecimal = true;
1468	<	#line 1466 "MDLexer.cpp"
1468	>	#line 1469 "MDLexer.cpp"
1469		}
1470		{
1471		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1485 | Line 1488 | void MDLexer::mNUM_INT(bool _createToken) {
1488		}
1489		}
1490		{ // ( ... )+
1491	<	int _cnt139=0;
1491	>	int _cnt147=0;
1492		for (;;) {
1493	<	if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1493	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1494		mHEX_DIGIT(false);
1495		}
1496		else {
1497	<	if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1497	>	if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1498		}
1499
1500	<	_cnt139++;
1500	>	_cnt147++;
1501		}
1502	<	_loop139:;
1502	>	_loop147:;
1503		}  // ( ... )+
1504		}
1505		else {
1506	<	bool synPredMatched144 = false;
1506	>	bool synPredMatched152 = false;
1507		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1508	<	int _m144 = mark();
1509	<	synPredMatched144 = true;
1508	>	int _m152 = mark();
1509	>	synPredMatched152 = true;
1510		inputState->guessing++;
1511		try {
1512		{
1513		{ // ( ... )+
1514	<	int _cnt142=0;
1514	>	int _cnt150=0;
1515		for (;;) {
1516		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1517		matchRange('0','9');
1518		}
1519		else {
1520	<	if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1520	>	if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521		}
1522
1523	<	_cnt142++;
1523	>	_cnt150++;
1524		}
1525	<	_loop142:;
1525	>	_loop150:;
1526		}  // ( ... )+
1527		{
1528	<	switch ( LA(1)) {
1526	<	case 0x2e /* '.' */ :
1527	<	{
1528	<	match('.' /* charlit */ );
1529	<	break;
1530	<	}
1531	<	case 0x45 /* 'E' */ :
1532	<	case 0x65 /* 'e' */ :
1533	<	{
1528	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1529		mEXPONENT(false);
1535	–	break;
1530		}
1531	<	case 0x44 /* 'D' */ :
1532	<	case 0x46 /* 'F' */ :
1533	<	case 0x64 /* 'd' */ :
1534	<	case 0x66 /* 'f' */ :
1541	<	{
1531	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1532	>	match('.' /* charlit */ );
1533	>	}
1534	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1535		mFLOAT_SUFFIX(false);
1543	–	break;
1536		}
1537	<	default:
1546	<	{
1537	>	else {
1538		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1539		}
1540	+
1541		}
1542		}
1551	–	}
1543		}
1544		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1545	<	synPredMatched144 = false;
1545	>	synPredMatched152 = false;
1546		}
1547	<	rewind(_m144);
1547	>	rewind(_m152);
1548		inputState->guessing--;
1549		}
1550	<	if ( synPredMatched144 ) {
1550	>	if ( synPredMatched152 ) {
1551		{ // ( ... )+
1552	<	int _cnt146=0;
1552	>	int _cnt154=0;
1553		for (;;) {
1554		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1555		matchRange('0','9');
1556		}
1557		else {
1558	<	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1558	>	if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1559		}
1560
1561	<	_cnt146++;
1561	>	_cnt154++;
1562		}
1563	<	_loop146:;
1563	>	_loop154:;
1564		}  // ( ... )+
1565		}
1566		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1567		{ // ( ... )+
1568	<	int _cnt148=0;
1568	>	int _cnt156=0;
1569		for (;;) {
1570		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1571		matchRange('0','7');
1572		}
1573		else {
1574	<	if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1574	>	if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575		}
1576
1577	<	_cnt148++;
1577	>	_cnt156++;
1578		}
1579	<	_loop148:;
1579	>	_loop156:;
1580		}  // ( ... )+
1581		}
1582		else {
#	Line 1613 | Line 1604 | void MDLexer::mNUM_INT(bool _createToken) {
1604		matchRange('0','9');
1605		}
1606		else {
1607	<	goto _loop151;
1607	>	goto _loop159;
1608		}
1609
1610		}
1611	<	_loop151:;
1611	>	_loop159:;
1612		} // ( ... )*
1613		if ( inputState->guessing==0 ) {
1614	<	#line 433 "MDParser.g"
1614	>	#line 448 "MDParser.g"
1615		isDecimal=true;
1616	<	#line 1626 "MDLexer.cpp"
1616	>	#line 1617 "MDLexer.cpp"
1617		}
1618		break;
1619		}
#	Line 1653 | Line 1644 | void MDLexer::mNUM_INT(bool _createToken) {
1644		}
1645		}
1646		if ( inputState->guessing==0 ) {
1647	<	#line 435 "MDParser.g"
1647	>	#line 450 "MDParser.g"
1648		_ttype = NUM_LONG;
1649	<	#line 1659 "MDLexer.cpp"
1649	>	#line 1650 "MDLexer.cpp"
1650		}
1651		}
1652	<	else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1652	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1653		{
1654	<	switch ( LA(1)) {
1655	<	case 0x2e /* '.' */ :
1656	<	{
1654	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1655	>	mEXPONENT(false);
1656	>	{
1657	>	if ((_tokenSet_8.member(LA(1)))) {
1658	>	mFLOAT_SUFFIX(true);
1659	>	f3=_returnToken;
1660	>	if ( inputState->guessing==0 ) {
1661	>	#line 455 "MDParser.g"
1662	>	t=f3;
1663	>	#line 1664 "MDLexer.cpp"
1664	>	}
1665	>	}
1666	>	else {
1667	>	}
1668	>
1669	>	}
1670	>	}
1671	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1672		match('.' /* charlit */ );
1673		{ // ( ... )*
1674		for (;;) {
#	Line 1670 | Line 1676 | void MDLexer::mNUM_INT(bool _createToken) {
1676		matchRange('0','9');
1677		}
1678		else {
1679	<	goto _loop156;
1679	>	goto _loop164;
1680		}
1681
1682		}
1683	<	_loop156:;
1683	>	_loop164:;
1684		} // ( ... )*
1685		{
1686	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1686	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1687		mEXPONENT(false);
1688		}
1689		else {
#	Line 1685 | Line 1691 | void MDLexer::mNUM_INT(bool _createToken) {
1691
1692		}
1693		{
1694	<	if ((_tokenSet_6.member(LA(1)))) {
1694	>	if ((_tokenSet_8.member(LA(1)))) {
1695		mFLOAT_SUFFIX(true);
1696		f2=_returnToken;
1697		if ( inputState->guessing==0 ) {
1698	<	#line 439 "MDParser.g"
1698	>	#line 454 "MDParser.g"
1699		t=f2;
1700	<	#line 1695 "MDLexer.cpp"
1700	>	#line 1701 "MDLexer.cpp"
1701		}
1702		}
1703		else {
1704		}
1705
1706		}
1701	–	break;
1707		}
1708	<	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	<	{
1708	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1709		mFLOAT_SUFFIX(true);
1710		f4=_returnToken;
1711		if ( inputState->guessing==0 ) {
1712	<	#line 441 "MDParser.g"
1712	>	#line 456 "MDParser.g"
1713		t=f4;
1714	<	#line 1734 "MDLexer.cpp"
1714	>	#line 1715 "MDLexer.cpp"
1715		}
1735	–	break;
1716		}
1717	<	default:
1738	<	{
1717	>	else {
1718		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1719		}
1720	+
1721		}
1742	–	}
1722		if ( inputState->guessing==0 ) {
1723	<	#line 443 "MDParser.g"
1723	>	#line 458 "MDParser.g"
1724
1725		if ( t &&
1726		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1752 | Line 1731 | void MDLexer::mNUM_INT(bool _createToken) {
1731		_ttype = NUM_DOUBLE; // assume double
1732		}
1733
1734	<	#line 1756 "MDLexer.cpp"
1734	>	#line 1735 "MDLexer.cpp"
1735		}
1736		}
1737		else {
#	Line 1792 | Line 1771 | void MDLexer::mEXPONENT(bool _createToken) {
1771		match('E' /* charlit */ );
1772		break;
1773		}
1774	+	case 0x64 /* 'd' */ :
1775	+	{
1776	+	match('d' /* charlit */ );
1777	+	break;
1778	+	}
1779	+	case 0x44 /* 'D' */ :
1780	+	{
1781	+	match('D' /* charlit */ );
1782	+	break;
1783	+	}
1784		default:
1785		{
1786		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 1830 | Line 1819 | void MDLexer::mEXPONENT(bool _createToken) {
1819		}
1820		}
1821		{ // ( ... )+
1822	<	int _cnt164=0;
1822	>	int _cnt172=0;
1823		for (;;) {
1824		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1825		matchRange('0','9');
1826		}
1827		else {
1828	<	if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1828	>	if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1829		}
1830
1831	<	_cnt164++;
1831	>	_cnt172++;
1832		}
1833	<	_loop164:;
1833	>	_loop172:;
1834		}  // ( ... )+
1835		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1836		_token = makeToken(_ttype);
#	Line 1894 | Line 1883 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1883		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1885		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1886	<	// \" # $ % & \' ( ) + , - . / 0 1 2
1886	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1887		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1888		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1889		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1890		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1891	<	// \" # $ % & \' ( ) * + , - . / 0 1 2
1891	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1892		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1893		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1894	<	// \" \' 0 1 2
1894	>	// \" \' 0 1 2 3 4 5
1895		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1896		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1898		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1899	<	// # $ % & \' ( ) * + , - . / 0 1 2
1899	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1900		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1901		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1902	<	// \' 0 1 2
1902	>	// \' 0 1 2 3 4 5
1903		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1904		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1906		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1907	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2
1907	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1908		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1909	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1909	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1910		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1911	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912	<	// 0 1 2
1911	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912	>	// + - 0 1 2 3 4 5
1913		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1914	<	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	<	// .
1914	>	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1916	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917	+	// 0 1 2 3 4 5
1918	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1919	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	+	// .
1921	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1922

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

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

Diff Legend

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