ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDLexer.cpp
(Generate patch)

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 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  

Diff Legend

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