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 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC vs.
Revision 1360 by cli2, Mon Sep 7 16:31:51 2009 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20080702): "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDLexer.cpp"$ */
2   #include "MDLexer.hpp"
3   #include <antlr/CharBuffer.hpp>
4   #include <antlr/TokenStreamException.hpp>
# Line 30 | Line 30 | void MDLexer::initLiterals()
30  
31   void MDLexer::initLiterals()
32   {
33 <        literals["members"] = 15;
34 <        literals["position"] = 17;
35 <        literals["torsion"] = 10;
33 >        literals["members"] = 16;
34 >        literals["position"] = 18;
35 >        literals["torsion"] = 11;
36          literals["component"] = 4;
37 <        literals["rigidBody"] = 12;
38 <        literals["center"] = 16;
39 <        literals["inversion"] = 11;
37 >        literals["restraint"] = 7;
38 >        literals["rigidBody"] = 13;
39 >        literals["center"] = 17;
40 >        literals["inversion"] = 12;
41          literals["zconstraint"] = 6;
42 <        literals["cutoffGroup"] = 13;
43 <        literals["bend"] = 9;
44 <        literals["orientation"] = 18;
45 <        literals["fragment"] = 14;
46 <        literals["bond"] = 8;
42 >        literals["cutoffGroup"] = 14;
43 >        literals["bend"] = 10;
44 >        literals["orientation"] = 19;
45 >        literals["fragment"] = 15;
46 >        literals["bond"] = 9;
47          literals["molecule"] = 5;
48 <        literals["atom"] = 7;
48 >        literals["atom"] = 8;
49   }
50  
51   ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
# Line 475 | Line 476 | void MDLexer::mWhitespace(bool _createToken) {
476                  
477                  }
478                  if ( inputState->guessing==0 ) {
479 < #line 228 "MDParser.g"
479 > #line 233 "MDParser.g"
480                          newline();
481 < #line 481 "MDLexer.cpp"
481 > #line 482 "MDLexer.cpp"
482                  }
483                  break;
484          }
# Line 503 | Line 504 | void MDLexer::mWhitespace(bool _createToken) {
504                  
505                  }
506                  if ( inputState->guessing==0 ) {
507 < #line 233 "MDParser.g"
507 > #line 238 "MDParser.g"
508                          printf("CPP_parser.g continuation line detected\n");
509                          deferredNewline();
510 < #line 510 "MDLexer.cpp"
510 > #line 511 "MDLexer.cpp"
511                  }
512                  break;
513          }
# Line 517 | Line 518 | void MDLexer::mWhitespace(bool _createToken) {
518          }
519          }
520          if ( inputState->guessing==0 ) {
521 < #line 236 "MDParser.g"
521 > #line 241 "MDParser.g"
522                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
523 < #line 523 "MDLexer.cpp"
523 > #line 524 "MDLexer.cpp"
524          }
525          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
526             _token = makeToken(_ttype);
# Line 543 | Line 544 | void MDLexer::mComment(bool _createToken) {
544                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
545                          mEndOfLine(false);
546                          if ( inputState->guessing==0 ) {
547 < #line 243 "MDParser.g"
547 > #line 248 "MDParser.g"
548                                  deferredNewline();
549 < #line 549 "MDLexer.cpp"
549 > #line 550 "MDLexer.cpp"
550                          }
551                  }
552                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 554 | Line 555 | void MDLexer::mComment(bool _createToken) {
555                          }
556                  }
557                  else {
558 <                        goto _loop83;
558 >                        goto _loop86;
559                  }
560                  
561          }
562 <        _loop83:;
562 >        _loop86:;
563          } // ( ... )*
564          match("*/");
565          if ( inputState->guessing==0 ) {
566 < #line 246 "MDParser.g"
566 > #line 251 "MDParser.g"
567                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
568 < #line 568 "MDLexer.cpp"
568 > #line 569 "MDLexer.cpp"
569          }
570          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
571             _token = makeToken(_ttype);
# Line 616 | Line 617 | void MDLexer::mCPPComment(bool _createToken) {
617                          }
618                  }
619                  else {
620 <                        goto _loop87;
620 >                        goto _loop90;
621                  }
622                  
623          }
624 <        _loop87:;
624 >        _loop90:;
625          } // ( ... )*
626          mEndOfLine(false);
627          if ( inputState->guessing==0 ) {
628 < #line 252 "MDParser.g"
628 > #line 257 "MDParser.g"
629                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
630 < #line 630 "MDLexer.cpp"
630 > #line 631 "MDLexer.cpp"
631          }
632          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
633             _token = makeToken(_ttype);
# Line 644 | Line 645 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
645          match('#' /* charlit */ );
646          mLineDirective(false);
647          if ( inputState->guessing==0 ) {
648 < #line 259 "MDParser.g"
648 > #line 264 "MDParser.g"
649                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
650 < #line 650 "MDLexer.cpp"
650 > #line 651 "MDLexer.cpp"
651          }
652          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
653             _token = makeToken(_ttype);
# Line 664 | Line 665 | void MDLexer::mLineDirective(bool _createToken) {
665          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
666          
667          if ( inputState->guessing==0 ) {
668 < #line 265 "MDParser.g"
668 > #line 270 "MDParser.g"
669                  
670                  deferredLineCount = 0;
671                  
672 < #line 672 "MDLexer.cpp"
672 > #line 673 "MDLexer.cpp"
673          }
674          {
675          switch ( LA(1)) {
# Line 690 | Line 691 | void MDLexer::mLineDirective(bool _createToken) {
691          }
692          }
693          { // ( ... )+
694 <        int _cnt92=0;
694 >        int _cnt95=0;
695          for (;;) {
696                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
697                          mSpace(false);
698                  }
699                  else {
700 <                        if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
700 >                        if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
701                  }
702                  
703 <                _cnt92++;
703 >                _cnt95++;
704          }
705 <        _loop92:;
705 >        _loop95:;
706          }  // ( ... )+
707          mDecimal(true);
708          n=_returnToken;
709          if ( inputState->guessing==0 ) {
710 < #line 270 "MDParser.g"
710 > #line 275 "MDParser.g"
711                  setLine(oopse::lexi_cast<int>(n->getText()) - 1);
712 < #line 712 "MDLexer.cpp"
712 > #line 713 "MDLexer.cpp"
713          }
714          { // ( ... )+
715 <        int _cnt94=0;
715 >        int _cnt97=0;
716          for (;;) {
717                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
718                          mSpace(false);
719                  }
720                  else {
721 <                        if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
721 >                        if ( _cnt97>=1 ) { goto _loop97; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
722                  }
723                  
724 <                _cnt94++;
724 >                _cnt97++;
725          }
726 <        _loop94:;
726 >        _loop97:;
727          }  // ( ... )+
728          {
729          mStringLiteral(true);
730          sl=_returnToken;
731          }
732          if ( inputState->guessing==0 ) {
733 < #line 272 "MDParser.g"
733 > #line 277 "MDParser.g"
734                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
735 < #line 735 "MDLexer.cpp"
735 > #line 736 "MDLexer.cpp"
736          }
737          { // ( ... )*
738          for (;;) {
739                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
740                          { // ( ... )+
741 <                        int _cnt98=0;
741 >                        int _cnt101=0;
742                          for (;;) {
743                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
744                                          mSpace(false);
745                                  }
746                                  else {
747 <                                        if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
747 >                                        if ( _cnt101>=1 ) { goto _loop101; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
748                                  }
749                                  
750 <                                _cnt98++;
750 >                                _cnt101++;
751                          }
752 <                        _loop98:;
752 >                        _loop101:;
753                          }  // ( ... )+
754                          mDecimal(false);
755                  }
756                  else {
757 <                        goto _loop99;
757 >                        goto _loop102;
758                  }
759                  
760          }
761 <        _loop99:;
761 >        _loop102:;
762          } // ( ... )*
763          mEndOfLine(false);
764          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 810 | Line 811 | void MDLexer::mDecimal(bool _createToken) {
811          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
812          
813          { // ( ... )+
814 <        int _cnt129=0;
814 >        int _cnt132=0;
815          for (;;) {
816                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
817                          matchRange('0','9');
818                  }
819                  else {
820 <                        if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
820 >                        if ( _cnt132>=1 ) { goto _loop132; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
821                  }
822                  
823 <                _cnt129++;
823 >                _cnt132++;
824          }
825 <        _loop129:;
825 >        _loop132:;
826          }  // ( ... )+
827          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
828             _token = makeToken(_ttype);
# Line 859 | Line 860 | void MDLexer::mStringLiteral(bool _createToken) {
860                          
861                          }
862                          if ( inputState->guessing==0 ) {
863 < #line 312 "MDParser.g"
863 > #line 317 "MDParser.g"
864                                  deferredNewline();
865 < #line 865 "MDLexer.cpp"
865 > #line 866 "MDLexer.cpp"
866                          }
867                  }
868                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 870 | Line 871 | void MDLexer::mStringLiteral(bool _createToken) {
871                          }
872                  }
873                  else {
874 <                        goto _loop109;
874 >                        goto _loop112;
875                  }
876                  
877          }
878 <        _loop109:;
878 >        _loop112:;
879          } // ( ... )*
880          match('\"' /* charlit */ );
881          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1034 | Line 1035 | void MDLexer::mEscape(bool _createToken) {
1035          {
1036                  match('x' /* charlit */ );
1037                  { // ( ... )+
1038 <                int _cnt120=0;
1038 >                int _cnt123=0;
1039                  for (;;) {
1040                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1041                                  mDigit(false);
# Line 1046 | Line 1047 | void MDLexer::mEscape(bool _createToken) {
1047                                  matchRange('A','F');
1048                          }
1049                          else {
1050 <                                if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1050 >                                if ( _cnt123>=1 ) { goto _loop123; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1051                          }
1052                          
1053 <                        _cnt120++;
1053 >                        _cnt123++;
1054                  }
1055 <                _loop120:;
1055 >                _loop123:;
1056                  }  // ( ... )+
1057                  break;
1058          }
# Line 1259 | Line 1260 | void MDLexer::mID(bool _createToken) {
1260                  }
1261                  default:
1262                  {
1263 <                        goto _loop125;
1263 >                        goto _loop128;
1264                  }
1265                  }
1266          }
1267 <        _loop125:;
1267 >        _loop128:;
1268          } // ( ... )*
1269          _ttype = testLiteralsTable(_ttype);
1270          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1337 | Line 1338 | void MDLexer::mNUM_INT(bool _createToken) {
1338          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1339          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1340          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1341 < #line 405 "MDParser.g"
1341 > #line 410 "MDParser.g"
1342          
1343                          bool isDecimal = false;
1344                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1345                  
1346 < #line 1346 "MDLexer.cpp"
1346 > #line 1347 "MDLexer.cpp"
1347          
1348          {
1349          switch ( LA(1)) {
# Line 1382 | Line 1383 | void MDLexer::mNUM_INT(bool _createToken) {
1383          {
1384                  match('.' /* charlit */ );
1385                  if ( inputState->guessing==0 ) {
1386 < #line 412 "MDParser.g"
1386 > #line 417 "MDParser.g"
1387                          _ttype = DOT;
1388 < #line 1388 "MDLexer.cpp"
1388 > #line 1389 "MDLexer.cpp"
1389                  }
1390                  {
1391                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1392                          { // ( ... )+
1393 <                        int _cnt137=0;
1393 >                        int _cnt140=0;
1394                          for (;;) {
1395                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1396                                          matchRange('0','9');
1397                                  }
1398                                  else {
1399 <                                        if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1399 >                                        if ( _cnt140>=1 ) { goto _loop140; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1400                                  }
1401                                  
1402 <                                _cnt137++;
1402 >                                _cnt140++;
1403                          }
1404 <                        _loop137:;
1404 >                        _loop140:;
1405                          }  // ( ... )+
1406                          {
1407                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1415 | Line 1416 | void MDLexer::mNUM_INT(bool _createToken) {
1416                                  mFLOAT_SUFFIX(true);
1417                                  f1=_returnToken;
1418                                  if ( inputState->guessing==0 ) {
1419 < #line 413 "MDParser.g"
1419 > #line 418 "MDParser.g"
1420                                          t=f1;
1421 < #line 1421 "MDLexer.cpp"
1421 > #line 1422 "MDLexer.cpp"
1422                                  }
1423                          }
1424                          else {
# Line 1425 | Line 1426 | void MDLexer::mNUM_INT(bool _createToken) {
1426                          
1427                          }
1428                          if ( inputState->guessing==0 ) {
1429 < #line 414 "MDParser.g"
1429 > #line 419 "MDParser.g"
1430                                  
1431                                                                          if ( t &&
1432                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1436 | Line 1437 | void MDLexer::mNUM_INT(bool _createToken) {
1437                                                                                  _ttype = NUM_DOUBLE; // assume double
1438                                                                          }
1439                                                                  
1440 < #line 1440 "MDLexer.cpp"
1440 > #line 1441 "MDLexer.cpp"
1441                          }
1442                  }
1443                  else {
# Line 1462 | Line 1463 | void MDLexer::mNUM_INT(bool _createToken) {
1463                  {
1464                          match('0' /* charlit */ );
1465                          if ( inputState->guessing==0 ) {
1466 < #line 426 "MDParser.g"
1466 > #line 431 "MDParser.g"
1467                                  isDecimal = true;
1468 < #line 1468 "MDLexer.cpp"
1468 > #line 1469 "MDLexer.cpp"
1469                          }
1470                          {
1471                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1487 | Line 1488 | void MDLexer::mNUM_INT(bool _createToken) {
1488                                  }
1489                                  }
1490                                  { // ( ... )+
1491 <                                int _cnt144=0;
1491 >                                int _cnt147=0;
1492                                  for (;;) {
1493                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1494                                                  mHEX_DIGIT(false);
1495                                          }
1496                                          else {
1497 <                                                if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1497 >                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1498                                          }
1499                                          
1500 <                                        _cnt144++;
1500 >                                        _cnt147++;
1501                                  }
1502 <                                _loop144:;
1502 >                                _loop147:;
1503                                  }  // ( ... )+
1504                          }
1505                          else {
1506 <                                bool synPredMatched149 = false;
1506 >                                bool synPredMatched152 = false;
1507                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1508 <                                        int _m149 = mark();
1509 <                                        synPredMatched149 = true;
1508 >                                        int _m152 = mark();
1509 >                                        synPredMatched152 = true;
1510                                          inputState->guessing++;
1511                                          try {
1512                                                  {
1513                                                  { // ( ... )+
1514 <                                                int _cnt147=0;
1514 >                                                int _cnt150=0;
1515                                                  for (;;) {
1516                                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1517                                                                  matchRange('0','9');
1518                                                          }
1519                                                          else {
1520 <                                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1520 >                                                                if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521                                                          }
1522                                                          
1523 <                                                        _cnt147++;
1523 >                                                        _cnt150++;
1524                                                  }
1525 <                                                _loop147:;
1525 >                                                _loop150:;
1526                                                  }  // ( ... )+
1527                                                  {
1528                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1541 | Line 1542 | void MDLexer::mNUM_INT(bool _createToken) {
1542                                                  }
1543                                          }
1544                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1545 <                                                synPredMatched149 = false;
1545 >                                                synPredMatched152 = false;
1546                                          }
1547 <                                        rewind(_m149);
1547 >                                        rewind(_m152);
1548                                          inputState->guessing--;
1549                                  }
1550 <                                if ( synPredMatched149 ) {
1550 >                                if ( synPredMatched152 ) {
1551                                          { // ( ... )+
1552 <                                        int _cnt151=0;
1552 >                                        int _cnt154=0;
1553                                          for (;;) {
1554                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1555                                                          matchRange('0','9');
1556                                                  }
1557                                                  else {
1558 <                                                        if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1558 >                                                        if ( _cnt154>=1 ) { goto _loop154; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1559                                                  }
1560                                                  
1561 <                                                _cnt151++;
1561 >                                                _cnt154++;
1562                                          }
1563 <                                        _loop151:;
1563 >                                        _loop154:;
1564                                          }  // ( ... )+
1565                                  }
1566                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1567                                          { // ( ... )+
1568 <                                        int _cnt153=0;
1568 >                                        int _cnt156=0;
1569                                          for (;;) {
1570                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1571                                                          matchRange('0','7');
1572                                                  }
1573                                                  else {
1574 <                                                        if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1574 >                                                        if ( _cnt156>=1 ) { goto _loop156; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1575                                                  }
1576                                                  
1577 <                                                _cnt153++;
1577 >                                                _cnt156++;
1578                                          }
1579 <                                        _loop153:;
1579 >                                        _loop156:;
1580                                          }  // ( ... )+
1581                                  }
1582                                  else {
# Line 1603 | Line 1604 | void MDLexer::mNUM_INT(bool _createToken) {
1604                                          matchRange('0','9');
1605                                  }
1606                                  else {
1607 <                                        goto _loop156;
1607 >                                        goto _loop159;
1608                                  }
1609                                  
1610                          }
1611 <                        _loop156:;
1611 >                        _loop159:;
1612                          } // ( ... )*
1613                          if ( inputState->guessing==0 ) {
1614 < #line 443 "MDParser.g"
1614 > #line 448 "MDParser.g"
1615                                  isDecimal=true;
1616 < #line 1616 "MDLexer.cpp"
1616 > #line 1617 "MDLexer.cpp"
1617                          }
1618                          break;
1619                  }
# Line 1643 | Line 1644 | void MDLexer::mNUM_INT(bool _createToken) {
1644                          }
1645                          }
1646                          if ( inputState->guessing==0 ) {
1647 < #line 445 "MDParser.g"
1647 > #line 450 "MDParser.g"
1648                                  _ttype = NUM_LONG;
1649 < #line 1649 "MDLexer.cpp"
1649 > #line 1650 "MDLexer.cpp"
1650                          }
1651                  }
1652                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1657 | Line 1658 | void MDLexer::mNUM_INT(bool _createToken) {
1658                                          mFLOAT_SUFFIX(true);
1659                                          f3=_returnToken;
1660                                          if ( inputState->guessing==0 ) {
1661 < #line 450 "MDParser.g"
1661 > #line 455 "MDParser.g"
1662                                                  t=f3;
1663 < #line 1663 "MDLexer.cpp"
1663 > #line 1664 "MDLexer.cpp"
1664                                          }
1665                                  }
1666                                  else {
# Line 1675 | Line 1676 | void MDLexer::mNUM_INT(bool _createToken) {
1676                                                  matchRange('0','9');
1677                                          }
1678                                          else {
1679 <                                                goto _loop161;
1679 >                                                goto _loop164;
1680                                          }
1681                                          
1682                                  }
1683 <                                _loop161:;
1683 >                                _loop164:;
1684                                  } // ( ... )*
1685                                  {
1686                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1694 | Line 1695 | void MDLexer::mNUM_INT(bool _createToken) {
1695                                          mFLOAT_SUFFIX(true);
1696                                          f2=_returnToken;
1697                                          if ( inputState->guessing==0 ) {
1698 < #line 449 "MDParser.g"
1698 > #line 454 "MDParser.g"
1699                                                  t=f2;
1700 < #line 1700 "MDLexer.cpp"
1700 > #line 1701 "MDLexer.cpp"
1701                                          }
1702                                  }
1703                                  else {
# Line 1708 | Line 1709 | void MDLexer::mNUM_INT(bool _createToken) {
1709                                  mFLOAT_SUFFIX(true);
1710                                  f4=_returnToken;
1711                                  if ( inputState->guessing==0 ) {
1712 < #line 451 "MDParser.g"
1712 > #line 456 "MDParser.g"
1713                                          t=f4;
1714 < #line 1714 "MDLexer.cpp"
1714 > #line 1715 "MDLexer.cpp"
1715                                  }
1716                          }
1717                          else {
# Line 1719 | Line 1720 | void MDLexer::mNUM_INT(bool _createToken) {
1720                          
1721                          }
1722                          if ( inputState->guessing==0 ) {
1723 < #line 453 "MDParser.g"
1723 > #line 458 "MDParser.g"
1724                                  
1725                                                                          if ( t &&
1726                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1730 | Line 1731 | void MDLexer::mNUM_INT(bool _createToken) {
1731                                                                                  _ttype = NUM_DOUBLE; // assume double
1732                                                                          }
1733                                                                  
1734 < #line 1734 "MDLexer.cpp"
1734 > #line 1735 "MDLexer.cpp"
1735                          }
1736                  }
1737                  else {
# Line 1818 | Line 1819 | void MDLexer::mEXPONENT(bool _createToken) {
1819          }
1820          }
1821          { // ( ... )+
1822 <        int _cnt169=0;
1822 >        int _cnt172=0;
1823          for (;;) {
1824                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1825                          matchRange('0','9');
1826                  }
1827                  else {
1828 <                        if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1828 >                        if ( _cnt172>=1 ) { goto _loop172; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1829                  }
1830                  
1831 <                _cnt169++;
1831 >                _cnt172++;
1832          }
1833 <        _loop169:;
1833 >        _loop172:;
1834          }  // ( ... )+
1835          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1836             _token = makeToken(_ttype);
# Line 1882 | Line 1883 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1883   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1884   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1885   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1886 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4
1886 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5
1887   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1888   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1889   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1890   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1891 < // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4
1891 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1892   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1893   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1894 < // \" \' 0 1 2 3 4
1894 > // \" \' 0 1 2 3 4 5
1895   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1896   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1897   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1898   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1899 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4
1899 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5
1900   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1901   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1902 < // \' 0 1 2 3 4
1902 > // \' 0 1 2 3 4 5
1903   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1904   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1905   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1906   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1907 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4
1907 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5
1908   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1909   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1910   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1911   const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1912 < // + - 0 1 2 3 4
1912 > // + - 0 1 2 3 4 5
1913   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1914   const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1915   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1916   const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1917 < // 0 1 2 3 4
1917 > // 0 1 2 3 4 5
1918   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1919   const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920   // .

Diff Legend

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