ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/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.
branches/development/src/mdParser/MDLexer.cpp (file contents), Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDLexer.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20120725): "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;
33	>	literals["flucQ"] = 20;
34	>	literals["cutoffGroup"] = 14;
35	>	literals["RNEMD"] = 21;
36	>	literals["rigidBody"] = 13;
37	>	literals["fragment"] = 15;
38		literals["zconstraint"] = 6;
39	<	literals["cutoffGroup"] = 12;
40	<	literals["bend"] = 9;
41	<	literals["orientation"] = 16;
42	<	literals["fragment"] = 13;
43	<	literals["bond"] = 8;
39	>	literals["minimizer"] = 22;
40	>	literals["component"] = 4;
41	>	literals["center"] = 17;
42	>	literals["members"] = 16;
43	>	literals["position"] = 18;
44	>	literals["orientation"] = 19;
45	>	literals["bend"] = 10;
46	>	literals["torsion"] = 11;
47	>	literals["atom"] = 8;
48		literals["molecule"] = 5;
49	<	literals["atom"] = 7;
49	>	literals["restraint"] = 7;
50	>	literals["inversion"] = 12;
51	>	literals["bond"] = 9;
52		}
53
54		ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
#	Line 473 | Line 479 | void MDLexer::mWhitespace(bool _createToken) {
479
480		}
481		if ( inputState->guessing==0 ) {
482	<	#line 218 "MDParser.g"
482	>	#line 253 "MDParser.g"
483		newline();
484	<	#line 479 "MDLexer.cpp"
484	>	#line 485 "MDLexer.cpp"
485		}
486		break;
487		}
#	Line 501 | Line 507 | void MDLexer::mWhitespace(bool _createToken) {
507
508		}
509		if ( inputState->guessing==0 ) {
510	<	#line 223 "MDParser.g"
510	>	#line 258 "MDParser.g"
511		printf("CPP_parser.g continuation line detected\n");
512		deferredNewline();
513	<	#line 508 "MDLexer.cpp"
513	>	#line 514 "MDLexer.cpp"
514		}
515		break;
516		}
#	Line 515 | Line 521 | void MDLexer::mWhitespace(bool _createToken) {
521		}
522		}
523		if ( inputState->guessing==0 ) {
524	<	#line 226 "MDParser.g"
524	>	#line 261 "MDParser.g"
525		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
526	<	#line 521 "MDLexer.cpp"
526	>	#line 527 "MDLexer.cpp"
527		}
528		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
529		_token = makeToken(_ttype);
#	Line 541 | Line 547 | void MDLexer::mComment(bool _createToken) {
547		else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
548		mEndOfLine(false);
549		if ( inputState->guessing==0 ) {
550	<	#line 233 "MDParser.g"
550	>	#line 268 "MDParser.g"
551		deferredNewline();
552	<	#line 547 "MDLexer.cpp"
552	>	#line 553 "MDLexer.cpp"
553		}
554		}
555		else if ((_tokenSet_0.member(LA(1)))) {
#	Line 552 | Line 558 | void MDLexer::mComment(bool _createToken) {
558		}
559		}
560		else {
561	<	goto _loop78;
561	>	goto _loop96;
562		}
563
564		}
565	<	_loop78:;
565	>	_loop96:;
566		} // ( ... )*
567		match("*/");
568		if ( inputState->guessing==0 ) {
569	<	#line 236 "MDParser.g"
569	>	#line 271 "MDParser.g"
570		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
571	<	#line 566 "MDLexer.cpp"
571	>	#line 572 "MDLexer.cpp"
572		}
573		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
574		_token = makeToken(_ttype);
#	Line 614 | Line 620 | void MDLexer::mCPPComment(bool _createToken) {
620		}
621		}
622		else {
623	<	goto _loop82;
623	>	goto _loop100;
624		}
625
626		}
627	<	_loop82:;
627	>	_loop100:;
628		} // ( ... )*
629		mEndOfLine(false);
630		if ( inputState->guessing==0 ) {
631	<	#line 242 "MDParser.g"
631	>	#line 277 "MDParser.g"
632		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
633	<	#line 628 "MDLexer.cpp"
633	>	#line 634 "MDLexer.cpp"
634		}
635		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
636		_token = makeToken(_ttype);
#	Line 642 | Line 648 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
648		match('#' /* charlit */ );
649		mLineDirective(false);
650		if ( inputState->guessing==0 ) {
651	<	#line 249 "MDParser.g"
651	>	#line 284 "MDParser.g"
652		_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
653	<	#line 648 "MDLexer.cpp"
653	>	#line 654 "MDLexer.cpp"
654		}
655		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
656		_token = makeToken(_ttype);
#	Line 662 | Line 668 | void MDLexer::mLineDirective(bool _createToken) {
668		ANTLR_USE_NAMESPACE(antlr)RefToken sl;
669
670		if ( inputState->guessing==0 ) {
671	<	#line 255 "MDParser.g"
671	>	#line 290 "MDParser.g"
672
673		deferredLineCount = 0;
674
675	<	#line 670 "MDLexer.cpp"
675	>	#line 676 "MDLexer.cpp"
676		}
677		{
678		switch ( LA(1)) {
#	Line 688 | Line 694 | void MDLexer::mLineDirective(bool _createToken) {
694		}
695		}
696		{ // ( ... )+
697	<	int _cnt87=0;
697	>	int _cnt105=0;
698		for (;;) {
699		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
700		mSpace(false);
701		}
702		else {
703	<	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
703	>	if ( _cnt105>=1 ) { goto _loop105; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
704		}
705
706	<	_cnt87++;
706	>	_cnt105++;
707		}
708	<	_loop87:;
708	>	_loop105:;
709		}  // ( ... )+
710		mDecimal(true);
711		n=_returnToken;
712		if ( inputState->guessing==0 ) {
713	<	#line 260 "MDParser.g"
714	<	setLine(oopse::lexi_cast<int>(n->getText()) - 1);
715	<	#line 710 "MDLexer.cpp"
713	>	#line 295 "MDParser.g"
714	>	setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
715	>	#line 716 "MDLexer.cpp"
716		}
717		{ // ( ... )+
718	<	int _cnt89=0;
718	>	int _cnt107=0;
719		for (;;) {
720		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
721		mSpace(false);
722		}
723		else {
724	<	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724	>	if ( _cnt107>=1 ) { goto _loop107; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
725		}
726
727	<	_cnt89++;
727	>	_cnt107++;
728		}
729	<	_loop89:;
729	>	_loop107:;
730		}  // ( ... )+
731		{
732		mStringLiteral(true);
733		sl=_returnToken;
734		}
735		if ( inputState->guessing==0 ) {
736	<	#line 262 "MDParser.g"
736	>	#line 297 "MDParser.g"
737		std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
738	<	#line 733 "MDLexer.cpp"
738	>	#line 739 "MDLexer.cpp"
739		}
740		{ // ( ... )*
741		for (;;) {
742		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
743		{ // ( ... )+
744	<	int _cnt93=0;
744	>	int _cnt111=0;
745		for (;;) {
746		if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
747		mSpace(false);
748		}
749		else {
750	<	if ( _cnt93>=1 ) { goto _loop93; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
750	>	if ( _cnt111>=1 ) { goto _loop111; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
751		}
752
753	<	_cnt93++;
753	>	_cnt111++;
754		}
755	<	_loop93:;
755	>	_loop111:;
756		}  // ( ... )+
757		mDecimal(false);
758		}
759		else {
760	<	goto _loop94;
760	>	goto _loop112;
761		}
762
763		}
764	<	_loop94:;
764	>	_loop112:;
765		} // ( ... )*
766		mEndOfLine(false);
767		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 808 | Line 814 | void MDLexer::mDecimal(bool _createToken) {
814		ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
815
816		{ // ( ... )+
817	<	int _cnt124=0;
817	>	int _cnt142=0;
818		for (;;) {
819		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
820		matchRange('0','9');
821		}
822		else {
823	<	if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
823	>	if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
824		}
825
826	<	_cnt124++;
826	>	_cnt142++;
827		}
828	<	_loop124:;
828	>	_loop142:;
829		}  // ( ... )+
830		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
831		_token = makeToken(_ttype);
#	Line 857 | Line 863 | void MDLexer::mStringLiteral(bool _createToken) {
863
864		}
865		if ( inputState->guessing==0 ) {
866	<	#line 302 "MDParser.g"
866	>	#line 337 "MDParser.g"
867		deferredNewline();
868	<	#line 863 "MDLexer.cpp"
868	>	#line 869 "MDLexer.cpp"
869		}
870		}
871		else if ((_tokenSet_3.member(LA(1)))) {
#	Line 868 | Line 874 | void MDLexer::mStringLiteral(bool _createToken) {
874		}
875		}
876		else {
877	<	goto _loop104;
877	>	goto _loop122;
878		}
879
880		}
881	<	_loop104:;
881	>	_loop122:;
882		} // ( ... )*
883		match('\"' /* charlit */ );
884		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1032 | Line 1038 | void MDLexer::mEscape(bool _createToken) {
1038		{
1039		match('x' /* charlit */ );
1040		{ // ( ... )+
1041	<	int _cnt115=0;
1041	>	int _cnt133=0;
1042		for (;;) {
1043		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1044		mDigit(false);
#	Line 1044 | Line 1050 | void MDLexer::mEscape(bool _createToken) {
1050		matchRange('A','F');
1051		}
1052		else {
1053	<	if ( _cnt115>=1 ) { goto _loop115; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1053	>	if ( _cnt133>=1 ) { goto _loop133; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1054		}
1055
1056	<	_cnt115++;
1056	>	_cnt133++;
1057		}
1058	<	_loop115:;
1058	>	_loop133:;
1059		}  // ( ... )+
1060		break;
1061		}
#	Line 1257 | Line 1263 | void MDLexer::mID(bool _createToken) {
1263		}
1264		default:
1265		{
1266	<	goto _loop120;
1266	>	goto _loop138;
1267		}
1268		}
1269		}
1270	<	_loop120:;
1270	>	_loop138:;
1271		} // ( ... )*
1272		_ttype = testLiteralsTable(_ttype);
1273		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
#	Line 1335 | Line 1341 | void MDLexer::mNUM_INT(bool _createToken) {
1341		ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1342		ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1343		ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1344	<	#line 395 "MDParser.g"
1344	>	#line 430 "MDParser.g"
1345
1346		bool isDecimal = false;
1347		ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1348
1349	<	#line 1344 "MDLexer.cpp"
1349	>	#line 1350 "MDLexer.cpp"
1350
1351		{
1352		switch ( LA(1)) {
#	Line 1380 | Line 1386 | void MDLexer::mNUM_INT(bool _createToken) {
1386		{
1387		match('.' /* charlit */ );
1388		if ( inputState->guessing==0 ) {
1389	<	#line 402 "MDParser.g"
1389	>	#line 437 "MDParser.g"
1390		_ttype = DOT;
1391	<	#line 1386 "MDLexer.cpp"
1391	>	#line 1392 "MDLexer.cpp"
1392		}
1393		{
1394		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1395		{ // ( ... )+
1396	<	int _cnt132=0;
1396	>	int _cnt150=0;
1397		for (;;) {
1398		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1399		matchRange('0','9');
1400		}
1401		else {
1402	<	if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1402	>	if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1403		}
1404
1405	<	_cnt132++;
1405	>	_cnt150++;
1406		}
1407	<	_loop132:;
1407	>	_loop150:;
1408		}  // ( ... )+
1409		{
1410	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1410	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1411		mEXPONENT(false);
1412		}
1413		else {
#	Line 1409 | Line 1415 | void MDLexer::mNUM_INT(bool _createToken) {
1415
1416		}
1417		{
1418	<	if ((_tokenSet_6.member(LA(1)))) {
1418	>	if ((_tokenSet_8.member(LA(1)))) {
1419		mFLOAT_SUFFIX(true);
1420		f1=_returnToken;
1421		if ( inputState->guessing==0 ) {
1422	<	#line 403 "MDParser.g"
1422	>	#line 438 "MDParser.g"
1423		t=f1;
1424	<	#line 1419 "MDLexer.cpp"
1424	>	#line 1425 "MDLexer.cpp"
1425		}
1426		}
1427		else {
#	Line 1423 | Line 1429 | void MDLexer::mNUM_INT(bool _createToken) {
1429
1430		}
1431		if ( inputState->guessing==0 ) {
1432	<	#line 404 "MDParser.g"
1432	>	#line 439 "MDParser.g"
1433
1434		if ( t &&
1435		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1434 | Line 1440 | void MDLexer::mNUM_INT(bool _createToken) {
1440		_ttype = NUM_DOUBLE; // assume double
1441		}
1442
1443	<	#line 1438 "MDLexer.cpp"
1443	>	#line 1444 "MDLexer.cpp"
1444		}
1445		}
1446		else {
#	Line 1460 | Line 1466 | void MDLexer::mNUM_INT(bool _createToken) {
1466		{
1467		match('0' /* charlit */ );
1468		if ( inputState->guessing==0 ) {
1469	<	#line 416 "MDParser.g"
1469	>	#line 451 "MDParser.g"
1470		isDecimal = true;
1471	<	#line 1466 "MDLexer.cpp"
1471	>	#line 1472 "MDLexer.cpp"
1472		}
1473		{
1474		if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
#	Line 1485 | Line 1491 | void MDLexer::mNUM_INT(bool _createToken) {
1491		}
1492		}
1493		{ // ( ... )+
1494	<	int _cnt139=0;
1494	>	int _cnt157=0;
1495		for (;;) {
1496	<	if ((_tokenSet_7.member(LA(1))) && (true) && (true)) {
1496	>	if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1497		mHEX_DIGIT(false);
1498		}
1499		else {
1500	<	if ( _cnt139>=1 ) { goto _loop139; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1500	>	if ( _cnt157>=1 ) { goto _loop157; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1501		}
1502
1503	<	_cnt139++;
1503	>	_cnt157++;
1504		}
1505	<	_loop139:;
1505	>	_loop157:;
1506		}  // ( ... )+
1507		}
1508		else {
1509	<	bool synPredMatched144 = false;
1509	>	bool synPredMatched162 = false;
1510		if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1511	<	int _m144 = mark();
1512	<	synPredMatched144 = true;
1511	>	int _m162 = mark();
1512	>	synPredMatched162 = true;
1513		inputState->guessing++;
1514		try {
1515		{
1516		{ // ( ... )+
1517	<	int _cnt142=0;
1517	>	int _cnt160=0;
1518		for (;;) {
1519		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1520		matchRange('0','9');
1521		}
1522		else {
1523	<	if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1523	>	if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1524		}
1525
1526	<	_cnt142++;
1526	>	_cnt160++;
1527		}
1528	<	_loop142:;
1528	>	_loop160:;
1529		}  // ( ... )+
1530		{
1531	<	switch ( LA(1)) {
1532	<	case 0x2e /* '.' */ :
1533	<	{
1531	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1532	>	mEXPONENT(false);
1533	>	}
1534	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1535		match('.' /* charlit */ );
1529	–	break;
1536		}
1537	<	case 0x45 /* 'E' */ :
1538	<	case 0x65 /* 'e' */ :
1533	<	{
1534	<	mEXPONENT(false);
1535	<	break;
1537	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1538	>	mFLOAT_SUFFIX(false);
1539		}
1540	<	case 0x44 /* 'D' */ :
1538	<	case 0x46 /* 'F' */ :
1539	<	case 0x64 /* 'd' */ :
1540	<	case 0x66 /* 'f' */ :
1541	<	{
1542	<	mFLOAT_SUFFIX(false);
1543	<	break;
1544	<	}
1545	<	default:
1546	<	{
1540	>	else {
1541		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1542		}
1543	+
1544		}
1545		}
1551	–	}
1546		}
1547		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1548	<	synPredMatched144 = false;
1548	>	synPredMatched162 = false;
1549		}
1550	<	rewind(_m144);
1550	>	rewind(_m162);
1551		inputState->guessing--;
1552		}
1553	<	if ( synPredMatched144 ) {
1553	>	if ( synPredMatched162 ) {
1554		{ // ( ... )+
1555	<	int _cnt146=0;
1555	>	int _cnt164=0;
1556		for (;;) {
1557		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1558		matchRange('0','9');
1559		}
1560		else {
1561	<	if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1561	>	if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1562		}
1563
1564	<	_cnt146++;
1564	>	_cnt164++;
1565		}
1566	<	_loop146:;
1566	>	_loop164:;
1567		}  // ( ... )+
1568		}
1569		else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1570		{ // ( ... )+
1571	<	int _cnt148=0;
1571	>	int _cnt166=0;
1572		for (;;) {
1573		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1574		matchRange('0','7');
1575		}
1576		else {
1577	<	if ( _cnt148>=1 ) { goto _loop148; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1577	>	if ( _cnt166>=1 ) { goto _loop166; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1578		}
1579
1580	<	_cnt148++;
1580	>	_cnt166++;
1581		}
1582	<	_loop148:;
1582	>	_loop166:;
1583		}  // ( ... )+
1584		}
1585		else {
#	Line 1613 | Line 1607 | void MDLexer::mNUM_INT(bool _createToken) {
1607		matchRange('0','9');
1608		}
1609		else {
1610	<	goto _loop151;
1610	>	goto _loop169;
1611		}
1612
1613		}
1614	<	_loop151:;
1614	>	_loop169:;
1615		} // ( ... )*
1616		if ( inputState->guessing==0 ) {
1617	<	#line 433 "MDParser.g"
1617	>	#line 468 "MDParser.g"
1618		isDecimal=true;
1619	<	#line 1626 "MDLexer.cpp"
1619	>	#line 1620 "MDLexer.cpp"
1620		}
1621		break;
1622		}
#	Line 1653 | Line 1647 | void MDLexer::mNUM_INT(bool _createToken) {
1647		}
1648		}
1649		if ( inputState->guessing==0 ) {
1650	<	#line 435 "MDParser.g"
1650	>	#line 470 "MDParser.g"
1651		_ttype = NUM_LONG;
1652	<	#line 1659 "MDLexer.cpp"
1652	>	#line 1653 "MDLexer.cpp"
1653		}
1654		}
1655	<	else if (((_tokenSet_8.member(LA(1))))&&(isDecimal)) {
1655	>	else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
1656		{
1657	<	switch ( LA(1)) {
1658	<	case 0x2e /* '.' */ :
1659	<	{
1657	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1658	>	mEXPONENT(false);
1659	>	{
1660	>	if ((_tokenSet_8.member(LA(1)))) {
1661	>	mFLOAT_SUFFIX(true);
1662	>	f3=_returnToken;
1663	>	if ( inputState->guessing==0 ) {
1664	>	#line 475 "MDParser.g"
1665	>	t=f3;
1666	>	#line 1667 "MDLexer.cpp"
1667	>	}
1668	>	}
1669	>	else {
1670	>	}
1671	>
1672	>	}
1673	>	}
1674	>	else if ((LA(1) == 0x2e /* '.' */ )) {
1675		match('.' /* charlit */ );
1676		{ // ( ... )*
1677		for (;;) {
#	Line 1670 | Line 1679 | void MDLexer::mNUM_INT(bool _createToken) {
1679		matchRange('0','9');
1680		}
1681		else {
1682	<	goto _loop156;
1682	>	goto _loop174;
1683		}
1684
1685		}
1686	<	_loop156:;
1686	>	_loop174:;
1687		} // ( ... )*
1688		{
1689	<	if ((LA(1) == 0x45 /* 'E' */  || LA(1) == 0x65 /* 'e' */ )) {
1689	>	if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
1690		mEXPONENT(false);
1691		}
1692		else {
#	Line 1685 | Line 1694 | void MDLexer::mNUM_INT(bool _createToken) {
1694
1695		}
1696		{
1697	<	if ((_tokenSet_6.member(LA(1)))) {
1697	>	if ((_tokenSet_8.member(LA(1)))) {
1698		mFLOAT_SUFFIX(true);
1699		f2=_returnToken;
1700		if ( inputState->guessing==0 ) {
1701	<	#line 439 "MDParser.g"
1701	>	#line 474 "MDParser.g"
1702		t=f2;
1703	<	#line 1695 "MDLexer.cpp"
1703	>	#line 1704 "MDLexer.cpp"
1704		}
1705		}
1706		else {
1707		}
1708
1709		}
1701	–	break;
1710		}
1711	<	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	<	{
1711	>	else if ((_tokenSet_8.member(LA(1))) && (true)) {
1712		mFLOAT_SUFFIX(true);
1713		f4=_returnToken;
1714		if ( inputState->guessing==0 ) {
1715	<	#line 441 "MDParser.g"
1715	>	#line 476 "MDParser.g"
1716		t=f4;
1717	<	#line 1734 "MDLexer.cpp"
1717	>	#line 1718 "MDLexer.cpp"
1718		}
1735	–	break;
1719		}
1720	<	default:
1738	<	{
1720	>	else {
1721		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
1722		}
1723	+
1724		}
1742	–	}
1725		if ( inputState->guessing==0 ) {
1726	<	#line 443 "MDParser.g"
1726	>	#line 478 "MDParser.g"
1727
1728		if ( t &&
1729		(t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
#	Line 1752 | Line 1734 | void MDLexer::mNUM_INT(bool _createToken) {
1734		_ttype = NUM_DOUBLE; // assume double
1735		}
1736
1737	<	#line 1756 "MDLexer.cpp"
1737	>	#line 1738 "MDLexer.cpp"
1738		}
1739		}
1740		else {
#	Line 1792 | Line 1774 | void MDLexer::mEXPONENT(bool _createToken) {
1774		match('E' /* charlit */ );
1775		break;
1776		}
1777	+	case 0x64 /* 'd' */ :
1778	+	{
1779	+	match('d' /* charlit */ );
1780	+	break;
1781	+	}
1782	+	case 0x44 /* 'D' */ :
1783	+	{
1784	+	match('D' /* charlit */ );
1785	+	break;
1786	+	}
1787		default:
1788		{
1789		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
#	Line 1830 | Line 1822 | void MDLexer::mEXPONENT(bool _createToken) {
1822		}
1823		}
1824		{ // ( ... )+
1825	<	int _cnt164=0;
1825	>	int _cnt182=0;
1826		for (;;) {
1827		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1828		matchRange('0','9');
1829		}
1830		else {
1831	<	if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1831	>	if ( _cnt182>=1 ) { goto _loop182; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1832		}
1833
1834	<	_cnt164++;
1834	>	_cnt182++;
1835		}
1836	<	_loop164:;
1836	>	_loop182:;
1837		}  // ( ... )+
1838		if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1839		_token = makeToken(_ttype);
#	Line 1894 | Line 1886 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1886		const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1887		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1888		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1889	<	// \" # $ % & \' ( ) + , - . / 0 1 2
1889	>	// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8
1890		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1891		const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1892		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1893		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1894	<	// \" # $ % & \' ( ) * + , - . / 0 1 2
1894	>	// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1895		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1896		const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897	<	// \" \' 0 1 2
1897	>	// \" \' 0 1 2 3 4 5 6 7
1898		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1899		const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1901		// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1902	<	// # $ % & \' ( ) * + , - . / 0 1 2
1902	>	// # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1903		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1904		const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905	<	// \' 0 1 2
1905	>	// \' 0 1 2 3 4 5 6 7 8
1906		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1907		const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908		// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1909		// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1910	<	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2
1910	>	// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8
1911		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1912	<	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912	>	const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1913		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1914	<	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915	<	// 0 1 2
1914	>	const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915	>	// + - 0 1 2 3 4 5 6 7 8
1916		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1917	<	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926	<	// .
1917	>	const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918		const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1919	+	const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920	+	// 0 1 2 3 4 5 6 7 8
1921	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1922	+	const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923	+	// .
1924	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1925

Comparing:
trunk/src/mdParser/MDLexer.cpp (property svn:keywords), Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
branches/development/src/mdParser/MDLexer.cpp (property svn:keywords), Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

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

Diff Legend

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