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 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC vs.
Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20110725): "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 479 | Line 479 | void MDLexer::mWhitespace(bool _createToken) {
479                  
480                  }
481                  if ( inputState->guessing==0 ) {
482 < #line 248 "MDParser.g"
482 > #line 253 "MDParser.g"
483                          newline();
484   #line 485 "MDLexer.cpp"
485                  }
# Line 507 | Line 507 | void MDLexer::mWhitespace(bool _createToken) {
507                  
508                  }
509                  if ( inputState->guessing==0 ) {
510 < #line 253 "MDParser.g"
510 > #line 258 "MDParser.g"
511                          printf("CPP_parser.g continuation line detected\n");
512                          deferredNewline();
513   #line 514 "MDLexer.cpp"
# Line 521 | Line 521 | void MDLexer::mWhitespace(bool _createToken) {
521          }
522          }
523          if ( inputState->guessing==0 ) {
524 < #line 256 "MDParser.g"
524 > #line 261 "MDParser.g"
525                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
526   #line 527 "MDLexer.cpp"
527          }
# Line 547 | 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 263 "MDParser.g"
550 > #line 268 "MDParser.g"
551                                  deferredNewline();
552   #line 553 "MDLexer.cpp"
553                          }
# Line 558 | Line 558 | void MDLexer::mComment(bool _createToken) {
558                          }
559                  }
560                  else {
561 <                        goto _loop95;
561 >                        goto _loop96;
562                  }
563                  
564          }
565 <        _loop95:;
565 >        _loop96:;
566          } // ( ... )*
567          match("*/");
568          if ( inputState->guessing==0 ) {
569 < #line 266 "MDParser.g"
569 > #line 271 "MDParser.g"
570                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
571   #line 572 "MDLexer.cpp"
572          }
# Line 620 | Line 620 | void MDLexer::mCPPComment(bool _createToken) {
620                          }
621                  }
622                  else {
623 <                        goto _loop99;
623 >                        goto _loop100;
624                  }
625                  
626          }
627 <        _loop99:;
627 >        _loop100:;
628          } // ( ... )*
629          mEndOfLine(false);
630          if ( inputState->guessing==0 ) {
631 < #line 272 "MDParser.g"
631 > #line 277 "MDParser.g"
632                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
633   #line 634 "MDLexer.cpp"
634          }
# Line 648 | Line 648 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
648          match('#' /* charlit */ );
649          mLineDirective(false);
650          if ( inputState->guessing==0 ) {
651 < #line 279 "MDParser.g"
651 > #line 284 "MDParser.g"
652                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
653   #line 654 "MDLexer.cpp"
654          }
# Line 668 | Line 668 | void MDLexer::mLineDirective(bool _createToken) {
668          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
669          
670          if ( inputState->guessing==0 ) {
671 < #line 285 "MDParser.g"
671 > #line 290 "MDParser.g"
672                  
673                  deferredLineCount = 0;
674                  
# Line 694 | Line 694 | void MDLexer::mLineDirective(bool _createToken) {
694          }
695          }
696          { // ( ... )+
697 <        int _cnt104=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 ( _cnt104>=1 ) { goto _loop104; } 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 <                _cnt104++;
706 >                _cnt105++;
707          }
708 <        _loop104:;
708 >        _loop105:;
709          }  // ( ... )+
710          mDecimal(true);
711          n=_returnToken;
712          if ( inputState->guessing==0 ) {
713 < #line 290 "MDParser.g"
713 > #line 295 "MDParser.g"
714                  setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
715   #line 716 "MDLexer.cpp"
716          }
717          { // ( ... )+
718 <        int _cnt106=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 ( _cnt106>=1 ) { goto _loop106; } 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 <                _cnt106++;
727 >                _cnt107++;
728          }
729 <        _loop106:;
729 >        _loop107:;
730          }  // ( ... )+
731          {
732          mStringLiteral(true);
733          sl=_returnToken;
734          }
735          if ( inputState->guessing==0 ) {
736 < #line 292 "MDParser.g"
736 > #line 297 "MDParser.g"
737                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
738   #line 739 "MDLexer.cpp"
739          }
# Line 741 | Line 741 | void MDLexer::mLineDirective(bool _createToken) {
741          for (;;) {
742                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
743                          { // ( ... )+
744 <                        int _cnt110=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 ( _cnt110>=1 ) { goto _loop110; } 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 <                                _cnt110++;
753 >                                _cnt111++;
754                          }
755 <                        _loop110:;
755 >                        _loop111:;
756                          }  // ( ... )+
757                          mDecimal(false);
758                  }
759                  else {
760 <                        goto _loop111;
760 >                        goto _loop112;
761                  }
762                  
763          }
764 <        _loop111:;
764 >        _loop112:;
765          } // ( ... )*
766          mEndOfLine(false);
767          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 814 | Line 814 | void MDLexer::mDecimal(bool _createToken) {
814          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
815          
816          { // ( ... )+
817 <        int _cnt141=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 ( _cnt141>=1 ) { goto _loop141; } 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 <                _cnt141++;
826 >                _cnt142++;
827          }
828 <        _loop141:;
828 >        _loop142:;
829          }  // ( ... )+
830          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
831             _token = makeToken(_ttype);
# Line 863 | Line 863 | void MDLexer::mStringLiteral(bool _createToken) {
863                          
864                          }
865                          if ( inputState->guessing==0 ) {
866 < #line 332 "MDParser.g"
866 > #line 337 "MDParser.g"
867                                  deferredNewline();
868   #line 869 "MDLexer.cpp"
869                          }
# Line 874 | Line 874 | void MDLexer::mStringLiteral(bool _createToken) {
874                          }
875                  }
876                  else {
877 <                        goto _loop121;
877 >                        goto _loop122;
878                  }
879                  
880          }
881 <        _loop121:;
881 >        _loop122:;
882          } // ( ... )*
883          match('\"' /* charlit */ );
884          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1038 | Line 1038 | void MDLexer::mEscape(bool _createToken) {
1038          {
1039                  match('x' /* charlit */ );
1040                  { // ( ... )+
1041 <                int _cnt132=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 1050 | Line 1050 | void MDLexer::mEscape(bool _createToken) {
1050                                  matchRange('A','F');
1051                          }
1052                          else {
1053 <                                if ( _cnt132>=1 ) { goto _loop132; } 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 <                        _cnt132++;
1056 >                        _cnt133++;
1057                  }
1058 <                _loop132:;
1058 >                _loop133:;
1059                  }  // ( ... )+
1060                  break;
1061          }
# Line 1263 | Line 1263 | void MDLexer::mID(bool _createToken) {
1263                  }
1264                  default:
1265                  {
1266 <                        goto _loop137;
1266 >                        goto _loop138;
1267                  }
1268                  }
1269          }
1270 <        _loop137:;
1270 >        _loop138:;
1271          } // ( ... )*
1272          _ttype = testLiteralsTable(_ttype);
1273          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1341 | 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 425 "MDParser.g"
1344 > #line 430 "MDParser.g"
1345          
1346                          bool isDecimal = false;
1347                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
# Line 1386 | Line 1386 | void MDLexer::mNUM_INT(bool _createToken) {
1386          {
1387                  match('.' /* charlit */ );
1388                  if ( inputState->guessing==0 ) {
1389 < #line 432 "MDParser.g"
1389 > #line 437 "MDParser.g"
1390                          _ttype = DOT;
1391   #line 1392 "MDLexer.cpp"
1392                  }
1393                  {
1394                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1395                          { // ( ... )+
1396 <                        int _cnt149=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 ( _cnt149>=1 ) { goto _loop149; } 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 <                                _cnt149++;
1405 >                                _cnt150++;
1406                          }
1407 <                        _loop149:;
1407 >                        _loop150:;
1408                          }  // ( ... )+
1409                          {
1410                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1419 | Line 1419 | void MDLexer::mNUM_INT(bool _createToken) {
1419                                  mFLOAT_SUFFIX(true);
1420                                  f1=_returnToken;
1421                                  if ( inputState->guessing==0 ) {
1422 < #line 433 "MDParser.g"
1422 > #line 438 "MDParser.g"
1423                                          t=f1;
1424   #line 1425 "MDLexer.cpp"
1425                                  }
# Line 1429 | Line 1429 | void MDLexer::mNUM_INT(bool _createToken) {
1429                          
1430                          }
1431                          if ( inputState->guessing==0 ) {
1432 < #line 434 "MDParser.g"
1432 > #line 439 "MDParser.g"
1433                                  
1434                                                                          if ( t &&
1435                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1466 | Line 1466 | void MDLexer::mNUM_INT(bool _createToken) {
1466                  {
1467                          match('0' /* charlit */ );
1468                          if ( inputState->guessing==0 ) {
1469 < #line 446 "MDParser.g"
1469 > #line 451 "MDParser.g"
1470                                  isDecimal = true;
1471   #line 1472 "MDLexer.cpp"
1472                          }
# Line 1491 | Line 1491 | void MDLexer::mNUM_INT(bool _createToken) {
1491                                  }
1492                                  }
1493                                  { // ( ... )+
1494 <                                int _cnt156=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 ( _cnt156>=1 ) { goto _loop156; } 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 <                                        _cnt156++;
1503 >                                        _cnt157++;
1504                                  }
1505 <                                _loop156:;
1505 >                                _loop157:;
1506                                  }  // ( ... )+
1507                          }
1508                          else {
1509 <                                bool synPredMatched161 = false;
1509 >                                bool synPredMatched162 = false;
1510                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1511 <                                        int _m161 = mark();
1512 <                                        synPredMatched161 = true;
1511 >                                        int _m162 = mark();
1512 >                                        synPredMatched162 = true;
1513                                          inputState->guessing++;
1514                                          try {
1515                                                  {
1516                                                  { // ( ... )+
1517 <                                                int _cnt159=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 ( _cnt159>=1 ) { goto _loop159; } 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 <                                                        _cnt159++;
1526 >                                                        _cnt160++;
1527                                                  }
1528 <                                                _loop159:;
1528 >                                                _loop160:;
1529                                                  }  // ( ... )+
1530                                                  {
1531                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1545 | Line 1545 | void MDLexer::mNUM_INT(bool _createToken) {
1545                                                  }
1546                                          }
1547                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1548 <                                                synPredMatched161 = false;
1548 >                                                synPredMatched162 = false;
1549                                          }
1550 <                                        rewind(_m161);
1550 >                                        rewind(_m162);
1551                                          inputState->guessing--;
1552                                  }
1553 <                                if ( synPredMatched161 ) {
1553 >                                if ( synPredMatched162 ) {
1554                                          { // ( ... )+
1555 <                                        int _cnt163=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 ( _cnt163>=1 ) { goto _loop163; } 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 <                                                _cnt163++;
1564 >                                                _cnt164++;
1565                                          }
1566 <                                        _loop163:;
1566 >                                        _loop164:;
1567                                          }  // ( ... )+
1568                                  }
1569                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1570                                          { // ( ... )+
1571 <                                        int _cnt165=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 ( _cnt165>=1 ) { goto _loop165; } 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 <                                                _cnt165++;
1580 >                                                _cnt166++;
1581                                          }
1582 <                                        _loop165:;
1582 >                                        _loop166:;
1583                                          }  // ( ... )+
1584                                  }
1585                                  else {
# Line 1607 | Line 1607 | void MDLexer::mNUM_INT(bool _createToken) {
1607                                          matchRange('0','9');
1608                                  }
1609                                  else {
1610 <                                        goto _loop168;
1610 >                                        goto _loop169;
1611                                  }
1612                                  
1613                          }
1614 <                        _loop168:;
1614 >                        _loop169:;
1615                          } // ( ... )*
1616                          if ( inputState->guessing==0 ) {
1617 < #line 463 "MDParser.g"
1617 > #line 468 "MDParser.g"
1618                                  isDecimal=true;
1619   #line 1620 "MDLexer.cpp"
1620                          }
# Line 1647 | Line 1647 | void MDLexer::mNUM_INT(bool _createToken) {
1647                          }
1648                          }
1649                          if ( inputState->guessing==0 ) {
1650 < #line 465 "MDParser.g"
1650 > #line 470 "MDParser.g"
1651                                  _ttype = NUM_LONG;
1652   #line 1653 "MDLexer.cpp"
1653                          }
# Line 1661 | Line 1661 | void MDLexer::mNUM_INT(bool _createToken) {
1661                                          mFLOAT_SUFFIX(true);
1662                                          f3=_returnToken;
1663                                          if ( inputState->guessing==0 ) {
1664 < #line 470 "MDParser.g"
1664 > #line 475 "MDParser.g"
1665                                                  t=f3;
1666   #line 1667 "MDLexer.cpp"
1667                                          }
# Line 1679 | Line 1679 | void MDLexer::mNUM_INT(bool _createToken) {
1679                                                  matchRange('0','9');
1680                                          }
1681                                          else {
1682 <                                                goto _loop173;
1682 >                                                goto _loop174;
1683                                          }
1684                                          
1685                                  }
1686 <                                _loop173:;
1686 >                                _loop174:;
1687                                  } // ( ... )*
1688                                  {
1689                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1698 | Line 1698 | void MDLexer::mNUM_INT(bool _createToken) {
1698                                          mFLOAT_SUFFIX(true);
1699                                          f2=_returnToken;
1700                                          if ( inputState->guessing==0 ) {
1701 < #line 469 "MDParser.g"
1701 > #line 474 "MDParser.g"
1702                                                  t=f2;
1703   #line 1704 "MDLexer.cpp"
1704                                          }
# Line 1712 | Line 1712 | void MDLexer::mNUM_INT(bool _createToken) {
1712                                  mFLOAT_SUFFIX(true);
1713                                  f4=_returnToken;
1714                                  if ( inputState->guessing==0 ) {
1715 < #line 471 "MDParser.g"
1715 > #line 476 "MDParser.g"
1716                                          t=f4;
1717   #line 1718 "MDLexer.cpp"
1718                                  }
# Line 1723 | Line 1723 | void MDLexer::mNUM_INT(bool _createToken) {
1723                          
1724                          }
1725                          if ( inputState->guessing==0 ) {
1726 < #line 473 "MDParser.g"
1726 > #line 478 "MDParser.g"
1727                                  
1728                                                                          if ( t &&
1729                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1822 | Line 1822 | void MDLexer::mEXPONENT(bool _createToken) {
1822          }
1823          }
1824          { // ( ... )+
1825 <        int _cnt181=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 ( _cnt181>=1 ) { goto _loop181; } 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 <                _cnt181++;
1834 >                _cnt182++;
1835          }
1836 <        _loop181:;
1836 >        _loop182:;
1837          }  // ( ... )+
1838          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1839             _token = makeToken(_ttype);

Diff Legend

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