ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
(Generate patch)

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1901 by gezelter, Wed Aug 22 02:28:28 2012 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20120725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20121118): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 546 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546   }
547  
548   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549 < #line 294 "MDTreeParser.g"
549 > #line 296 "MDTreeParser.g"
550          int ival;
551   #line 552 "MDTreeParser.cpp"
552          ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
# Line 562 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562                          i1 = _t;
563                          match(_t,NUM_INT);
564                          _t = _t->getNextSibling();
565 < #line 295 "MDTreeParser.g"
565 > #line 297 "MDTreeParser.g"
566                          ival = lexi_cast<int>(i1->getText());
567   #line 568 "MDTreeParser.cpp"
568                          break;
# Line 572 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572                          i2 = _t;
573                          match(_t,NUM_LONG);
574                          _t = _t->getNextSibling();
575 < #line 296 "MDTreeParser.g"
575 > #line 298 "MDTreeParser.g"
576                          ival = lexi_cast<int>(i2->getText());
577   #line 578 "MDTreeParser.cpp"
578                          break;
# Line 593 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593   }
594  
595   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596 < #line 306 "MDTreeParser.g"
596 > #line 308 "MDTreeParser.g"
597          RealType dval;
598   #line 599 "MDTreeParser.cpp"
599          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
# Line 609 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609                          d1 = _t;
610                          match(_t,NUM_FLOAT);
611                          _t = _t->getNextSibling();
612 < #line 307 "MDTreeParser.g"
612 > #line 309 "MDTreeParser.g"
613                          dval = lexi_cast<RealType>(d1->getText());
614   #line 615 "MDTreeParser.cpp"
615                          break;
# Line 619 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619                          d2 = _t;
620                          match(_t,NUM_DOUBLE);
621                          _t = _t->getNextSibling();
622 < #line 308 "MDTreeParser.g"
622 > #line 310 "MDTreeParser.g"
623                          dval = lexi_cast<RealType>(d2->getText());
624   #line 625 "MDTreeParser.cpp"
625                          break;
# Line 640 | Line 640 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
640   }
641  
642   RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643 < #line 300 "MDTreeParser.g"
643 > #line 302 "MDTreeParser.g"
644          RealType dval;
645   #line 646 "MDTreeParser.cpp"
646          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
# Line 657 | Line 657 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
657                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658                          intConst(_t);
659                          _t = _retTree;
660 < #line 301 "MDTreeParser.g"
660 > #line 303 "MDTreeParser.g"
661                          dval = lexi_cast<RealType>(ic->getText());
662   #line 663 "MDTreeParser.cpp"
663                          break;
# Line 668 | Line 668 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
668                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669                          floatConst(_t);
670                          _t = _retTree;
671 < #line 302 "MDTreeParser.g"
671 > #line 304 "MDTreeParser.g"
672                          dval = lexi_cast<RealType>(fc->getText());
673   #line 674 "MDTreeParser.cpp"
674                          break;
# Line 976 | Line 976 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
976                  for (;;) {
977                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
978                                  _t = ASTNULL;
979 <                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
979 >                        if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
980                                  inversionstatement(_t);
981                                  _t = _retTree;
982                          }
# Line 1011 | Line 1011 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1011  
1012   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014 < #line 220 "MDTreeParser.g"
1014 > #line 222 "MDTreeParser.g"
1015          
1016          int index;
1017          
1018   #line 1019 "MDTreeParser.cpp"
1019          
1020          try {      // for error handling
1021 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1021 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1022                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023                  match(_t,RIGIDBODY);
1024                  _t = _t->getFirstChild();
1025                  index=intConst(_t);
1026                  _t = _retTree;
1027 < #line 224 "MDTreeParser.g"
1027 > #line 226 "MDTreeParser.g"
1028                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029   #line 1030 "MDTreeParser.cpp"
1030                  { // ( ... )*
# Line 1036 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036                                  _t = _retTree;
1037                          }
1038                          else {
1039 <                                goto _loop72;
1039 >                                goto _loop73;
1040                          }
1041                          
1042                  }
1043 <                _loop72:;
1043 >                _loop73:;
1044                  } // ( ... )*
1045                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046                  match(_t,ENDBLOCK);
1047                  _t = _t->getNextSibling();
1048 <                _t = __t70;
1048 >                _t = __t71;
1049                  _t = _t->getNextSibling();
1050 < #line 226 "MDTreeParser.g"
1050 > #line 228 "MDTreeParser.g"
1051                  
1052                  blockStack.top()->validate();
1053                  blockStack.pop();
# Line 1068 | Line 1068 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1068          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069          
1070          try {      // for error handling
1071 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1071 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1072                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073                  match(_t,CUTOFFGROUP);
1074                  _t = _t->getFirstChild();
1075 < #line 243 "MDTreeParser.g"
1075 > #line 245 "MDTreeParser.g"
1076                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077   #line 1078 "MDTreeParser.cpp"
1078                  { // ( ... )*
# Line 1084 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084                                  _t = _retTree;
1085                          }
1086                          else {
1087 <                                goto _loop78;
1087 >                                goto _loop79;
1088                          }
1089                          
1090                  }
1091 <                _loop78:;
1091 >                _loop79:;
1092                  } // ( ... )*
1093                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094                  match(_t,ENDBLOCK);
1095                  _t = _t->getNextSibling();
1096 <                _t = __t76;
1096 >                _t = __t77;
1097                  _t = _t->getNextSibling();
1098 < #line 245 "MDTreeParser.g"
1098 > #line 247 "MDTreeParser.g"
1099                  
1100                  blockStack.top()->validate();
1101                  blockStack.pop();
# Line 1114 | Line 1114 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1114  
1115   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117 < #line 262 "MDTreeParser.g"
1117 > #line 264 "MDTreeParser.g"
1118          int ival;
1119   #line 1120 "MDTreeParser.cpp"
1120          
1121          try {      // for error handling
1122 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1122 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1123                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124                  match(_t,FRAGMENT);
1125                  _t = _t->getFirstChild();
1126                  ival=intConst(_t);
1127                  _t = _retTree;
1128 < #line 263 "MDTreeParser.g"
1128 > #line 265 "MDTreeParser.g"
1129                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130   #line 1131 "MDTreeParser.cpp"
1131                  { // ( ... )*
# Line 1137 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137                                  _t = _retTree;
1138                          }
1139                          else {
1140 <                                goto _loop84;
1140 >                                goto _loop85;
1141                          }
1142                          
1143                  }
1144 <                _loop84:;
1144 >                _loop85:;
1145                  } // ( ... )*
1146                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147                  match(_t,ENDBLOCK);
1148                  _t = _t->getNextSibling();
1149 <                _t = __t82;
1149 >                _t = __t83;
1150                  _t = _t->getNextSibling();
1151 < #line 265 "MDTreeParser.g"
1151 > #line 267 "MDTreeParser.g"
1152                  
1153                  blockStack.top()->validate();
1154                  blockStack.pop();
# Line 1230 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230   }
1231  
1232   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 < #line 278 "MDTreeParser.g"
1233 > #line 280 "MDTreeParser.g"
1234          vector<RealType> dvec;
1235   #line 1236 "MDTreeParser.cpp"
1236          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237 < #line 278 "MDTreeParser.g"
1237 > #line 280 "MDTreeParser.g"
1238          
1239          RealType dval;
1240          
# Line 1242 | Line 1242 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1242          
1243          try {      // for error handling
1244                  { // ( ... )+
1245 <                int _cnt88=0;
1245 >                int _cnt89=0;
1246                  for (;;) {
1247                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248                                  _t = ASTNULL;
1249                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250                                  dval=doubleNumber(_t);
1251                                  _t = _retTree;
1252 < #line 282 "MDTreeParser.g"
1252 > #line 284 "MDTreeParser.g"
1253                                  dvec.push_back(dval);
1254   #line 1255 "MDTreeParser.cpp"
1255                          }
1256                          else {
1257 <                                if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1257 >                                if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258                          }
1259                          
1260 <                        _cnt88++;
1260 >                        _cnt89++;
1261                  }
1262 <                _loop88:;
1262 >                _loop89:;
1263                  }  // ( ... )+
1264          }
1265          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1320 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320   }
1321  
1322   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323 < #line 286 "MDTreeParser.g"
1323 > #line 288 "MDTreeParser.g"
1324          vector<int> ivec;
1325   #line 1326 "MDTreeParser.cpp"
1326          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327 < #line 286 "MDTreeParser.g"
1327 > #line 288 "MDTreeParser.g"
1328          
1329          int ival;
1330          
# Line 1332 | Line 1332 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1332          
1333          try {      // for error handling
1334                  { // ( ... )+
1335 <                int _cnt91=0;
1335 >                int _cnt92=0;
1336                  for (;;) {
1337                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338                                  _t = ASTNULL;
1339                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340                                  ival=intConst(_t);
1341                                  _t = _retTree;
1342 < #line 290 "MDTreeParser.g"
1342 > #line 292 "MDTreeParser.g"
1343                                  ivec.push_back(ival);
1344   #line 1345 "MDTreeParser.cpp"
1345                          }
1346                          else {
1347 <                                if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1347 >                                if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348                          }
1349                          
1350 <                        _cnt91++;
1350 >                        _cnt92++;
1351                  }
1352 <                _loop91:;
1352 >                _loop92:;
1353                  }  // ( ... )+
1354          }
1355          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1462 | Line 1462 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1462   #line 211 "MDTreeParser.g"
1463          
1464          int icent;
1465 +        vector<int> ivec;
1466          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1467          
1468 < #line 1468 "MDTreeParser.cpp"
1468 > #line 1469 "MDTreeParser.cpp"
1469          
1470          try {      // for error handling
1471                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1486 | Line 1487 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1487                          _t = _retTree;
1488                          _t = __t68;
1489                          _t = _t->getNextSibling();
1490 < #line 217 "MDTreeParser.g"
1490 > #line 218 "MDTreeParser.g"
1491                          currInversionStamp->setCenter(icent);
1492 < #line 1492 "MDTreeParser.cpp"
1492 > #line 1493 "MDTreeParser.cpp"
1493                          break;
1494                  }
1495 +                case SATELLITES:
1496 +                {
1497 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1498 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1499 +                        match(_t,SATELLITES);
1500 +                        _t = _t->getFirstChild();
1501 +                        ivec=inttuple(_t);
1502 +                        _t = _retTree;
1503 +                        _t = __t69;
1504 +                        _t = _t->getNextSibling();
1505 + #line 219 "MDTreeParser.g"
1506 +                        currInversionStamp->setSatellites(ivec);
1507 + #line 1508 "MDTreeParser.cpp"
1508 +                        break;
1509 +                }
1510                  default:
1511                  {
1512                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 1507 | Line 1523 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1523  
1524   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1525          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1526 < #line 234 "MDTreeParser.g"
1526 > #line 236 "MDTreeParser.g"
1527          
1528          vector<int> ivec;
1529          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1530          
1531 < #line 1516 "MDTreeParser.cpp"
1531 > #line 1532 "MDTreeParser.cpp"
1532          
1533          try {      // for error handling
1534                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1526 | Line 1542 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1542                  }
1543                  case MEMBERS:
1544                  {
1545 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1546 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1545 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1546 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1547                          match(_t,MEMBERS);
1548                          _t = _t->getFirstChild();
1549                          ivec=inttuple(_t);
1550                          _t = _retTree;
1551 <                        _t = __t74;
1551 >                        _t = __t75;
1552                          _t = _t->getNextSibling();
1553 < #line 240 "MDTreeParser.g"
1553 > #line 242 "MDTreeParser.g"
1554                          currRigidBodyStamp->setMembers(ivec);
1555 < #line 1540 "MDTreeParser.cpp"
1555 > #line 1556 "MDTreeParser.cpp"
1556                          break;
1557                  }
1558                  default:
# Line 1555 | Line 1571 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1571  
1572   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1573          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1574 < #line 253 "MDTreeParser.g"
1574 > #line 255 "MDTreeParser.g"
1575          
1576          vector<int> ivec;
1577          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1578          
1579 < #line 1564 "MDTreeParser.cpp"
1579 > #line 1580 "MDTreeParser.cpp"
1580          
1581          try {      // for error handling
1582                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1574 | Line 1590 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1590                  }
1591                  case MEMBERS:
1592                  {
1593 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1594 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1593 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1594 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1595                          match(_t,MEMBERS);
1596                          _t = _t->getFirstChild();
1597                          ivec=inttuple(_t);
1598                          _t = _retTree;
1599 <                        _t = __t80;
1599 >                        _t = __t81;
1600                          _t = _t->getNextSibling();
1601 < #line 259 "MDTreeParser.g"
1601 > #line 261 "MDTreeParser.g"
1602                          currCutoffGroupStamp->setMembers(ivec);
1603 < #line 1588 "MDTreeParser.cpp"
1603 > #line 1604 "MDTreeParser.cpp"
1604                          break;
1605                  }
1606                  default:
# Line 1638 | Line 1654 | const char* MDTreeParser::tokenNames[] = {
1654          "\"fragment\"",
1655          "\"members\"",
1656          "\"center\"",
1657 +        "\"satellites\"",
1658          "\"position\"",
1659          "\"orientation\"",
1660          "\"flucQ\"",
# Line 1680 | Line 1697 | const char* MDTreeParser::tokenNames[] = {
1697          0
1698   };
1699  
1700 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1700 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 81789168UL, 0UL, 0UL, 0UL };
1701   // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1702   // ASSIGNEQUAL
1703   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1704 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1704 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 67174144UL, 0UL, 0UL, 0UL };
1705   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1706   // "fragment" ASSIGNEQUAL
1707   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Diff Legend

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