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 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20080702): "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 30 | Line 30 | void MDLexer::initLiterals()
30  
31   void MDLexer::initLiterals()
32   {
33 <        literals["members"] = 15;
34 <        literals["position"] = 17;
35 <        literals["torsion"] = 10;
36 <        literals["component"] = 4;
37 <        literals["rigidBody"] = 12;
38 <        literals["center"] = 16;
39 <        literals["inversion"] = 11;
33 >        literals["flucQ"] = 23;
34 >        literals["satellites"] = 20;
35 >        literals["cutoffGroup"] = 14;
36 >        literals["RNEMD"] = 24;
37 >        literals["constraint"] = 15;
38 >        literals["distance"] = 16;
39 >        literals["rigidBody"] = 13;
40 >        literals["fragment"] = 17;
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["minimizer"] = 25;
43 >        literals["component"] = 4;
44 >        literals["center"] = 19;
45 >        literals["members"] = 18;
46 >        literals["position"] = 21;
47 >        literals["orientation"] = 22;
48 >        literals["bend"] = 10;
49 >        literals["torsion"] = 11;
50 >        literals["atom"] = 8;
51          literals["molecule"] = 5;
52 <        literals["atom"] = 7;
52 >        literals["restraint"] = 7;
53 >        literals["inversion"] = 12;
54 >        literals["bond"] = 9;
55   }
56  
57   ANTLR_USE_NAMESPACE(antlr)RefToken MDLexer::nextToken()
# Line 475 | Line 482 | void MDLexer::mWhitespace(bool _createToken) {
482                  
483                  }
484                  if ( inputState->guessing==0 ) {
485 < #line 228 "MDParser.g"
485 > #line 274 "MDParser.g"
486                          newline();
487 < #line 481 "MDLexer.cpp"
487 > #line 488 "MDLexer.cpp"
488                  }
489                  break;
490          }
# Line 503 | Line 510 | void MDLexer::mWhitespace(bool _createToken) {
510                  
511                  }
512                  if ( inputState->guessing==0 ) {
513 < #line 233 "MDParser.g"
513 > #line 279 "MDParser.g"
514                          printf("CPP_parser.g continuation line detected\n");
515                          deferredNewline();
516 < #line 510 "MDLexer.cpp"
516 > #line 517 "MDLexer.cpp"
517                  }
518                  break;
519          }
# Line 517 | Line 524 | void MDLexer::mWhitespace(bool _createToken) {
524          }
525          }
526          if ( inputState->guessing==0 ) {
527 < #line 236 "MDParser.g"
527 > #line 282 "MDParser.g"
528                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
529 < #line 523 "MDLexer.cpp"
529 > #line 530 "MDLexer.cpp"
530          }
531          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
532             _token = makeToken(_ttype);
# Line 543 | Line 550 | void MDLexer::mComment(bool _createToken) {
550                  else if ((LA(1) == 0xa /* '\n' */  || LA(1) == 0xd /* '\r' */ )) {
551                          mEndOfLine(false);
552                          if ( inputState->guessing==0 ) {
553 < #line 243 "MDParser.g"
553 > #line 289 "MDParser.g"
554                                  deferredNewline();
555 < #line 549 "MDLexer.cpp"
555 > #line 556 "MDLexer.cpp"
556                          }
557                  }
558                  else if ((_tokenSet_0.member(LA(1)))) {
# Line 554 | Line 561 | void MDLexer::mComment(bool _createToken) {
561                          }
562                  }
563                  else {
564 <                        goto _loop83;
564 >                        goto _loop101;
565                  }
566                  
567          }
568 <        _loop83:;
568 >        _loop101:;
569          } // ( ... )*
570          match("*/");
571          if ( inputState->guessing==0 ) {
572 < #line 246 "MDParser.g"
572 > #line 292 "MDParser.g"
573                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
574 < #line 568 "MDLexer.cpp"
574 > #line 575 "MDLexer.cpp"
575          }
576          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
577             _token = makeToken(_ttype);
# Line 616 | Line 623 | void MDLexer::mCPPComment(bool _createToken) {
623                          }
624                  }
625                  else {
626 <                        goto _loop87;
626 >                        goto _loop105;
627                  }
628                  
629          }
630 <        _loop87:;
630 >        _loop105:;
631          } // ( ... )*
632          mEndOfLine(false);
633          if ( inputState->guessing==0 ) {
634 < #line 252 "MDParser.g"
634 > #line 298 "MDParser.g"
635                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
636 < #line 630 "MDLexer.cpp"
636 > #line 637 "MDLexer.cpp"
637          }
638          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
639             _token = makeToken(_ttype);
# Line 644 | Line 651 | void MDLexer::mPREPROC_DIRECTIVE(bool _createToken) {
651          match('#' /* charlit */ );
652          mLineDirective(false);
653          if ( inputState->guessing==0 ) {
654 < #line 259 "MDParser.g"
654 > #line 305 "MDParser.g"
655                  _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; newline();
656 < #line 650 "MDLexer.cpp"
656 > #line 657 "MDLexer.cpp"
657          }
658          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
659             _token = makeToken(_ttype);
# Line 664 | Line 671 | void MDLexer::mLineDirective(bool _createToken) {
671          ANTLR_USE_NAMESPACE(antlr)RefToken sl;
672          
673          if ( inputState->guessing==0 ) {
674 < #line 265 "MDParser.g"
674 > #line 311 "MDParser.g"
675                  
676                  deferredLineCount = 0;
677                  
678 < #line 672 "MDLexer.cpp"
678 > #line 679 "MDLexer.cpp"
679          }
680          {
681          switch ( LA(1)) {
# Line 690 | Line 697 | void MDLexer::mLineDirective(bool _createToken) {
697          }
698          }
699          { // ( ... )+
700 <        int _cnt92=0;
700 >        int _cnt110=0;
701          for (;;) {
702                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
703                          mSpace(false);
704                  }
705                  else {
706 <                        if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
706 >                        if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
707                  }
708                  
709 <                _cnt92++;
709 >                _cnt110++;
710          }
711 <        _loop92:;
711 >        _loop110:;
712          }  // ( ... )+
713          mDecimal(true);
714          n=_returnToken;
715          if ( inputState->guessing==0 ) {
716 < #line 270 "MDParser.g"
717 <                setLine(oopse::lexi_cast<int>(n->getText()) - 1);
718 < #line 712 "MDLexer.cpp"
716 > #line 316 "MDParser.g"
717 >                setLine(OpenMD::lexi_cast<int>(n->getText()) - 1);
718 > #line 719 "MDLexer.cpp"
719          }
720          { // ( ... )+
721 <        int _cnt94=0;
721 >        int _cnt112=0;
722          for (;;) {
723                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
724                          mSpace(false);
725                  }
726                  else {
727 <                        if ( _cnt94>=1 ) { goto _loop94; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
727 >                        if ( _cnt112>=1 ) { goto _loop112; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
728                  }
729                  
730 <                _cnt94++;
730 >                _cnt112++;
731          }
732 <        _loop94:;
732 >        _loop112:;
733          }  // ( ... )+
734          {
735          mStringLiteral(true);
736          sl=_returnToken;
737          }
738          if ( inputState->guessing==0 ) {
739 < #line 272 "MDParser.g"
739 > #line 318 "MDParser.g"
740                  std::string filename = sl->getText().substr(1,sl->getText().length()-2); observer->notify(filename);
741 < #line 735 "MDLexer.cpp"
741 > #line 742 "MDLexer.cpp"
742          }
743          { // ( ... )*
744          for (;;) {
745                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
746                          { // ( ... )+
747 <                        int _cnt98=0;
747 >                        int _cnt116=0;
748                          for (;;) {
749                                  if ((LA(1) == 0x9 /* '\t' */  || LA(1) == 0xc /* '\14' */  || LA(1) == 0x20 /* ' ' */ )) {
750                                          mSpace(false);
751                                  }
752                                  else {
753 <                                        if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
753 >                                        if ( _cnt116>=1 ) { goto _loop116; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
754                                  }
755                                  
756 <                                _cnt98++;
756 >                                _cnt116++;
757                          }
758 <                        _loop98:;
758 >                        _loop116:;
759                          }  // ( ... )+
760                          mDecimal(false);
761                  }
762                  else {
763 <                        goto _loop99;
763 >                        goto _loop117;
764                  }
765                  
766          }
767 <        _loop99:;
767 >        _loop117:;
768          } // ( ... )*
769          mEndOfLine(false);
770          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 810 | Line 817 | void MDLexer::mDecimal(bool _createToken) {
817          ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
818          
819          { // ( ... )+
820 <        int _cnt129=0;
820 >        int _cnt147=0;
821          for (;;) {
822                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
823                          matchRange('0','9');
824                  }
825                  else {
826 <                        if ( _cnt129>=1 ) { goto _loop129; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
826 >                        if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
827                  }
828                  
829 <                _cnt129++;
829 >                _cnt147++;
830          }
831 <        _loop129:;
831 >        _loop147:;
832          }  // ( ... )+
833          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
834             _token = makeToken(_ttype);
# Line 859 | Line 866 | void MDLexer::mStringLiteral(bool _createToken) {
866                          
867                          }
868                          if ( inputState->guessing==0 ) {
869 < #line 312 "MDParser.g"
869 > #line 358 "MDParser.g"
870                                  deferredNewline();
871 < #line 865 "MDLexer.cpp"
871 > #line 872 "MDLexer.cpp"
872                          }
873                  }
874                  else if ((_tokenSet_3.member(LA(1)))) {
# Line 870 | Line 877 | void MDLexer::mStringLiteral(bool _createToken) {
877                          }
878                  }
879                  else {
880 <                        goto _loop109;
880 >                        goto _loop127;
881                  }
882                  
883          }
884 <        _loop109:;
884 >        _loop127:;
885          } // ( ... )*
886          match('\"' /* charlit */ );
887          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1034 | Line 1041 | void MDLexer::mEscape(bool _createToken) {
1041          {
1042                  match('x' /* charlit */ );
1043                  { // ( ... )+
1044 <                int _cnt120=0;
1044 >                int _cnt138=0;
1045                  for (;;) {
1046                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (_tokenSet_1.member(LA(2))) && (true)) {
1047                                  mDigit(false);
# Line 1046 | Line 1053 | void MDLexer::mEscape(bool _createToken) {
1053                                  matchRange('A','F');
1054                          }
1055                          else {
1056 <                                if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1056 >                                if ( _cnt138>=1 ) { goto _loop138; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1057                          }
1058                          
1059 <                        _cnt120++;
1059 >                        _cnt138++;
1060                  }
1061 <                _loop120:;
1061 >                _loop138:;
1062                  }  // ( ... )+
1063                  break;
1064          }
# Line 1259 | Line 1266 | void MDLexer::mID(bool _createToken) {
1266                  }
1267                  default:
1268                  {
1269 <                        goto _loop125;
1269 >                        goto _loop143;
1270                  }
1271                  }
1272          }
1273 <        _loop125:;
1273 >        _loop143:;
1274          } // ( ... )*
1275          _ttype = testLiteralsTable(_ttype);
1276          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
# Line 1337 | Line 1344 | void MDLexer::mNUM_INT(bool _createToken) {
1344          ANTLR_USE_NAMESPACE(antlr)RefToken f2;
1345          ANTLR_USE_NAMESPACE(antlr)RefToken f3;
1346          ANTLR_USE_NAMESPACE(antlr)RefToken f4;
1347 < #line 405 "MDParser.g"
1347 > #line 451 "MDParser.g"
1348          
1349                          bool isDecimal = false;
1350                          ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
1351                  
1352 < #line 1346 "MDLexer.cpp"
1352 > #line 1353 "MDLexer.cpp"
1353          
1354          {
1355          switch ( LA(1)) {
# Line 1382 | Line 1389 | void MDLexer::mNUM_INT(bool _createToken) {
1389          {
1390                  match('.' /* charlit */ );
1391                  if ( inputState->guessing==0 ) {
1392 < #line 412 "MDParser.g"
1392 > #line 458 "MDParser.g"
1393                          _ttype = DOT;
1394 < #line 1388 "MDLexer.cpp"
1394 > #line 1395 "MDLexer.cpp"
1395                  }
1396                  {
1397                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1398                          { // ( ... )+
1399 <                        int _cnt137=0;
1399 >                        int _cnt155=0;
1400                          for (;;) {
1401                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1402                                          matchRange('0','9');
1403                                  }
1404                                  else {
1405 <                                        if ( _cnt137>=1 ) { goto _loop137; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1405 >                                        if ( _cnt155>=1 ) { goto _loop155; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1406                                  }
1407                                  
1408 <                                _cnt137++;
1408 >                                _cnt155++;
1409                          }
1410 <                        _loop137:;
1410 >                        _loop155:;
1411                          }  // ( ... )+
1412                          {
1413                          if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1415 | Line 1422 | void MDLexer::mNUM_INT(bool _createToken) {
1422                                  mFLOAT_SUFFIX(true);
1423                                  f1=_returnToken;
1424                                  if ( inputState->guessing==0 ) {
1425 < #line 413 "MDParser.g"
1425 > #line 459 "MDParser.g"
1426                                          t=f1;
1427 < #line 1421 "MDLexer.cpp"
1427 > #line 1428 "MDLexer.cpp"
1428                                  }
1429                          }
1430                          else {
# Line 1425 | Line 1432 | void MDLexer::mNUM_INT(bool _createToken) {
1432                          
1433                          }
1434                          if ( inputState->guessing==0 ) {
1435 < #line 414 "MDParser.g"
1435 > #line 460 "MDParser.g"
1436                                  
1437                                                                          if ( t &&
1438                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1436 | Line 1443 | void MDLexer::mNUM_INT(bool _createToken) {
1443                                                                                  _ttype = NUM_DOUBLE; // assume double
1444                                                                          }
1445                                                                  
1446 < #line 1440 "MDLexer.cpp"
1446 > #line 1447 "MDLexer.cpp"
1447                          }
1448                  }
1449                  else {
# Line 1462 | Line 1469 | void MDLexer::mNUM_INT(bool _createToken) {
1469                  {
1470                          match('0' /* charlit */ );
1471                          if ( inputState->guessing==0 ) {
1472 < #line 426 "MDParser.g"
1472 > #line 472 "MDParser.g"
1473                                  isDecimal = true;
1474 < #line 1468 "MDLexer.cpp"
1474 > #line 1475 "MDLexer.cpp"
1475                          }
1476                          {
1477                          if ((LA(1) == 0x58 /* 'X' */  || LA(1) == 0x78 /* 'x' */ )) {
# Line 1487 | Line 1494 | void MDLexer::mNUM_INT(bool _createToken) {
1494                                  }
1495                                  }
1496                                  { // ( ... )+
1497 <                                int _cnt144=0;
1497 >                                int _cnt162=0;
1498                                  for (;;) {
1499                                          if ((_tokenSet_9.member(LA(1))) && (true) && (true)) {
1500                                                  mHEX_DIGIT(false);
1501                                          }
1502                                          else {
1503 <                                                if ( _cnt144>=1 ) { goto _loop144; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1503 >                                                if ( _cnt162>=1 ) { goto _loop162; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1504                                          }
1505                                          
1506 <                                        _cnt144++;
1506 >                                        _cnt162++;
1507                                  }
1508 <                                _loop144:;
1508 >                                _loop162:;
1509                                  }  // ( ... )+
1510                          }
1511                          else {
1512 <                                bool synPredMatched149 = false;
1512 >                                bool synPredMatched167 = false;
1513                                  if ((((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true))) {
1514 <                                        int _m149 = mark();
1515 <                                        synPredMatched149 = true;
1514 >                                        int _m167 = mark();
1515 >                                        synPredMatched167 = true;
1516                                          inputState->guessing++;
1517                                          try {
1518                                                  {
1519                                                  { // ( ... )+
1520 <                                                int _cnt147=0;
1520 >                                                int _cnt165=0;
1521                                                  for (;;) {
1522                                                          if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1523                                                                  matchRange('0','9');
1524                                                          }
1525                                                          else {
1526 <                                                                if ( _cnt147>=1 ) { goto _loop147; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1526 >                                                                if ( _cnt165>=1 ) { goto _loop165; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1527                                                          }
1528                                                          
1529 <                                                        _cnt147++;
1529 >                                                        _cnt165++;
1530                                                  }
1531 <                                                _loop147:;
1531 >                                                _loop165:;
1532                                                  }  // ( ... )+
1533                                                  {
1534                                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1541 | Line 1548 | void MDLexer::mNUM_INT(bool _createToken) {
1548                                                  }
1549                                          }
1550                                          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
1551 <                                                synPredMatched149 = false;
1551 >                                                synPredMatched167 = false;
1552                                          }
1553 <                                        rewind(_m149);
1553 >                                        rewind(_m167);
1554                                          inputState->guessing--;
1555                                  }
1556 <                                if ( synPredMatched149 ) {
1556 >                                if ( synPredMatched167 ) {
1557                                          { // ( ... )+
1558 <                                        int _cnt151=0;
1558 >                                        int _cnt169=0;
1559                                          for (;;) {
1560                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1561                                                          matchRange('0','9');
1562                                                  }
1563                                                  else {
1564 <                                                        if ( _cnt151>=1 ) { goto _loop151; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1564 >                                                        if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1565                                                  }
1566                                                  
1567 <                                                _cnt151++;
1567 >                                                _cnt169++;
1568                                          }
1569 <                                        _loop151:;
1569 >                                        _loop169:;
1570                                          }  // ( ... )+
1571                                  }
1572                                  else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ )) && (true) && (true)) {
1573                                          { // ( ... )+
1574 <                                        int _cnt153=0;
1574 >                                        int _cnt171=0;
1575                                          for (;;) {
1576                                                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x37 /* '7' */ ))) {
1577                                                          matchRange('0','7');
1578                                                  }
1579                                                  else {
1580 <                                                        if ( _cnt153>=1 ) { goto _loop153; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1580 >                                                        if ( _cnt171>=1 ) { goto _loop171; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1581                                                  }
1582                                                  
1583 <                                                _cnt153++;
1583 >                                                _cnt171++;
1584                                          }
1585 <                                        _loop153:;
1585 >                                        _loop171:;
1586                                          }  // ( ... )+
1587                                  }
1588                                  else {
# Line 1603 | Line 1610 | void MDLexer::mNUM_INT(bool _createToken) {
1610                                          matchRange('0','9');
1611                                  }
1612                                  else {
1613 <                                        goto _loop156;
1613 >                                        goto _loop174;
1614                                  }
1615                                  
1616                          }
1617 <                        _loop156:;
1617 >                        _loop174:;
1618                          } // ( ... )*
1619                          if ( inputState->guessing==0 ) {
1620 < #line 443 "MDParser.g"
1620 > #line 489 "MDParser.g"
1621                                  isDecimal=true;
1622 < #line 1616 "MDLexer.cpp"
1622 > #line 1623 "MDLexer.cpp"
1623                          }
1624                          break;
1625                  }
# Line 1643 | Line 1650 | void MDLexer::mNUM_INT(bool _createToken) {
1650                          }
1651                          }
1652                          if ( inputState->guessing==0 ) {
1653 < #line 445 "MDParser.g"
1653 > #line 491 "MDParser.g"
1654                                  _ttype = NUM_LONG;
1655 < #line 1649 "MDLexer.cpp"
1655 > #line 1656 "MDLexer.cpp"
1656                          }
1657                  }
1658                  else if (((_tokenSet_10.member(LA(1))))&&(isDecimal)) {
# Line 1657 | Line 1664 | void MDLexer::mNUM_INT(bool _createToken) {
1664                                          mFLOAT_SUFFIX(true);
1665                                          f3=_returnToken;
1666                                          if ( inputState->guessing==0 ) {
1667 < #line 450 "MDParser.g"
1667 > #line 496 "MDParser.g"
1668                                                  t=f3;
1669 < #line 1663 "MDLexer.cpp"
1669 > #line 1670 "MDLexer.cpp"
1670                                          }
1671                                  }
1672                                  else {
# Line 1675 | Line 1682 | void MDLexer::mNUM_INT(bool _createToken) {
1682                                                  matchRange('0','9');
1683                                          }
1684                                          else {
1685 <                                                goto _loop161;
1685 >                                                goto _loop179;
1686                                          }
1687                                          
1688                                  }
1689 <                                _loop161:;
1689 >                                _loop179:;
1690                                  } // ( ... )*
1691                                  {
1692                                  if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) {
# Line 1694 | Line 1701 | void MDLexer::mNUM_INT(bool _createToken) {
1701                                          mFLOAT_SUFFIX(true);
1702                                          f2=_returnToken;
1703                                          if ( inputState->guessing==0 ) {
1704 < #line 449 "MDParser.g"
1704 > #line 495 "MDParser.g"
1705                                                  t=f2;
1706 < #line 1700 "MDLexer.cpp"
1706 > #line 1707 "MDLexer.cpp"
1707                                          }
1708                                  }
1709                                  else {
# Line 1708 | Line 1715 | void MDLexer::mNUM_INT(bool _createToken) {
1715                                  mFLOAT_SUFFIX(true);
1716                                  f4=_returnToken;
1717                                  if ( inputState->guessing==0 ) {
1718 < #line 451 "MDParser.g"
1718 > #line 497 "MDParser.g"
1719                                          t=f4;
1720 < #line 1714 "MDLexer.cpp"
1720 > #line 1721 "MDLexer.cpp"
1721                                  }
1722                          }
1723                          else {
# Line 1719 | Line 1726 | void MDLexer::mNUM_INT(bool _createToken) {
1726                          
1727                          }
1728                          if ( inputState->guessing==0 ) {
1729 < #line 453 "MDParser.g"
1729 > #line 499 "MDParser.g"
1730                                  
1731                                                                          if ( t &&
1732                                                                                    (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
# Line 1730 | Line 1737 | void MDLexer::mNUM_INT(bool _createToken) {
1737                                                                                  _ttype = NUM_DOUBLE; // assume double
1738                                                                          }
1739                                                                  
1740 < #line 1734 "MDLexer.cpp"
1740 > #line 1741 "MDLexer.cpp"
1741                          }
1742                  }
1743                  else {
# Line 1818 | Line 1825 | void MDLexer::mEXPONENT(bool _createToken) {
1825          }
1826          }
1827          { // ( ... )+
1828 <        int _cnt169=0;
1828 >        int _cnt187=0;
1829          for (;;) {
1830                  if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
1831                          matchRange('0','9');
1832                  }
1833                  else {
1834 <                        if ( _cnt169>=1 ) { goto _loop169; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1834 >                        if ( _cnt187>=1 ) { goto _loop187; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
1835                  }
1836                  
1837 <                _cnt169++;
1837 >                _cnt187++;
1838          }
1839 <        _loop169:;
1839 >        _loop187:;
1840          }  // ( ... )+
1841          if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
1842             _token = makeToken(_ttype);
# Line 1882 | Line 1889 | const unsigned long MDLexer::_tokenSet_0_data_[] = { 4
1889   const unsigned long MDLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1890   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1891   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1892 < // \" # $ % & \' ( ) + , - . / 0 1 2 3 4
1892 > // \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1893   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_0(_tokenSet_0_data_,16);
1894   const unsigned long MDLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1895   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1896   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1897 < // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4
1897 > // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1898   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_1(_tokenSet_1_data_,16);
1899   const unsigned long MDLexer::_tokenSet_2_data_[] = { 0UL, 2164195460UL, 268435456UL, 22298694UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1900 < // \" \' 0 1 2 3 4
1900 > // \" \' 0 1 2 3 4 5 6 7
1901   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_2(_tokenSet_2_data_,10);
1902   const unsigned long MDLexer::_tokenSet_3_data_[] = { 4294958079UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1903   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12
1904   // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   !
1905 < // # $ % & \' ( ) * + , - . / 0 1 2 3 4
1905 > // # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1906   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_3(_tokenSet_3_data_,16);
1907   const unsigned long MDLexer::_tokenSet_4_data_[] = { 0UL, 67043456UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1908 < // \' 0 1 2 3 4
1908 > // \' 0 1 2 3 4 5 6 7 8 9
1909   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_4(_tokenSet_4_data_,10);
1910   const unsigned long MDLexer::_tokenSet_5_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1911   // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10
1912   // 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e
1913 < // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4
1913 > // 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ;
1914   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_5(_tokenSet_5_data_,16);
1915   const unsigned long MDLexer::_tokenSet_6_data_[] = { 0UL, 0UL, 48UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1916   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_6(_tokenSet_6_data_,10);
1917   const unsigned long MDLexer::_tokenSet_7_data_[] = { 0UL, 67053568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1918 < // + - 0 1 2 3 4
1918 > // + - 0 1 2 3 4 5 6 7 8 9
1919   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_7(_tokenSet_7_data_,10);
1920   const unsigned long MDLexer::_tokenSet_8_data_[] = { 0UL, 0UL, 80UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1921   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_8(_tokenSet_8_data_,10);
1922   const unsigned long MDLexer::_tokenSet_9_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1923 < // 0 1 2 3 4
1923 > // 0 1 2 3 4 5 6 7 8 9
1924   const ANTLR_USE_NAMESPACE(antlr)BitSet MDLexer::_tokenSet_9(_tokenSet_9_data_,10);
1925   const unsigned long MDLexer::_tokenSet_10_data_[] = { 0UL, 16384UL, 112UL, 112UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
1926   // .

Comparing trunk/src/mdParser/MDLexer.cpp (property svn:keywords):
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

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