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

Comparing trunk/src/mdParser/MDLexer.cpp (file contents):
Revision 1978 by gezelter, Wed Feb 26 14:14:50 2014 UTC vs.
Revision 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20121118): "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20140107): "MDParser.g" -> "MDLexer.cpp"$ */
2   #include "MDLexer.hpp"
3   #include <antlr/CharBuffer.hpp>
4   #include <antlr/TokenStreamException.hpp>
# Line 17 | Line 17 | MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer
17   }
18  
19   MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
20 <  : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib, true)
20 >        : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
21   {
22          initLiterals();
23   }
# Line 30 | Line 30 | void MDLexer::initLiterals()
30  
31   void MDLexer::initLiterals()
32   {
33 <        literals["flucQ"] = 21;
34 <        literals["satellites"] = 18;
33 >        literals["flucQ"] = 23;
34 >        literals["satellites"] = 20;
35          literals["cutoffGroup"] = 14;
36 <        literals["RNEMD"] = 22;
36 >        literals["RNEMD"] = 24;
37 >        literals["constraint"] = 15;
38 >        literals["distance"] = 16;
39          literals["rigidBody"] = 13;
40 <        literals["fragment"] = 15;
40 >        literals["fragment"] = 17;
41          literals["zconstraint"] = 6;
42 <        literals["minimizer"] = 23;
42 >        literals["minimizer"] = 25;
43          literals["component"] = 4;
44 <        literals["center"] = 17;
45 <        literals["members"] = 16;
46 <        literals["position"] = 19;
47 <        literals["orientation"] = 20;
44 >        literals["center"] = 19;
45 >        literals["members"] = 18;
46 >        literals["position"] = 21;
47 >        literals["orientation"] = 22;
48          literals["bend"] = 10;
49          literals["torsion"] = 11;
50          literals["atom"] = 8;
# Line 480 | Line 482 | void MDLexer::mWhitespace(bool _createToken) {
482                  
483                  }
484                  if ( inputState->guessing==0 ) {
485 < #line 255 "MDParser.g"
485 > #line 264 "MDParser.g"
486                          newline();
487 < #line 486 "MDLexer.cpp"
487 > #line 488 "MDLexer.cpp"
488                  }
489                  break;
490          }
# Line 508 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510                  
511                  }
512                  if ( inputState->guessing==0 ) {
513 < #line 260 "MDParser.g"
513 > #line 269 "MDParser.g"
514                          printf("CPP_parser.g continuation line detected\n");
515                          deferredNewline();
516 < #line 515 "MDLexer.cpp"
516 > #line 517 "MDLexer.cpp"
517                  }
518                  break;
519          }
# Line 522 | Line 524 | void MDLexer::mWhitespace(bool _createToken) {
524          }
525          }
526          if ( inputState->guessing==0 ) {
527 < #line 263 "MDParser.g"
527 > #line 272 "MDParser.g"
528                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
529 < #line 528 "MDLexer.cpp"
529 > #line 530 "MDLexer.cpp"
530          }
531          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
532             _token = makeToken(_ttype);
# Line 548 | Line 550 | void MDLexer::mComment(bool _createToken) {
550                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
551                          mEndOfLine(false);
552                          if ( inputState->guessing==0 ) {
553 < #line 270 "MDParser.g"
553 > #line 279 "MDParser.g"
554                                  deferredNewline();
555 < #line 554 "MDLexer.cpp"
555 > #line 556 "MDLexer.cpp"
556                          }
557                  }
558                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 559 | Line 561 | void MDLexer::mComment(bool _createToken) {
561                          }
562                  }
563                  else {
564 <                        goto _loop96;
564 >                        goto _loop101;
565                  }
566                  
567          }
568 <        _loop96:;
568 >        _loop101:;
569          } // ( ... )*
570          match("*/");
571          if ( inputState->guessing==0 ) {
572 < #line 273 "MDParser.g"
572 > #line 282 "MDParser.g"
573                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
574 < #line 573 "MDLexer.cpp"
574 > #line 575 "MDLexer.cpp"
575          }
576          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
577             _token = makeToken(_ttype);
# Line 621 | Line 623 | void MDLexer::mCPPComment(bool _createToken) {
623                          }
624                  }
625                  else {
626 <                        goto _loop100;
626 >                        goto _loop105;
627                  }
628                  
629          }
630 <        _loop100:;
630 >        _loop105:;
631          } // ( ... )*
632          mEndOfLine(false);
633          if ( inputState->guessing==0 ) {
634 < #line 279 "MDParser.g"
634 > #line 288 "MDParser.g"
635                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
636 < #line 635 "MDLexer.cpp"
636 > #line 637 "MDLexer.cpp"
637          }
638          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
639             _token = makeToken(_ttype);
# Line 649 | Line 651 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
651          match('#' /* charlit */ );
652          mLineDirective(false);
653          if ( inputState->guessing==0 ) {
654 < #line 286 "MDParser.g"
654 > #line 295 "MDParser.g"
655                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
656 < #line 655 "MDLexer.cpp"
656 > #line 657 "MDLexer.cpp"
657          }
658          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
659             _token = makeToken(_ttype);
# Line 669 | Line 671 | void MDLexer::mLineDirective(bool _createToken) {
671          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
672          
673          if ( inputState->guessing==0 ) {
674 < #line 292 "MDParser.g"
674 > #line 301 "MDParser.g"
675                  
676                  deferredLineCount = 0;
677                  
678 < #line 677 "MDLexer.cpp"
678 > #line 679 "MDLexer.cpp"
679          }
680          {
681          switch ( LA(1)) {
# Line 695 | Line 697 | void MDLexer::mLineDirective(bool _createToken) {
697          }
698          }
699          { // ( ... )+
700 <        int _cnt105=0;
700 >        int _cnt110=0;
701          for (;;) {
702                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
703                          mSpace(false);
704                  }
705                  else {
706 <                        if ( _cnt105>=1 ) { goto _loop105; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
706 >                        if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
707                  }
708                  
709 <                _cnt105++;
709 >                _cnt110++;
710          }
711 <        _loop105:;
711 >        _loop110:;
712          }  // ( ... )+
713          mDecimal(true);
714          n=_returnToken;
715          if ( inputState->guessing==0 ) {
716 < #line 297 "MDParser.g"
716 > #line 306 "MDParser.g"
717                  setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
718 < #line 717 "MDLexer.cpp"
718 > #line 719 "MDLexer.cpp"
719          }
720          { // ( ... )+
721 <        int _cnt107=0;
721 >        int _cnt112=0;
722          for (;;) {
723                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
724                          mSpace(false);
725                  }
726                  else {
727 <                        if ( _cnt107>=1 ) { goto _loop107; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
727 >                        if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
728                  }
729                  
730 <                _cnt107++;
730 >                _cnt112++;
731          }
732 <        _loop107:;
732 >        _loop112:;
733          }  // ( ... )+
734          {
735          mStringLiteral(true);
736          sl=_returnToken;
737          }
738          if ( inputState->guessing==0 ) {
739 < #line 299 "MDParser.g"
739 > #line 308 "MDParser.g"
740                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
741 < #line 740 "MDLexer.cpp"
741 > #line 742 "MDLexer.cpp"
742          }
743          { // ( ... )*
744          for (;;) {
745                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746                          { // ( ... )+
747 <                        int _cnt111=0;
747 >                        int _cnt116=0;
748                          for (;;) {
749                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
750                                          mSpace(false);
751                                  }
752                                  else {
753 <                                        if ( _cnt111>=1 ) { goto _loop111; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
753 >                                        if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
754                                  }
755                                  
756 <                                _cnt111++;
756 >                                _cnt116++;
757                          }
758 <                        _loop111:;
758 >                        _loop116:;
759                          }  // ( ... )+
760                          mDecimal(false);
761                  }
762                  else {
763 <                        goto _loop112;
763 >                        goto _loop117;
764                  }
765                  
766          }
767 <        _loop112:;
767 >        _loop117:;
768          } // ( ... )*
769          mEndOfLine(false);
770          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 815 | Line 817 | void MDLexer::mDecimal(bool _createToken) {
817          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
818          
819          { // ( ... )+
820 <        int _cnt142=0;
820 >        int _cnt147=0;
821          for (;;) {
822                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
823                          matchRange('0','9');
824                  }
825                  else {
826 <                        if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
826 >                        if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
827                  }
828                  
829 <                _cnt142++;
829 >                _cnt147++;
830          }
831 <        _loop142:;
831 >        _loop147:;
832          }  // ( ... )+
833          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
834             _token = makeToken(_ttype);
# Line 864 | Line 866 | void MDLexer::mStringLiteral(bool _createToken) {
866                          
867                          }
868                          if ( inputState->guessing==0 ) {
869 < #line 339 "MDParser.g"
869 > #line 348 "MDParser.g"
870                                  deferredNewline();
871 < #line 870 "MDLexer.cpp"
871 > #line 872 "MDLexer.cpp"
872                          }
873                  }
874                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 875 | Line 877 | void MDLexer::mStringLiteral(bool _createToken) {
877                          }
878                  }
879                  else {
880 <                        goto _loop122;
880 >                        goto _loop127;
881                  }
882                  
883          }
884 <        _loop122:;
884 >        _loop127:;
885          } // ( ... )*
886          match('\"' /* charlit */ );
887          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1039 | Line 1041 | void MDLexer::mEscape(bool _createToken) {
1041          {
1042                  match('x' /* charlit */ );
1043                  { // ( ... )+
1044 <                int _cnt133=0;
1044 >                int _cnt138=0;
1045                  for (;;) {
1046                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1047                                  mDigit(false);
# Line 1051 | Line 1053 | void MDLexer::mEscape(bool _createToken) {
1053                                  matchRange('A','F');
1054                          }
1055                          else {
1056 <                                if ( _cnt133>=1 ) { goto _loop133; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1056 >                                if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1057                          }
1058                          
1059 <                        _cnt133++;
1059 >                        _cnt138++;
1060                  }
1061 <                _loop133:;
1061 >                _loop138:;
1062                  }  // ( ... )+
1063                  break;
1064          }
# Line 1264 | Line 1266 | void MDLexer::mID(bool _createToken) {
1266                  }
1267                  default:
1268                  {
1269 <                        goto _loop138;
1269 >                        goto _loop143;
1270                  }
1271                  }
1272          }
1273 <        _loop138:;
1273 >        _loop143:;
1274          } // ( ... )*
1275          _ttype = testLiteralsTable(_ttype);
1276          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1342 | Line 1344 | void MDLexer::mNUM_INT(bool _createToken) {
1344          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1345          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1346          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1347 < #line 432 "MDParser.g"
1347 > #line 441 "MDParser.g"
1348          
1349                          bool isDecimal = false;
1350                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1351                  
1352 < #line 1351 "MDLexer.cpp"
1352 > #line 1353 "MDLexer.cpp"
1353          
1354          {
1355          switch ( LA(1)) {
# Line 1387 | Line 1389 | void MDLexer::mNUM_INT(bool _createToken) {
1389          {
1390                  match('.' /* charlit */ );
1391                  if ( inputState->guessing==0 ) {
1392 < #line 439 "MDParser.g"
1392 > #line 448 "MDParser.g"
1393                          _ttype = DOT;
1394 < #line 1393 "MDLexer.cpp"
1394 > #line 1395 "MDLexer.cpp"
1395                  }
1396                  {
1397                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398                          { // ( ... )+
1399 <                        int _cnt150=0;
1399 >                        int _cnt155=0;
1400                          for (;;) {
1401                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1402                                          matchRange('0','9');
1403                                  }
1404                                  else {
1405 <                                        if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1405 >                                        if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1406                                  }
1407                                  
1408 <                                _cnt150++;
1408 >                                _cnt155++;
1409                          }
1410 <                        _loop150:;
1410 >                        _loop155:;
1411                          }  // ( ... )+
1412                          {
1413                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1420 | Line 1422 | void MDLexer::mNUM_INT(bool _createToken) {
1422                                  mFLOAT_SUFFIX(true);
1423                                  f1=_returnToken;
1424                                  if ( inputState->guessing==0 ) {
1425 < #line 440 "MDParser.g"
1425 > #line 449 "MDParser.g"
1426                                          t=f1;
1427 < #line 1426 "MDLexer.cpp"
1427 > #line 1428 "MDLexer.cpp"
1428                                  }
1429                          }
1430                          else {
# Line 1430 | Line 1432 | void MDLexer::mNUM_INT(bool _createToken) {
1432                          
1433                          }
1434                          if ( inputState->guessing==0 ) {
1435 < #line 441 "MDParser.g"
1435 > #line 450 "MDParser.g"
1436                                  
1437                                                                          if ( t &&
1438                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1441 | Line 1443 | void MDLexer::mNUM_INT(bool _createToken) {
1443                                                                                  _ttype = NUM_DOUBLE; // assume double
1444                                                                          }
1445                                                                  
1446 < #line 1445 "MDLexer.cpp"
1446 > #line 1447 "MDLexer.cpp"
1447                          }
1448                  }
1449                  else {
# Line 1467 | Line 1469 | void MDLexer::mNUM_INT(bool _createToken) {
1469                  {
1470                          match('0' /* charlit */ );
1471                          if ( inputState->guessing==0 ) {
1472 < #line 453 "MDParser.g"
1472 > #line 462 "MDParser.g"
1473                                  isDecimal = true;
1474 < #line 1473 "MDLexer.cpp"
1474 > #line 1475 "MDLexer.cpp"
1475                          }
1476                          {
1477                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1492 | Line 1494 | void MDLexer::mNUM_INT(bool _createToken) {
1494                                  }
1495                                  }
1496                                  { // ( ... )+
1497 <                                int _cnt157=0;
1497 >                                int _cnt162=0;
1498                                  for (;;) {
1499                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1500                                                  mHEX_DIGIT(false);
1501                                          }
1502                                          else {
1503 <                                                if ( _cnt157>=1 ) { goto _loop157; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1503 >                                                if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1504                                          }
1505                                          
1506 <                                        _cnt157++;
1506 >                                        _cnt162++;
1507                                  }
1508 <                                _loop157:;
1508 >                                _loop162:;
1509                                  }  // ( ... )+
1510                          }
1511                          else {
1512 <                                bool synPredMatched162 = false;
1512 >                                bool synPredMatched167 = false;
1513                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1514 <                                        int _m162 = mark();
1515 <                                        synPredMatched162 = true;
1514 >                                        int _m167 = mark();
1515 >                                        synPredMatched167 = true;
1516                                          inputState->guessing++;
1517                                          try {
1518                                                  {
1519                                                  { // ( ... )+
1520 <                                                int _cnt160=0;
1520 >                                                int _cnt165=0;
1521                                                  for (;;) {
1522                                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1523                                                                  matchRange('0','9');
1524                                                          }
1525                                                          else {
1526 <                                                                if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1526 >                                                                if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1527                                                          }
1528                                                          
1529 <                                                        _cnt160++;
1529 >                                                        _cnt165++;
1530                                                  }
1531 <                                                _loop160:;
1531 >                                                _loop165:;
1532                                                  }  // ( ... )+
1533                                                  {
1534                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1546 | Line 1548 | void MDLexer::mNUM_INT(bool _createToken) {
1548                                                  }
1549                                          }
1550                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1551 <                                                synPredMatched162 = false;
1551 >                                                synPredMatched167 = false;
1552                                          }
1553 <                                        rewind(_m162);
1553 >                                        rewind(_m167);
1554                                          inputState->guessing--;
1555                                  }
1556 <                                if ( synPredMatched162 ) {
1556 >                                if ( synPredMatched167 ) {
1557                                          { // ( ... )+
1558 <                                        int _cnt164=0;
1558 >                                        int _cnt169=0;
1559                                          for (;;) {
1560                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1561                                                          matchRange('0','9');
1562                                                  }
1563                                                  else {
1564 <                                                        if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1564 >                                                        if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1565                                                  }
1566                                                  
1567 <                                                _cnt164++;
1567 >                                                _cnt169++;
1568                                          }
1569 <                                        _loop164:;
1569 >                                        _loop169:;
1570                                          }  // ( ... )+
1571                                  }
1572                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1573                                          { // ( ... )+
1574 <                                        int _cnt166=0;
1574 >                                        int _cnt171=0;
1575                                          for (;;) {
1576                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1577                                                          matchRange('0','7');
1578                                                  }
1579                                                  else {
1580 <                                                        if ( _cnt166>=1 ) { goto _loop166; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1580 >                                                        if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1581                                                  }
1582                                                  
1583 <                                                _cnt166++;
1583 >                                                _cnt171++;
1584                                          }
1585 <                                        _loop166:;
1585 >                                        _loop171:;
1586                                          }  // ( ... )+
1587                                  }
1588                                  else {
# Line 1608 | Line 1610 | void MDLexer::mNUM_INT(bool _createToken) {
1610                                          matchRange('0','9');
1611                                  }
1612                                  else {
1613 <                                        goto _loop169;
1613 >                                        goto _loop174;
1614                                  }
1615                                  
1616                          }
1617 <                        _loop169:;
1617 >                        _loop174:;
1618                          } // ( ... )*
1619                          if ( inputState->guessing==0 ) {
1620 < #line 470 "MDParser.g"
1620 > #line 479 "MDParser.g"
1621                                  isDecimal=true;
1622 < #line 1621 "MDLexer.cpp"
1622 > #line 1623 "MDLexer.cpp"
1623                          }
1624                          break;
1625                  }
# Line 1648 | Line 1650 | void MDLexer::mNUM_INT(bool _createToken) {
1650                          }
1651                          }
1652                          if ( inputState->guessing==0 ) {
1653 < #line 472 "MDParser.g"
1653 > #line 481 "MDParser.g"
1654                                  _ttype = NUM_LONG;
1655 < #line 1654 "MDLexer.cpp"
1655 > #line 1656 "MDLexer.cpp"
1656                          }
1657                  }
1658                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1662 | Line 1664 | void MDLexer::mNUM_INT(bool _createToken) {
1664                                          mFLOAT_SUFFIX(true);
1665                                          f3=_returnToken;
1666                                          if ( inputState->guessing==0 ) {
1667 < #line 477 "MDParser.g"
1667 > #line 486 "MDParser.g"
1668                                                  t=f3;
1669 < #line 1668 "MDLexer.cpp"
1669 > #line 1670 "MDLexer.cpp"
1670                                          }
1671                                  }
1672                                  else {
# Line 1680 | Line 1682 | void MDLexer::mNUM_INT(bool _createToken) {
1682                                                  matchRange('0','9');
1683                                          }
1684                                          else {
1685 <                                                goto _loop174;
1685 >                                                goto _loop179;
1686                                          }
1687                                          
1688                                  }
1689 <                                _loop174:;
1689 >                                _loop179:;
1690                                  } // ( ... )*
1691                                  {
1692                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1699 | Line 1701 | void MDLexer::mNUM_INT(bool _createToken) {
1701                                          mFLOAT_SUFFIX(true);
1702                                          f2=_returnToken;
1703                                          if ( inputState->guessing==0 ) {
1704 < #line 476 "MDParser.g"
1704 > #line 485 "MDParser.g"
1705                                                  t=f2;
1706 < #line 1705 "MDLexer.cpp"
1706 > #line 1707 "MDLexer.cpp"
1707                                          }
1708                                  }
1709                                  else {
# Line 1713 | Line 1715 | void MDLexer::mNUM_INT(bool _createToken) {
1715                                  mFLOAT_SUFFIX(true);
1716                                  f4=_returnToken;
1717                                  if ( inputState->guessing==0 ) {
1718 < #line 478 "MDParser.g"
1718 > #line 487 "MDParser.g"
1719                                          t=f4;
1720 < #line 1719 "MDLexer.cpp"
1720 > #line 1721 "MDLexer.cpp"
1721                                  }
1722                          }
1723                          else {
# Line 1724 | Line 1726 | void MDLexer::mNUM_INT(bool _createToken) {
1726                          
1727                          }
1728                          if ( inputState->guessing==0 ) {
1729 < #line 480 "MDParser.g"
1729 > #line 489 "MDParser.g"
1730                                  
1731                                                                          if ( t &&
1732                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1735 | Line 1737 | void MDLexer::mNUM_INT(bool _createToken) {
1737                                                                                  _ttype = NUM_DOUBLE; // assume double
1738                                                                          }
1739                                                                  
1740 < #line 1739 "MDLexer.cpp"
1740 > #line 1741 "MDLexer.cpp"
1741                          }
1742                  }
1743                  else {
# Line 1823 | Line 1825 | void MDLexer::mEXPONENT(bool _createToken) {
1825          }
1826          }
1827          { // ( ... )+
1828 <        int _cnt182=0;
1828 >        int _cnt187=0;
1829          for (;;) {
1830                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1831                          matchRange('0','9');
1832                  }
1833                  else {
1834 <                        if ( _cnt182>=1 ) { goto _loop182; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1834 >                        if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1835                  }
1836                  
1837 <                _cnt182++;
1837 >                _cnt187++;
1838          }
1839 <        _loop182:;
1839 >        _loop187:;
1840          }  // ( ... )+
1841          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1842             _token = makeToken(_ttype);
# Line 1887 | Line 1889 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1889   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1891   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1892 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9
1892 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1893   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1894   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1897 < // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1897 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1898   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1899   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900   // \" \' 0 1 2 3 4 5 6 7
# Line 1900 | Line 1902 | const unsigned long MDLexer::_tokenSet_3_data_[] = { 4
1902   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1904   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1905 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1905 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1906   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1907   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908   // \' 0 1 2 3 4 5 6 7 8 9
# Line 1908 | Line 1910 | const unsigned long MDLexer::_tokenSet_5_data_[] = { 4
1910   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1912   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1913 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1913 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1914   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1915   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);

Diff Legend

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