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 1558 by gezelter, Wed May 11 16:32:48 2011 UTC vs.
Revision 1782 by gezelter, Wed Aug 22 02:28:28 2012 UTC

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

Diff Legend

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