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 1969 by gezelter, Wed Feb 26 14:14:50 2014 UTC vs.
Revision 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20121118): "MDParser.g" -> "MDLexer.cpp"$ */
1 > /* $ANTLR 2.7.7 (20141024): "MDParser.g" -> "MDLexer.cpp"$ */
2   #include "MDLexer.hpp"
3   #include <antlr/CharBuffer.hpp>
4   #include <antlr/TokenStreamException.hpp>
# Line 17 | Line 17 | MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer
17   }
18  
19   MDLexer::MDLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
20 <  : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib, true)
20 >        : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
21   {
22          initLiterals();
23   }
# Line 30 | Line 30 | void MDLexer::initLiterals()
30  
31   void MDLexer::initLiterals()
32   {
33 <        literals["flucQ"] = 21;
34 <        literals["satellites"] = 18;
33 >        literals["Quartic"] = 29;
34 >        literals["UreyBradley"] = 33;
35 >        literals["Harmonic"] = 27;
36 >        literals["flucQ"] = 23;
37 >        literals["satellites"] = 20;
38 >        literals["Opls"] = 37;
39          literals["cutoffGroup"] = 14;
40 <        literals["RNEMD"] = 22;
40 >        literals["RNEMD"] = 24;
41 >        literals["constraint"] = 15;
42 >        literals["Trappe"] = 38;
43 >        literals["distance"] = 16;
44 >        literals["Cosine"] = 34;
45          literals["rigidBody"] = 13;
46 <        literals["fragment"] = 15;
46 >        literals["fragment"] = 17;
47 >        literals["charge"] = 43;
48          literals["zconstraint"] = 6;
49 <        literals["minimizer"] = 23;
49 >        literals["minimizer"] = 25;
50 >        literals["Cubic"] = 28;
51          literals["component"] = 4;
52 <        literals["center"] = 17;
53 <        literals["members"] = 16;
54 <        literals["position"] = 19;
55 <        literals["orientation"] = 20;
52 >        literals["GhostBend"] = 32;
53 >        literals["center"] = 19;
54 >        literals["members"] = 18;
55 >        literals["position"] = 21;
56 >        literals["Charmm"] = 36;
57 >        literals["AmberImproper"] = 39;
58 >        literals["Fixed"] = 26;
59 >        literals["Polynomial"] = 30;
60 >        literals["orientation"] = 22;
61          literals["bend"] = 10;
62          literals["torsion"] = 11;
63          literals["atom"] = 8;
64          literals["molecule"] = 5;
65 +        literals["CentralAtomHeight"] = 41;
66 +        literals["Morse"] = 31;
67          literals["restraint"] = 7;
68          literals["inversion"] = 12;
69          literals["bond"] = 9;
70 +        literals["GhostTorsion"] = 35;
71 +        literals["ImproperCosine"] = 40;
72 +        literals["Dreiding"] = 42;
73   }
74  
75   ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
# Line 480 | Line 500 | void MDLexer::mWhitespace(bool _createToken) {
500                  
501                  }
502                  if ( inputState->guessing==0 ) {
503 < #line 255 "MDParser.g"
503 > #line 321 "MDParser.g"
504                          newline();
505 < #line 486 "MDLexer.cpp"
505 > #line 506 "MDLexer.cpp"
506                  }
507                  break;
508          }
# Line 508 | Line 528 | void MDLexer::mWhitespace(bool _createToken) {
528                  
529                  }
530                  if ( inputState->guessing==0 ) {
531 < #line 260 "MDParser.g"
531 > #line 326 "MDParser.g"
532                          printf("CPP_parser.g continuation line detected\n");
533                          deferredNewline();
534 < #line 515 "MDLexer.cpp"
534 > #line 535 "MDLexer.cpp"
535                  }
536                  break;
537          }
# Line 522 | Line 542 | void MDLexer::mWhitespace(bool _createToken) {
542          }
543          }
544          if ( inputState->guessing==0 ) {
545 < #line 263 "MDParser.g"
545 > #line 329 "MDParser.g"
546                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
547 < #line 528 "MDLexer.cpp"
547 > #line 548 "MDLexer.cpp"
548          }
549          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
550             _token = makeToken(_ttype);
# Line 548 | Line 568 | void MDLexer::mComment(bool _createToken) {
568                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
569                          mEndOfLine(false);
570                          if ( inputState->guessing==0 ) {
571 < #line 270 "MDParser.g"
571 > #line 336 "MDParser.g"
572                                  deferredNewline();
573 < #line 554 "MDLexer.cpp"
573 > #line 574 "MDLexer.cpp"
574                          }
575                  }
576                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 559 | Line 579 | void MDLexer::mComment(bool _createToken) {
579                          }
580                  }
581                  else {
582 <                        goto _loop96;
582 >                        goto _loop101;
583                  }
584                  
585          }
586 <        _loop96:;
586 >        _loop101:;
587          } // ( ... )*
588          match("*/");
589          if ( inputState->guessing==0 ) {
590 < #line 273 "MDParser.g"
590 > #line 339 "MDParser.g"
591                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
592 < #line 573 "MDLexer.cpp"
592 > #line 593 "MDLexer.cpp"
593          }
594          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
595             _token = makeToken(_ttype);
# Line 621 | Line 641 | void MDLexer::mCPPComment(bool _createToken) {
641                          }
642                  }
643                  else {
644 <                        goto _loop100;
644 >                        goto _loop105;
645                  }
646                  
647          }
648 <        _loop100:;
648 >        _loop105:;
649          } // ( ... )*
650          mEndOfLine(false);
651          if ( inputState->guessing==0 ) {
652 < #line 279 "MDParser.g"
652 > #line 345 "MDParser.g"
653                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
654 < #line 635 "MDLexer.cpp"
654 > #line 655 "MDLexer.cpp"
655          }
656          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
657             _token = makeToken(_ttype);
# Line 649 | Line 669 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
669          match('#' /* charlit */ );
670          mLineDirective(false);
671          if ( inputState->guessing==0 ) {
672 < #line 286 "MDParser.g"
672 > #line 352 "MDParser.g"
673                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
674 < #line 655 "MDLexer.cpp"
674 > #line 675 "MDLexer.cpp"
675          }
676          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
677             _token = makeToken(_ttype);
# Line 669 | Line 689 | void MDLexer::mLineDirective(bool _createToken) {
689          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
690          
691          if ( inputState->guessing==0 ) {
692 < #line 292 "MDParser.g"
692 > #line 358 "MDParser.g"
693                  
694                  deferredLineCount = 0;
695                  
696 < #line 677 "MDLexer.cpp"
696 > #line 697 "MDLexer.cpp"
697          }
698          {
699          switch ( LA(1)) {
# Line 695 | Line 715 | void MDLexer::mLineDirective(bool _createToken) {
715          }
716          }
717          { // ( ... )+
718 <        int _cnt105=0;
718 >        int _cnt110=0;
719          for (;;) {
720                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
721                          mSpace(false);
722                  }
723                  else {
724 <                        if ( _cnt105>=1 ) { goto _loop105; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
724 >                        if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
725                  }
726                  
727 <                _cnt105++;
727 >                _cnt110++;
728          }
729 <        _loop105:;
729 >        _loop110:;
730          }  // ( ... )+
731          mDecimal(true);
732          n=_returnToken;
733          if ( inputState->guessing==0 ) {
734 < #line 297 "MDParser.g"
734 > #line 363 "MDParser.g"
735                  setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
736 < #line 717 "MDLexer.cpp"
736 > #line 737 "MDLexer.cpp"
737          }
738          { // ( ... )+
739 <        int _cnt107=0;
739 >        int _cnt112=0;
740          for (;;) {
741                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
742                          mSpace(false);
743                  }
744                  else {
745 <                        if ( _cnt107>=1 ) { goto _loop107; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
745 >                        if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
746                  }
747                  
748 <                _cnt107++;
748 >                _cnt112++;
749          }
750 <        _loop107:;
750 >        _loop112:;
751          }  // ( ... )+
752          {
753          mStringLiteral(true);
754          sl=_returnToken;
755          }
756          if ( inputState->guessing==0 ) {
757 < #line 299 "MDParser.g"
757 > #line 365 "MDParser.g"
758                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
759 < #line 740 "MDLexer.cpp"
759 > #line 760 "MDLexer.cpp"
760          }
761          { // ( ... )*
762          for (;;) {
763                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
764                          { // ( ... )+
765 <                        int _cnt111=0;
765 >                        int _cnt116=0;
766                          for (;;) {
767                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
768                                          mSpace(false);
769                                  }
770                                  else {
771 <                                        if ( _cnt111>=1 ) { goto _loop111; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
771 >                                        if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
772                                  }
773                                  
774 <                                _cnt111++;
774 >                                _cnt116++;
775                          }
776 <                        _loop111:;
776 >                        _loop116:;
777                          }  // ( ... )+
778                          mDecimal(false);
779                  }
780                  else {
781 <                        goto _loop112;
781 >                        goto _loop117;
782                  }
783                  
784          }
785 <        _loop112:;
785 >        _loop117:;
786          } // ( ... )*
787          mEndOfLine(false);
788          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 815 | Line 835 | void MDLexer::mDecimal(bool _createToken) {
835          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
836          
837          { // ( ... )+
838 <        int _cnt142=0;
838 >        int _cnt147=0;
839          for (;;) {
840                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
841                          matchRange('0','9');
842                  }
843                  else {
844 <                        if ( _cnt142>=1 ) { goto _loop142; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
844 >                        if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
845                  }
846                  
847 <                _cnt142++;
847 >                _cnt147++;
848          }
849 <        _loop142:;
849 >        _loop147:;
850          }  // ( ... )+
851          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
852             _token = makeToken(_ttype);
# Line 864 | Line 884 | void MDLexer::mStringLiteral(bool _createToken) {
884                          
885                          }
886                          if ( inputState->guessing==0 ) {
887 < #line 339 "MDParser.g"
887 > #line 405 "MDParser.g"
888                                  deferredNewline();
889 < #line 870 "MDLexer.cpp"
889 > #line 890 "MDLexer.cpp"
890                          }
891                  }
892                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 875 | Line 895 | void MDLexer::mStringLiteral(bool _createToken) {
895                          }
896                  }
897                  else {
898 <                        goto _loop122;
898 >                        goto _loop127;
899                  }
900                  
901          }
902 <        _loop122:;
902 >        _loop127:;
903          } // ( ... )*
904          match('\"' /* charlit */ );
905          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1039 | Line 1059 | void MDLexer::mEscape(bool _createToken) {
1059          {
1060                  match('x' /* charlit */ );
1061                  { // ( ... )+
1062 <                int _cnt133=0;
1062 >                int _cnt138=0;
1063                  for (;;) {
1064                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1065                                  mDigit(false);
# Line 1051 | Line 1071 | void MDLexer::mEscape(bool _createToken) {
1071                                  matchRange('A','F');
1072                          }
1073                          else {
1074 <                                if ( _cnt133>=1 ) { goto _loop133; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1074 >                                if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1075                          }
1076                          
1077 <                        _cnt133++;
1077 >                        _cnt138++;
1078                  }
1079 <                _loop133:;
1079 >                _loop138:;
1080                  }  // ( ... )+
1081                  break;
1082          }
# Line 1264 | Line 1284 | void MDLexer::mID(bool _createToken) {
1284                  }
1285                  default:
1286                  {
1287 <                        goto _loop138;
1287 >                        goto _loop143;
1288                  }
1289                  }
1290          }
1291 <        _loop138:;
1291 >        _loop143:;
1292          } // ( ... )*
1293          _ttype = testLiteralsTable(_ttype);
1294          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1342 | Line 1362 | void MDLexer::mNUM_INT(bool _createToken) {
1362          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1363          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1364          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1365 < #line 432 "MDParser.g"
1365 > #line 498 "MDParser.g"
1366          
1367                          bool isDecimal = false;
1368                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1369                  
1370 < #line 1351 "MDLexer.cpp"
1370 > #line 1371 "MDLexer.cpp"
1371          
1372          {
1373          switch ( LA(1)) {
# Line 1387 | Line 1407 | void MDLexer::mNUM_INT(bool _createToken) {
1407          {
1408                  match('.' /* charlit */ );
1409                  if ( inputState->guessing==0 ) {
1410 < #line 439 "MDParser.g"
1410 > #line 505 "MDParser.g"
1411                          _ttype = DOT;
1412 < #line 1393 "MDLexer.cpp"
1412 > #line 1413 "MDLexer.cpp"
1413                  }
1414                  {
1415                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1416                          { // ( ... )+
1417 <                        int _cnt150=0;
1417 >                        int _cnt155=0;
1418                          for (;;) {
1419                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1420                                          matchRange('0','9');
1421                                  }
1422                                  else {
1423 <                                        if ( _cnt150>=1 ) { goto _loop150; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1423 >                                        if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1424                                  }
1425                                  
1426 <                                _cnt150++;
1426 >                                _cnt155++;
1427                          }
1428 <                        _loop150:;
1428 >                        _loop155:;
1429                          }  // ( ... )+
1430                          {
1431                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1420 | Line 1440 | void MDLexer::mNUM_INT(bool _createToken) {
1440                                  mFLOAT_SUFFIX(true);
1441                                  f1=_returnToken;
1442                                  if ( inputState->guessing==0 ) {
1443 < #line 440 "MDParser.g"
1443 > #line 506 "MDParser.g"
1444                                          t=f1;
1445 < #line 1426 "MDLexer.cpp"
1445 > #line 1446 "MDLexer.cpp"
1446                                  }
1447                          }
1448                          else {
# Line 1430 | Line 1450 | void MDLexer::mNUM_INT(bool _createToken) {
1450                          
1451                          }
1452                          if ( inputState->guessing==0 ) {
1453 < #line 441 "MDParser.g"
1453 > #line 507 "MDParser.g"
1454                                  
1455                                                                          if ( t &&
1456                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1441 | Line 1461 | void MDLexer::mNUM_INT(bool _createToken) {
1461                                                                                  _ttype = NUM_DOUBLE; // assume double
1462                                                                          }
1463                                                                  
1464 < #line 1445 "MDLexer.cpp"
1464 > #line 1465 "MDLexer.cpp"
1465                          }
1466                  }
1467                  else {
# Line 1467 | Line 1487 | void MDLexer::mNUM_INT(bool _createToken) {
1487                  {
1488                          match('0' /* charlit */ );
1489                          if ( inputState->guessing==0 ) {
1490 < #line 453 "MDParser.g"
1490 > #line 519 "MDParser.g"
1491                                  isDecimal = true;
1492 < #line 1473 "MDLexer.cpp"
1492 > #line 1493 "MDLexer.cpp"
1493                          }
1494                          {
1495                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1492 | Line 1512 | void MDLexer::mNUM_INT(bool _createToken) {
1512                                  }
1513                                  }
1514                                  { // ( ... )+
1515 <                                int _cnt157=0;
1515 >                                int _cnt162=0;
1516                                  for (;;) {
1517                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1518                                                  mHEX_DIGIT(false);
1519                                          }
1520                                          else {
1521 <                                                if ( _cnt157>=1 ) { goto _loop157; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1521 >                                                if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1522                                          }
1523                                          
1524 <                                        _cnt157++;
1524 >                                        _cnt162++;
1525                                  }
1526 <                                _loop157:;
1526 >                                _loop162:;
1527                                  }  // ( ... )+
1528                          }
1529                          else {
1530 <                                bool synPredMatched162 = false;
1530 >                                bool synPredMatched167 = false;
1531                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1532 <                                        int _m162 = mark();
1533 <                                        synPredMatched162 = true;
1532 >                                        int _m167 = mark();
1533 >                                        synPredMatched167 = true;
1534                                          inputState->guessing++;
1535                                          try {
1536                                                  {
1537                                                  { // ( ... )+
1538 <                                                int _cnt160=0;
1538 >                                                int _cnt165=0;
1539                                                  for (;;) {
1540                                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1541                                                                  matchRange('0','9');
1542                                                          }
1543                                                          else {
1544 <                                                                if ( _cnt160>=1 ) { goto _loop160; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1544 >                                                                if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1545                                                          }
1546                                                          
1547 <                                                        _cnt160++;
1547 >                                                        _cnt165++;
1548                                                  }
1549 <                                                _loop160:;
1549 >                                                _loop165:;
1550                                                  }  // ( ... )+
1551                                                  {
1552                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1546 | Line 1566 | void MDLexer::mNUM_INT(bool _createToken) {
1566                                                  }
1567                                          }
1568                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1569 <                                                synPredMatched162 = false;
1569 >                                                synPredMatched167 = false;
1570                                          }
1571 <                                        rewind(_m162);
1571 >                                        rewind(_m167);
1572                                          inputState->guessing--;
1573                                  }
1574 <                                if ( synPredMatched162 ) {
1574 >                                if ( synPredMatched167 ) {
1575                                          { // ( ... )+
1576 <                                        int _cnt164=0;
1576 >                                        int _cnt169=0;
1577                                          for (;;) {
1578                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1579                                                          matchRange('0','9');
1580                                                  }
1581                                                  else {
1582 <                                                        if ( _cnt164>=1 ) { goto _loop164; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1582 >                                                        if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1583                                                  }
1584                                                  
1585 <                                                _cnt164++;
1585 >                                                _cnt169++;
1586                                          }
1587 <                                        _loop164:;
1587 >                                        _loop169:;
1588                                          }  // ( ... )+
1589                                  }
1590                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1591                                          { // ( ... )+
1592 <                                        int _cnt166=0;
1592 >                                        int _cnt171=0;
1593                                          for (;;) {
1594                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1595                                                          matchRange('0','7');
1596                                                  }
1597                                                  else {
1598 <                                                        if ( _cnt166>=1 ) { goto _loop166; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1598 >                                                        if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1599                                                  }
1600                                                  
1601 <                                                _cnt166++;
1601 >                                                _cnt171++;
1602                                          }
1603 <                                        _loop166:;
1603 >                                        _loop171:;
1604                                          }  // ( ... )+
1605                                  }
1606                                  else {
# Line 1608 | Line 1628 | void MDLexer::mNUM_INT(bool _createToken) {
1628                                          matchRange('0','9');
1629                                  }
1630                                  else {
1631 <                                        goto _loop169;
1631 >                                        goto _loop174;
1632                                  }
1633                                  
1634                          }
1635 <                        _loop169:;
1635 >                        _loop174:;
1636                          } // ( ... )*
1637                          if ( inputState->guessing==0 ) {
1638 < #line 470 "MDParser.g"
1638 > #line 536 "MDParser.g"
1639                                  isDecimal=true;
1640 < #line 1621 "MDLexer.cpp"
1640 > #line 1641 "MDLexer.cpp"
1641                          }
1642                          break;
1643                  }
# Line 1648 | Line 1668 | void MDLexer::mNUM_INT(bool _createToken) {
1668                          }
1669                          }
1670                          if ( inputState->guessing==0 ) {
1671 < #line 472 "MDParser.g"
1671 > #line 538 "MDParser.g"
1672                                  _ttype = NUM_LONG;
1673 < #line 1654 "MDLexer.cpp"
1673 > #line 1674 "MDLexer.cpp"
1674                          }
1675                  }
1676                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1662 | Line 1682 | void MDLexer::mNUM_INT(bool _createToken) {
1682                                          mFLOAT_SUFFIX(true);
1683                                          f3=_returnToken;
1684                                          if ( inputState->guessing==0 ) {
1685 < #line 477 "MDParser.g"
1685 > #line 543 "MDParser.g"
1686                                                  t=f3;
1687 < #line 1668 "MDLexer.cpp"
1687 > #line 1688 "MDLexer.cpp"
1688                                          }
1689                                  }
1690                                  else {
# Line 1680 | Line 1700 | void MDLexer::mNUM_INT(bool _createToken) {
1700                                                  matchRange('0','9');
1701                                          }
1702                                          else {
1703 <                                                goto _loop174;
1703 >                                                goto _loop179;
1704                                          }
1705                                          
1706                                  }
1707 <                                _loop174:;
1707 >                                _loop179:;
1708                                  } // ( ... )*
1709                                  {
1710                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1699 | Line 1719 | void MDLexer::mNUM_INT(bool _createToken) {
1719                                          mFLOAT_SUFFIX(true);
1720                                          f2=_returnToken;
1721                                          if ( inputState->guessing==0 ) {
1722 < #line 476 "MDParser.g"
1722 > #line 542 "MDParser.g"
1723                                                  t=f2;
1724 < #line 1705 "MDLexer.cpp"
1724 > #line 1725 "MDLexer.cpp"
1725                                          }
1726                                  }
1727                                  else {
# Line 1713 | Line 1733 | void MDLexer::mNUM_INT(bool _createToken) {
1733                                  mFLOAT_SUFFIX(true);
1734                                  f4=_returnToken;
1735                                  if ( inputState->guessing==0 ) {
1736 < #line 478 "MDParser.g"
1736 > #line 544 "MDParser.g"
1737                                          t=f4;
1738 < #line 1719 "MDLexer.cpp"
1738 > #line 1739 "MDLexer.cpp"
1739                                  }
1740                          }
1741                          else {
# Line 1724 | Line 1744 | void MDLexer::mNUM_INT(bool _createToken) {
1744                          
1745                          }
1746                          if ( inputState->guessing==0 ) {
1747 < #line 480 "MDParser.g"
1747 > #line 546 "MDParser.g"
1748                                  
1749                                                                          if ( t &&
1750                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1735 | Line 1755 | void MDLexer::mNUM_INT(bool _createToken) {
1755                                                                                  _ttype = NUM_DOUBLE; // assume double
1756                                                                          }
1757                                                                  
1758 < #line 1739 "MDLexer.cpp"
1758 > #line 1759 "MDLexer.cpp"
1759                          }
1760                  }
1761                  else {
# Line 1823 | Line 1843 | void MDLexer::mEXPONENT(bool _createToken) {
1843          }
1844          }
1845          { // ( ... )+
1846 <        int _cnt182=0;
1846 >        int _cnt187=0;
1847          for (;;) {
1848                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1849                          matchRange('0','9');
1850                  }
1851                  else {
1852 <                        if ( _cnt182>=1 ) { goto _loop182; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1852 >                        if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1853                  }
1854                  
1855 <                _cnt182++;
1855 >                _cnt187++;
1856          }
1857 <        _loop182:;
1857 >        _loop187:;
1858          }  // ( ... )+
1859          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1860             _token = makeToken(_ttype);
# Line 1887 | Line 1907 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1907   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 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 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1909   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1910 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9
1910 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C
1911 > // D E F G H I J K L M
1912   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1913   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1914   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1915   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1916 < // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1916 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
1917 > // C D E F G H I J K L M
1918   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1919   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1920 < // \" \' 0 1 2 3 4 5 6 7
1920 > // \" \' 0 1 2 3 4 5 6 7 ?
1921   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1922   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1924   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1925 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1925 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D
1926 > // E F G H I J K L M
1927   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1928   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1929 < // \' 0 1 2 3 4 5 6 7 8 9
1929 > // \' 0 1 2 3 4 5 6 7 8 9 A B C D E F
1930   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1931   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1932   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1933   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1934 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9
1934 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
1935 > // @ A B C D E F G H I J K L M
1936   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1937   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1938 + // D E
1939   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1940   const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1941   // + - 0 1 2 3 4 5 6 7 8 9
1942   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1943   const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1944 + // D F
1945   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1946   const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1947 < // 0 1 2 3 4 5 6 7 8 9
1947 > // 0 1 2 3 4 5 6 7 8 9 A B C D E F
1948   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1949   const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1950 < // .
1950 > // . D E F
1951   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_10(_tokenSet_10_data_,10);
1952  

Diff Legend

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