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

Comparing branches/development/src/mdParser/MDLexer.cpp (file contents):
Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20110725): "MDParser.g" -> "MDLexer.cpp"$ */
2   #include "MDLexer.hpp"
3   #include <antlr/CharBuffer.hpp>
4   #include <antlr/TokenStreamException.hpp>
# Line 46 | Line 46 | void MDLexer::initLiterals()
46          literals["bond"] = 9;
47          literals["molecule"] = 5;
48          literals["atom"] = 8;
49 +        literals["RNEMD"] = 21;
50 +        literals["flucQ"] = 20;
51   }
52  
53   ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
# Line 476 | Line 478 | void MDLexer::mWhitespace(bool _createToken) {
478                  
479                  }
480                  if ( inputState->guessing==0 ) {
481 < #line 233 "MDParser.g"
481 > #line 243 "MDParser.g"
482                          newline();
483 < #line 482 "MDLexer.cpp"
483 > #line 484 "MDLexer.cpp"
484                  }
485                  break;
486          }
# Line 504 | Line 506 | void MDLexer::mWhitespace(bool _createToken) {
506                  
507                  }
508                  if ( inputState->guessing==0 ) {
509 < #line 238 "MDParser.g"
509 > #line 248 "MDParser.g"
510                          printf("CPP_parser.g continuation line detected\n");
511                          deferredNewline();
512 < #line 511 "MDLexer.cpp"
512 > #line 513 "MDLexer.cpp"
513                  }
514                  break;
515          }
# Line 518 | Line 520 | void MDLexer::mWhitespace(bool _createToken) {
520          }
521          }
522          if ( inputState->guessing==0 ) {
523 < #line 241 "MDParser.g"
523 > #line 251 "MDParser.g"
524                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
525 < #line 524 "MDLexer.cpp"
525 > #line 526 "MDLexer.cpp"
526          }
527          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
528             _token = makeToken(_ttype);
# Line 544 | Line 546 | void MDLexer::mComment(bool _createToken) {
546                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
547                          mEndOfLine(false);
548                          if ( inputState->guessing==0 ) {
549 < #line 248 "MDParser.g"
549 > #line 258 "MDParser.g"
550                                  deferredNewline();
551 < #line 550 "MDLexer.cpp"
551 > #line 552 "MDLexer.cpp"
552                          }
553                  }
554                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 555 | Line 557 | void MDLexer::mComment(bool _createToken) {
557                          }
558                  }
559                  else {
560 <                        goto _loop86;
560 >                        goto _loop92;
561                  }
562                  
563          }
564 <        _loop86:;
564 >        _loop92:;
565          } // ( ... )*
566          match("*/");
567          if ( inputState->guessing==0 ) {
568 < #line 251 "MDParser.g"
568 > #line 261 "MDParser.g"
569                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
570 < #line 569 "MDLexer.cpp"
570 > #line 571 "MDLexer.cpp"
571          }
572          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
573             _token = makeToken(_ttype);
# Line 617 | Line 619 | void MDLexer::mCPPComment(bool _createToken) {
619                          }
620                  }
621                  else {
622 <                        goto _loop90;
622 >                        goto _loop96;
623                  }
624                  
625          }
626 <        _loop90:;
626 >        _loop96:;
627          } // ( ... )*
628          mEndOfLine(false);
629          if ( inputState->guessing==0 ) {
630 < #line 257 "MDParser.g"
630 > #line 267 "MDParser.g"
631                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
632 < #line 631 "MDLexer.cpp"
632 > #line 633 "MDLexer.cpp"
633          }
634          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
635             _token = makeToken(_ttype);
# Line 645 | Line 647 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
647          match('#' /* charlit */ );
648          mLineDirective(false);
649          if ( inputState->guessing==0 ) {
650 < #line 264 "MDParser.g"
650 > #line 274 "MDParser.g"
651                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
652 < #line 651 "MDLexer.cpp"
652 > #line 653 "MDLexer.cpp"
653          }
654          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
655             _token = makeToken(_ttype);
# Line 665 | Line 667 | void MDLexer::mLineDirective(bool _createToken) {
667          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
668          
669          if ( inputState->guessing==0 ) {
670 < #line 270 "MDParser.g"
670 > #line 280 "MDParser.g"
671                  
672                  deferredLineCount = 0;
673                  
674 < #line 673 "MDLexer.cpp"
674 > #line 675 "MDLexer.cpp"
675          }
676          {
677          switch ( LA(1)) {
# Line 691 | Line 693 | void MDLexer::mLineDirective(bool _createToken) {
693          }
694          }
695          { // ( ... )+
696 <        int _cnt95=0;
696 >        int _cnt101=0;
697          for (;;) {
698                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
699                          mSpace(false);
700                  }
701                  else {
702 <                        if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
702 >                        if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
703                  }
704                  
705 <                _cnt95++;
705 >                _cnt101++;
706          }
707 <        _loop95:;
707 >        _loop101:;
708          }  // ( ... )+
709          mDecimal(true);
710          n=_returnToken;
711          if ( inputState->guessing==0 ) {
712 < #line 275 "MDParser.g"
712 > #line 285 "MDParser.g"
713                  setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
714 < #line 713 "MDLexer.cpp"
714 > #line 715 "MDLexer.cpp"
715          }
716          { // ( ... )+
717 <        int _cnt97=0;
717 >        int _cnt103=0;
718          for (;;) {
719                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
720                          mSpace(false);
721                  }
722                  else {
723 <                        if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
723 >                        if ( _cnt103>=1 ) { goto _loop103; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724                  }
725                  
726 <                _cnt97++;
726 >                _cnt103++;
727          }
728 <        _loop97:;
728 >        _loop103:;
729          }  // ( ... )+
730          {
731          mStringLiteral(true);
732          sl=_returnToken;
733          }
734          if ( inputState->guessing==0 ) {
735 < #line 277 "MDParser.g"
735 > #line 287 "MDParser.g"
736                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
737 < #line 736 "MDLexer.cpp"
737 > #line 738 "MDLexer.cpp"
738          }
739          { // ( ... )*
740          for (;;) {
741                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
742                          { // ( ... )+
743 <                        int _cnt101=0;
743 >                        int _cnt107=0;
744                          for (;;) {
745                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746                                          mSpace(false);
747                                  }
748                                  else {
749 <                                        if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
749 >                                        if ( _cnt107>=1 ) { goto _loop107; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
750                                  }
751                                  
752 <                                _cnt101++;
752 >                                _cnt107++;
753                          }
754 <                        _loop101:;
754 >                        _loop107:;
755                          }  // ( ... )+
756                          mDecimal(false);
757                  }
758                  else {
759 <                        goto _loop102;
759 >                        goto _loop108;
760                  }
761                  
762          }
763 <        _loop102:;
763 >        _loop108:;
764          } // ( ... )*
765          mEndOfLine(false);
766          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 811 | Line 813 | void MDLexer::mDecimal(bool _createToken) {
813          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
814          
815          { // ( ... )+
816 <        int _cnt132=0;
816 >        int _cnt138=0;
817          for (;;) {
818                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
819                          matchRange('0','9');
820                  }
821                  else {
822 <                        if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
822 >                        if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
823                  }
824                  
825 <                _cnt132++;
825 >                _cnt138++;
826          }
827 <        _loop132:;
827 >        _loop138:;
828          }  // ( ... )+
829          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
830             _token = makeToken(_ttype);
# Line 860 | Line 862 | void MDLexer::mStringLiteral(bool _createToken) {
862                          
863                          }
864                          if ( inputState->guessing==0 ) {
865 < #line 317 "MDParser.g"
865 > #line 327 "MDParser.g"
866                                  deferredNewline();
867 < #line 866 "MDLexer.cpp"
867 > #line 868 "MDLexer.cpp"
868                          }
869                  }
870                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 871 | Line 873 | void MDLexer::mStringLiteral(bool _createToken) {
873                          }
874                  }
875                  else {
876 <                        goto _loop112;
876 >                        goto _loop118;
877                  }
878                  
879          }
880 <        _loop112:;
880 >        _loop118:;
881          } // ( ... )*
882          match('\"' /* charlit */ );
883          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1035 | Line 1037 | void MDLexer::mEscape(bool _createToken) {
1037          {
1038                  match('x' /* charlit */ );
1039                  { // ( ... )+
1040 <                int _cnt123=0;
1040 >                int _cnt129=0;
1041                  for (;;) {
1042                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1043                                  mDigit(false);
# Line 1047 | Line 1049 | void MDLexer::mEscape(bool _createToken) {
1049                                  matchRange('A','F');
1050                          }
1051                          else {
1052 <                                if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1052 >                                if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1053                          }
1054                          
1055 <                        _cnt123++;
1055 >                        _cnt129++;
1056                  }
1057 <                _loop123:;
1057 >                _loop129:;
1058                  }  // ( ... )+
1059                  break;
1060          }
# Line 1260 | Line 1262 | void MDLexer::mID(bool _createToken) {
1262                  }
1263                  default:
1264                  {
1265 <                        goto _loop128;
1265 >                        goto _loop134;
1266                  }
1267                  }
1268          }
1269 <        _loop128:;
1269 >        _loop134:;
1270          } // ( ... )*
1271          _ttype = testLiteralsTable(_ttype);
1272          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1338 | Line 1340 | void MDLexer::mNUM_INT(bool _createToken) {
1340          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1341          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1342          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1343 < #line 410 "MDParser.g"
1343 > #line 420 "MDParser.g"
1344          
1345                          bool isDecimal = false;
1346                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1347                  
1348 < #line 1347 "MDLexer.cpp"
1348 > #line 1349 "MDLexer.cpp"
1349          
1350          {
1351          switch ( LA(1)) {
# Line 1383 | Line 1385 | void MDLexer::mNUM_INT(bool _createToken) {
1385          {
1386                  match('.' /* charlit */ );
1387                  if ( inputState->guessing==0 ) {
1388 < #line 417 "MDParser.g"
1388 > #line 427 "MDParser.g"
1389                          _ttype = DOT;
1390 < #line 1389 "MDLexer.cpp"
1390 > #line 1391 "MDLexer.cpp"
1391                  }
1392                  {
1393                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1394                          { // ( ... )+
1395 <                        int _cnt140=0;
1395 >                        int _cnt146=0;
1396                          for (;;) {
1397                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398                                          matchRange('0','9');
1399                                  }
1400                                  else {
1401 <                                        if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1401 >                                        if ( _cnt146>=1 ) { goto _loop146; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1402                                  }
1403                                  
1404 <                                _cnt140++;
1404 >                                _cnt146++;
1405                          }
1406 <                        _loop140:;
1406 >                        _loop146:;
1407                          }  // ( ... )+
1408                          {
1409                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1416 | Line 1418 | void MDLexer::mNUM_INT(bool _createToken) {
1418                                  mFLOAT_SUFFIX(true);
1419                                  f1=_returnToken;
1420                                  if ( inputState->guessing==0 ) {
1421 < #line 418 "MDParser.g"
1421 > #line 428 "MDParser.g"
1422                                          t=f1;
1423 < #line 1422 "MDLexer.cpp"
1423 > #line 1424 "MDLexer.cpp"
1424                                  }
1425                          }
1426                          else {
# Line 1426 | Line 1428 | void MDLexer::mNUM_INT(bool _createToken) {
1428                          
1429                          }
1430                          if ( inputState->guessing==0 ) {
1431 < #line 419 "MDParser.g"
1431 > #line 429 "MDParser.g"
1432                                  
1433                                                                          if ( t &&
1434                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1437 | Line 1439 | void MDLexer::mNUM_INT(bool _createToken) {
1439                                                                                  _ttype = NUM_DOUBLE; // assume double
1440                                                                          }
1441                                                                  
1442 < #line 1441 "MDLexer.cpp"
1442 > #line 1443 "MDLexer.cpp"
1443                          }
1444                  }
1445                  else {
# Line 1463 | Line 1465 | void MDLexer::mNUM_INT(bool _createToken) {
1465                  {
1466                          match('0' /* charlit */ );
1467                          if ( inputState->guessing==0 ) {
1468 < #line 431 "MDParser.g"
1468 > #line 441 "MDParser.g"
1469                                  isDecimal = true;
1470 < #line 1469 "MDLexer.cpp"
1470 > #line 1471 "MDLexer.cpp"
1471                          }
1472                          {
1473                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1488 | Line 1490 | void MDLexer::mNUM_INT(bool _createToken) {
1490                                  }
1491                                  }
1492                                  { // ( ... )+
1493 <                                int _cnt147=0;
1493 >                                int _cnt153=0;
1494                                  for (;;) {
1495                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1496                                                  mHEX_DIGIT(false);
1497                                          }
1498                                          else {
1499 <                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1499 >                                                if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1500                                          }
1501                                          
1502 <                                        _cnt147++;
1502 >                                        _cnt153++;
1503                                  }
1504 <                                _loop147:;
1504 >                                _loop153:;
1505                                  }  // ( ... )+
1506                          }
1507                          else {
1508 <                                bool synPredMatched152 = false;
1508 >                                bool synPredMatched158 = false;
1509                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1510 <                                        int _m152 = mark();
1511 <                                        synPredMatched152 = true;
1510 >                                        int _m158 = mark();
1511 >                                        synPredMatched158 = true;
1512                                          inputState->guessing++;
1513                                          try {
1514                                                  {
1515                                                  { // ( ... )+
1516 <                                                int _cnt150=0;
1516 >                                                int _cnt156=0;
1517                                                  for (;;) {
1518                                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1519                                                                  matchRange('0','9');
1520                                                          }
1521                                                          else {
1522 <                                                                if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1522 >                                                                if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1523                                                          }
1524                                                          
1525 <                                                        _cnt150++;
1525 >                                                        _cnt156++;
1526                                                  }
1527 <                                                _loop150:;
1527 >                                                _loop156:;
1528                                                  }  // ( ... )+
1529                                                  {
1530                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1542 | Line 1544 | void MDLexer::mNUM_INT(bool _createToken) {
1544                                                  }
1545                                          }
1546                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1547 <                                                synPredMatched152 = false;
1547 >                                                synPredMatched158 = false;
1548                                          }
1549 <                                        rewind(_m152);
1549 >                                        rewind(_m158);
1550                                          inputState->guessing--;
1551                                  }
1552 <                                if ( synPredMatched152 ) {
1552 >                                if ( synPredMatched158 ) {
1553                                          { // ( ... )+
1554 <                                        int _cnt154=0;
1554 >                                        int _cnt160=0;
1555                                          for (;;) {
1556                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1557                                                          matchRange('0','9');
1558                                                  }
1559                                                  else {
1560 <                                                        if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1560 >                                                        if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1561                                                  }
1562                                                  
1563 <                                                _cnt154++;
1563 >                                                _cnt160++;
1564                                          }
1565 <                                        _loop154:;
1565 >                                        _loop160:;
1566                                          }  // ( ... )+
1567                                  }
1568                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1569                                          { // ( ... )+
1570 <                                        int _cnt156=0;
1570 >                                        int _cnt162=0;
1571                                          for (;;) {
1572                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1573                                                          matchRange('0','7');
1574                                                  }
1575                                                  else {
1576 <                                                        if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1576 >                                                        if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1577                                                  }
1578                                                  
1579 <                                                _cnt156++;
1579 >                                                _cnt162++;
1580                                          }
1581 <                                        _loop156:;
1581 >                                        _loop162:;
1582                                          }  // ( ... )+
1583                                  }
1584                                  else {
# Line 1604 | Line 1606 | void MDLexer::mNUM_INT(bool _createToken) {
1606                                          matchRange('0','9');
1607                                  }
1608                                  else {
1609 <                                        goto _loop159;
1609 >                                        goto _loop165;
1610                                  }
1611                                  
1612                          }
1613 <                        _loop159:;
1613 >                        _loop165:;
1614                          } // ( ... )*
1615                          if ( inputState->guessing==0 ) {
1616 < #line 448 "MDParser.g"
1616 > #line 458 "MDParser.g"
1617                                  isDecimal=true;
1618 < #line 1617 "MDLexer.cpp"
1618 > #line 1619 "MDLexer.cpp"
1619                          }
1620                          break;
1621                  }
# Line 1644 | Line 1646 | void MDLexer::mNUM_INT(bool _createToken) {
1646                          }
1647                          }
1648                          if ( inputState->guessing==0 ) {
1649 < #line 450 "MDParser.g"
1649 > #line 460 "MDParser.g"
1650                                  _ttype = NUM_LONG;
1651 < #line 1650 "MDLexer.cpp"
1651 > #line 1652 "MDLexer.cpp"
1652                          }
1653                  }
1654                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1658 | Line 1660 | void MDLexer::mNUM_INT(bool _createToken) {
1660                                          mFLOAT_SUFFIX(true);
1661                                          f3=_returnToken;
1662                                          if ( inputState->guessing==0 ) {
1663 < #line 455 "MDParser.g"
1663 > #line 465 "MDParser.g"
1664                                                  t=f3;
1665 < #line 1664 "MDLexer.cpp"
1665 > #line 1666 "MDLexer.cpp"
1666                                          }
1667                                  }
1668                                  else {
# Line 1676 | Line 1678 | void MDLexer::mNUM_INT(bool _createToken) {
1678                                                  matchRange('0','9');
1679                                          }
1680                                          else {
1681 <                                                goto _loop164;
1681 >                                                goto _loop170;
1682                                          }
1683                                          
1684                                  }
1685 <                                _loop164:;
1685 >                                _loop170:;
1686                                  } // ( ... )*
1687                                  {
1688                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1695 | Line 1697 | void MDLexer::mNUM_INT(bool _createToken) {
1697                                          mFLOAT_SUFFIX(true);
1698                                          f2=_returnToken;
1699                                          if ( inputState->guessing==0 ) {
1700 < #line 454 "MDParser.g"
1700 > #line 464 "MDParser.g"
1701                                                  t=f2;
1702 < #line 1701 "MDLexer.cpp"
1702 > #line 1703 "MDLexer.cpp"
1703                                          }
1704                                  }
1705                                  else {
# Line 1709 | Line 1711 | void MDLexer::mNUM_INT(bool _createToken) {
1711                                  mFLOAT_SUFFIX(true);
1712                                  f4=_returnToken;
1713                                  if ( inputState->guessing==0 ) {
1714 < #line 456 "MDParser.g"
1714 > #line 466 "MDParser.g"
1715                                          t=f4;
1716 < #line 1715 "MDLexer.cpp"
1716 > #line 1717 "MDLexer.cpp"
1717                                  }
1718                          }
1719                          else {
# Line 1720 | Line 1722 | void MDLexer::mNUM_INT(bool _createToken) {
1722                          
1723                          }
1724                          if ( inputState->guessing==0 ) {
1725 < #line 458 "MDParser.g"
1725 > #line 468 "MDParser.g"
1726                                  
1727                                                                          if ( t &&
1728                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1731 | Line 1733 | void MDLexer::mNUM_INT(bool _createToken) {
1733                                                                                  _ttype = NUM_DOUBLE; // assume double
1734                                                                          }
1735                                                                  
1736 < #line 1735 "MDLexer.cpp"
1736 > #line 1737 "MDLexer.cpp"
1737                          }
1738                  }
1739                  else {
# Line 1819 | Line 1821 | void MDLexer::mEXPONENT(bool _createToken) {
1821          }
1822          }
1823          { // ( ... )+
1824 <        int _cnt172=0;
1824 >        int _cnt178=0;
1825          for (;;) {
1826                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1827                          matchRange('0','9');
1828                  }
1829                  else {
1830 <                        if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1830 >                        if ( _cnt178>=1 ) { goto _loop178; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1831                  }
1832                  
1833 <                _cnt172++;
1833 >                _cnt178++;
1834          }
1835 <        _loop172:;
1835 >        _loop178:;
1836          }  // ( ... )+
1837          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1838             _token = makeToken(_ttype);
# Line 1883 | Line 1885 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1885   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1886   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1887   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1888 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1888 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7
1889   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1890   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1891   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1892   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1893 < // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1893 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1894   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1895   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1896 < // \" \' 0 1 2 3 4 5
1896 > // \" \' 0 1 2 3 4 5 6 7
1897   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1898   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1899   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1900   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1901 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1901 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7
1902   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1903   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1904 < // \' 0 1 2 3 4 5
1904 > // \' 0 1 2 3 4 5 6 7
1905   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1906   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1907   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1908   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1909 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1909 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7
1910   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1911   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1913   const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914 < // + - 0 1 2 3 4 5
1914 > // + - 0 1 2 3 4 5 6 7
1915   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1916   const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1918   const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1919 < // 0 1 2 3 4 5
1919 > // 0 1 2 3 4 5 6 7
1920   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1921   const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1922   // .

Diff Legend

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