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 1782 by gezelter, Wed Aug 22 02:28:28 2012 UTC vs.
Revision 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20120725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20140107): "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 314 "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 315 "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 316 "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 326 "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 327 "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 328 "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 320 "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 321 "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 322 "MDTreeParser.g"
672                          dval = lexi_cast<RealType>(fc->getText());
673   #line 674 "MDTreeParser.cpp"
674                          break;
# Line 749 | Line 749 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
749                          _t = _retTree;
750                          break;
751                  }
752 +                case CONSTRAINT:
753 +                {
754 +                        constraintblock(_t);
755 +                        _t = _retTree;
756 +                        break;
757 +                }
758                  default:
759                  {
760                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 765 | Line 771 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
771  
772   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
773          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
774 < #line 119 "MDTreeParser.g"
774 > #line 120 "MDTreeParser.g"
775          
776          int index;
777          
778 < #line 773 "MDTreeParser.cpp"
778 > #line 779 "MDTreeParser.cpp"
779          
780          try {      // for error handling
781                  ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
# Line 778 | Line 784 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
784                  _t = _t->getFirstChild();
785                  index=intConst(_t);
786                  _t = _retTree;
787 < #line 123 "MDTreeParser.g"
787 > #line 124 "MDTreeParser.g"
788                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
789 < #line 784 "MDTreeParser.cpp"
789 > #line 790 "MDTreeParser.cpp"
790                  { // ( ... )*
791                  for (;;) {
792                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 801 | Line 807 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
807                  _t = _t->getNextSibling();
808                  _t = __t39;
809                  _t = _t->getNextSibling();
810 < #line 125 "MDTreeParser.g"
810 > #line 126 "MDTreeParser.g"
811                  
812                  blockStack.top()->validate();
813                  blockStack.pop();
814                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
815                  currMoleculeStamp->addAtomStamp(currAtomStamp);
816                  
817 < #line 812 "MDTreeParser.cpp"
817 > #line 818 "MDTreeParser.cpp"
818          }
819          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
820                  reportError(ex);
# Line 826 | Line 832 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
832                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
833                  match(_t,BOND);
834                  _t = _t->getFirstChild();
835 < #line 145 "MDTreeParser.g"
835 > #line 146 "MDTreeParser.g"
836                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
837 < #line 832 "MDTreeParser.cpp"
837 > #line 838 "MDTreeParser.cpp"
838                  { // ( ... )*
839                  for (;;) {
840                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 849 | Line 855 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
855                  _t = _t->getNextSibling();
856                  _t = __t46;
857                  _t = _t->getNextSibling();
858 < #line 147 "MDTreeParser.g"
858 > #line 148 "MDTreeParser.g"
859                  
860                  blockStack.pop();
861                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
862                  currMoleculeStamp->addBondStamp(currBondStamp);
863                  
864 < #line 859 "MDTreeParser.cpp"
864 > #line 865 "MDTreeParser.cpp"
865          }
866          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
867                  reportError(ex);
# Line 873 | Line 879 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
879                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
880                  match(_t,BEND);
881                  _t = _t->getFirstChild();
882 < #line 163 "MDTreeParser.g"
882 > #line 164 "MDTreeParser.g"
883                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
884 < #line 879 "MDTreeParser.cpp"
884 > #line 885 "MDTreeParser.cpp"
885                  { // ( ... )*
886                  for (;;) {
887                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 896 | Line 902 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
902                  _t = _t->getNextSibling();
903                  _t = __t52;
904                  _t = _t->getNextSibling();
905 < #line 165 "MDTreeParser.g"
905 > #line 166 "MDTreeParser.g"
906                  
907                  blockStack.top()->validate();
908                  blockStack.pop();
909                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
910                  currMoleculeStamp->addBendStamp(currBendStamp);
911                  
912 < #line 907 "MDTreeParser.cpp"
912 > #line 913 "MDTreeParser.cpp"
913          }
914          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
915                  reportError(ex);
# Line 921 | Line 927 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
927                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
928                  match(_t,TORSION);
929                  _t = _t->getFirstChild();
930 < #line 182 "MDTreeParser.g"
930 > #line 183 "MDTreeParser.g"
931                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
932 < #line 927 "MDTreeParser.cpp"
932 > #line 933 "MDTreeParser.cpp"
933                  { // ( ... )*
934                  for (;;) {
935                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 944 | Line 950 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
950                  _t = _t->getNextSibling();
951                  _t = __t58;
952                  _t = _t->getNextSibling();
953 < #line 184 "MDTreeParser.g"
953 > #line 185 "MDTreeParser.g"
954                  
955                  blockStack.top()->validate();
956                  blockStack.pop();
957                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
958                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
959                  
960 < #line 955 "MDTreeParser.cpp"
960 > #line 961 "MDTreeParser.cpp"
961          }
962          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
963                  reportError(ex);
# Line 969 | Line 975 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
975                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
976                  match(_t,INVERSION);
977                  _t = _t->getFirstChild();
978 < #line 201 "MDTreeParser.g"
978 > #line 202 "MDTreeParser.g"
979                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
980 < #line 975 "MDTreeParser.cpp"
980 > #line 981 "MDTreeParser.cpp"
981                  { // ( ... )*
982                  for (;;) {
983                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
984                                  _t = ASTNULL;
985 <                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
985 >                        if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
986                                  inversionstatement(_t);
987                                  _t = _retTree;
988                          }
# Line 992 | Line 998 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
998                  _t = _t->getNextSibling();
999                  _t = __t64;
1000                  _t = _t->getNextSibling();
1001 < #line 203 "MDTreeParser.g"
1001 > #line 204 "MDTreeParser.g"
1002                  
1003                  blockStack.top()->validate();
1004                  blockStack.pop();
1005                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1006                  currMoleculeStamp->addInversionStamp(currInversionStamp);
1007                  
1008 < #line 1003 "MDTreeParser.cpp"
1008 > #line 1009 "MDTreeParser.cpp"
1009          }
1010          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1011                  reportError(ex);
# Line 1011 | Line 1017 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1017  
1018   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1019          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1020 < #line 220 "MDTreeParser.g"
1020 > #line 223 "MDTreeParser.g"
1021          
1022          int index;
1023          
1024 < #line 1019 "MDTreeParser.cpp"
1024 > #line 1025 "MDTreeParser.cpp"
1025          
1026          try {      // for error handling
1027 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1027 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1028                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1029                  match(_t,RIGIDBODY);
1030                  _t = _t->getFirstChild();
1031                  index=intConst(_t);
1032                  _t = _retTree;
1033 < #line 224 "MDTreeParser.g"
1033 > #line 227 "MDTreeParser.g"
1034                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1035 < #line 1030 "MDTreeParser.cpp"
1035 > #line 1036 "MDTreeParser.cpp"
1036                  { // ( ... )*
1037                  for (;;) {
1038                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1036 | Line 1042 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1042                                  _t = _retTree;
1043                          }
1044                          else {
1045 <                                goto _loop72;
1045 >                                goto _loop73;
1046                          }
1047                          
1048                  }
1049 <                _loop72:;
1049 >                _loop73:;
1050                  } // ( ... )*
1051                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1052                  match(_t,ENDBLOCK);
1053                  _t = _t->getNextSibling();
1054 <                _t = __t70;
1054 >                _t = __t71;
1055                  _t = _t->getNextSibling();
1056 < #line 226 "MDTreeParser.g"
1056 > #line 229 "MDTreeParser.g"
1057                  
1058                  blockStack.top()->validate();
1059                  blockStack.pop();
1060                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1061                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1062                  
1063 < #line 1058 "MDTreeParser.cpp"
1063 > #line 1064 "MDTreeParser.cpp"
1064          }
1065          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1066                  reportError(ex);
# Line 1068 | Line 1074 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1074          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1075          
1076          try {      // for error handling
1077 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1077 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1078                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1079                  match(_t,CUTOFFGROUP);
1080                  _t = _t->getFirstChild();
1081 < #line 243 "MDTreeParser.g"
1081 > #line 246 "MDTreeParser.g"
1082                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1083 < #line 1078 "MDTreeParser.cpp"
1083 > #line 1084 "MDTreeParser.cpp"
1084                  { // ( ... )*
1085                  for (;;) {
1086                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1084 | Line 1090 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1090                                  _t = _retTree;
1091                          }
1092                          else {
1093 <                                goto _loop78;
1093 >                                goto _loop79;
1094                          }
1095                          
1096                  }
1097 <                _loop78:;
1097 >                _loop79:;
1098                  } // ( ... )*
1099                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1100                  match(_t,ENDBLOCK);
1101                  _t = _t->getNextSibling();
1102 <                _t = __t76;
1102 >                _t = __t77;
1103                  _t = _t->getNextSibling();
1104 < #line 245 "MDTreeParser.g"
1104 > #line 248 "MDTreeParser.g"
1105                  
1106                  blockStack.top()->validate();
1107                  blockStack.pop();
1108                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1109                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1110                  
1111 < #line 1106 "MDTreeParser.cpp"
1111 > #line 1112 "MDTreeParser.cpp"
1112          }
1113          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1114                  reportError(ex);
# Line 1114 | Line 1120 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1120  
1121   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1122          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1123 < #line 262 "MDTreeParser.g"
1123 > #line 265 "MDTreeParser.g"
1124          int ival;
1125 < #line 1120 "MDTreeParser.cpp"
1125 > #line 1126 "MDTreeParser.cpp"
1126          
1127          try {      // for error handling
1128 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1128 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1129                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1130                  match(_t,FRAGMENT);
1131                  _t = _t->getFirstChild();
1132                  ival=intConst(_t);
1133                  _t = _retTree;
1134 < #line 263 "MDTreeParser.g"
1134 > #line 266 "MDTreeParser.g"
1135                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1136 < #line 1131 "MDTreeParser.cpp"
1136 > #line 1137 "MDTreeParser.cpp"
1137                  { // ( ... )*
1138                  for (;;) {
1139                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1137 | Line 1143 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1143                                  _t = _retTree;
1144                          }
1145                          else {
1146 <                                goto _loop84;
1146 >                                goto _loop85;
1147                          }
1148                          
1149                  }
1150 <                _loop84:;
1150 >                _loop85:;
1151                  } // ( ... )*
1152                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1153                  match(_t,ENDBLOCK);
1154                  _t = _t->getNextSibling();
1155 <                _t = __t82;
1155 >                _t = __t83;
1156                  _t = _t->getNextSibling();
1157 < #line 265 "MDTreeParser.g"
1157 > #line 268 "MDTreeParser.g"
1158                  
1159                  blockStack.top()->validate();
1160                  blockStack.pop();
1161                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1162                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1163                  
1164 < #line 1159 "MDTreeParser.cpp"
1164 > #line 1165 "MDTreeParser.cpp"
1165          }
1166          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1167                  reportError(ex);
# Line 1165 | Line 1171 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1171          _retTree = _t;
1172   }
1173  
1174 + void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1175 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1176 +        
1177 +        try {      // for error handling
1178 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1179 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1180 +                match(_t,CONSTRAINT);
1181 +                _t = _t->getFirstChild();
1182 + #line 279 "MDTreeParser.g"
1183 +                ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1184 + #line 1185 "MDTreeParser.cpp"
1185 +                { // ( ... )*
1186 +                for (;;) {
1187 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1188 +                                _t = ASTNULL;
1189 +                        if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1190 +                                constraintstatement(_t);
1191 +                                _t = _retTree;
1192 +                        }
1193 +                        else {
1194 +                                goto _loop90;
1195 +                        }
1196 +                        
1197 +                }
1198 +                _loop90:;
1199 +                } // ( ... )*
1200 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1201 +                match(_t,ENDBLOCK);
1202 +                _t = _t->getNextSibling();
1203 +                _t = __t88;
1204 +                _t = _t->getNextSibling();
1205 + #line 281 "MDTreeParser.g"
1206 +                
1207 +                blockStack.pop();
1208 +                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1209 +                currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1210 +                
1211 + #line 1212 "MDTreeParser.cpp"
1212 +        }
1213 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1214 +                reportError(ex);
1215 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1216 +                        _t = _t->getNextSibling();
1217 +        }
1218 +        _retTree = _t;
1219 + }
1220 +
1221   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1222          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1223 < #line 133 "MDTreeParser.g"
1223 > #line 134 "MDTreeParser.g"
1224          
1225          vector<RealType> dvec;
1226          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1227          
1228          
1229 < #line 1177 "MDTreeParser.cpp"
1229 > #line 1230 "MDTreeParser.cpp"
1230          
1231          try {      // for error handling
1232                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1188 | Line 1241 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1241                  case POSITION:
1242                  {
1243                          ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1244 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1244 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1245                          match(_t,POSITION);
1246                          _t = _t->getFirstChild();
1247                          dvec=doubleNumberTuple(_t);
1248                          _t = _retTree;
1249                          _t = __t43;
1250                          _t = _t->getNextSibling();
1251 < #line 140 "MDTreeParser.g"
1251 > #line 141 "MDTreeParser.g"
1252                          currAtomStamp->setPosition(dvec);
1253 < #line 1201 "MDTreeParser.cpp"
1253 > #line 1254 "MDTreeParser.cpp"
1254                          break;
1255                  }
1256                  case ORIENTATION:
1257                  {
1258                          ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1259 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1259 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1260                          match(_t,ORIENTATION);
1261                          _t = _t->getFirstChild();
1262                          dvec=doubleNumberTuple(_t);
1263                          _t = _retTree;
1264                          _t = __t44;
1265                          _t = _t->getNextSibling();
1266 < #line 141 "MDTreeParser.g"
1266 > #line 142 "MDTreeParser.g"
1267                          currAtomStamp->setOrientation(dvec);
1268 < #line 1216 "MDTreeParser.cpp"
1268 > #line 1269 "MDTreeParser.cpp"
1269                          break;
1270                  }
1271                  default:
# Line 1230 | Line 1283 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1283   }
1284  
1285   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286 < #line 278 "MDTreeParser.g"
1286 > #line 298 "MDTreeParser.g"
1287          vector<RealType> dvec;
1288 < #line 1236 "MDTreeParser.cpp"
1288 > #line 1289 "MDTreeParser.cpp"
1289          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290 < #line 278 "MDTreeParser.g"
1290 > #line 298 "MDTreeParser.g"
1291          
1292          RealType dval;
1293          
1294 < #line 1242 "MDTreeParser.cpp"
1294 > #line 1295 "MDTreeParser.cpp"
1295          
1296          try {      // for error handling
1297                  { // ( ... )+
1298 <                int _cnt88=0;
1298 >                int _cnt95=0;
1299                  for (;;) {
1300                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1301                                  _t = ASTNULL;
1302                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1303                                  dval=doubleNumber(_t);
1304                                  _t = _retTree;
1305 < #line 282 "MDTreeParser.g"
1305 > #line 302 "MDTreeParser.g"
1306                                  dvec.push_back(dval);
1307 < #line 1255 "MDTreeParser.cpp"
1307 > #line 1308 "MDTreeParser.cpp"
1308                          }
1309                          else {
1310 <                                if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1310 >                                if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1311                          }
1312                          
1313 <                        _cnt88++;
1313 >                        _cnt95++;
1314                  }
1315 <                _loop88:;
1315 >                _loop95:;
1316                  }  // ( ... )+
1317          }
1318          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1273 | Line 1326 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1326  
1327   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 < #line 154 "MDTreeParser.g"
1329 > #line 155 "MDTreeParser.g"
1330          
1331          vector<int> ivec;
1332          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1333          
1334 < #line 1282 "MDTreeParser.cpp"
1334 > #line 1335 "MDTreeParser.cpp"
1335          
1336          try {      // for error handling
1337                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1293 | Line 1346 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1346                  case MEMBERS:
1347                  {
1348                          ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1349 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1349 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1350                          match(_t,MEMBERS);
1351                          _t = _t->getFirstChild();
1352                          ivec=inttuple(_t);
1353                          _t = _retTree;
1354                          _t = __t50;
1355                          _t = _t->getNextSibling();
1356 < #line 160 "MDTreeParser.g"
1356 > #line 161 "MDTreeParser.g"
1357                          currBondStamp->setMembers(ivec);
1358 < #line 1306 "MDTreeParser.cpp"
1358 > #line 1359 "MDTreeParser.cpp"
1359                          break;
1360                  }
1361                  default:
# Line 1320 | Line 1373 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1373   }
1374  
1375   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376 < #line 286 "MDTreeParser.g"
1376 > #line 306 "MDTreeParser.g"
1377          vector<int> ivec;
1378 < #line 1326 "MDTreeParser.cpp"
1378 > #line 1379 "MDTreeParser.cpp"
1379          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380 < #line 286 "MDTreeParser.g"
1380 > #line 306 "MDTreeParser.g"
1381          
1382          int ival;
1383          
1384 < #line 1332 "MDTreeParser.cpp"
1384 > #line 1385 "MDTreeParser.cpp"
1385          
1386          try {      // for error handling
1387                  { // ( ... )+
1388 <                int _cnt91=0;
1388 >                int _cnt98=0;
1389                  for (;;) {
1390                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1391                                  _t = ASTNULL;
1392                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1393                                  ival=intConst(_t);
1394                                  _t = _retTree;
1395 < #line 290 "MDTreeParser.g"
1395 > #line 310 "MDTreeParser.g"
1396                                  ivec.push_back(ival);
1397 < #line 1345 "MDTreeParser.cpp"
1397 > #line 1398 "MDTreeParser.cpp"
1398                          }
1399                          else {
1400 <                                if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1400 >                                if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1401                          }
1402                          
1403 <                        _cnt91++;
1403 >                        _cnt98++;
1404                  }
1405 <                _loop91:;
1405 >                _loop98:;
1406                  }  // ( ... )+
1407          }
1408          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1363 | Line 1416 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1416  
1417   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1418          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1419 < #line 173 "MDTreeParser.g"
1419 > #line 174 "MDTreeParser.g"
1420          
1421          vector<int> ivec;
1422          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1423          
1424 < #line 1372 "MDTreeParser.cpp"
1424 > #line 1425 "MDTreeParser.cpp"
1425          
1426          try {      // for error handling
1427                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1383 | Line 1436 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1436                  case MEMBERS:
1437                  {
1438                          ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1439 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1439 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1440                          match(_t,MEMBERS);
1441                          _t = _t->getFirstChild();
1442                          ivec=inttuple(_t);
1443                          _t = _retTree;
1444                          _t = __t56;
1445                          _t = _t->getNextSibling();
1446 < #line 179 "MDTreeParser.g"
1446 > #line 180 "MDTreeParser.g"
1447                          currBendStamp->setMembers(ivec);
1448 < #line 1396 "MDTreeParser.cpp"
1448 > #line 1449 "MDTreeParser.cpp"
1449                          break;
1450                  }
1451                  default:
# Line 1411 | Line 1464 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1464  
1465   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1466          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1467 < #line 192 "MDTreeParser.g"
1467 > #line 193 "MDTreeParser.g"
1468          
1469          vector<int> ivec;
1470          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1471          
1472 < #line 1420 "MDTreeParser.cpp"
1472 > #line 1473 "MDTreeParser.cpp"
1473          
1474          try {      // for error handling
1475                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1431 | Line 1484 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1484                  case MEMBERS:
1485                  {
1486                          ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1487 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1487 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1488                          match(_t,MEMBERS);
1489                          _t = _t->getFirstChild();
1490                          ivec=inttuple(_t);
1491                          _t = _retTree;
1492                          _t = __t62;
1493                          _t = _t->getNextSibling();
1494 < #line 198 "MDTreeParser.g"
1494 > #line 199 "MDTreeParser.g"
1495                          currTorsionStamp->setMembers(ivec);
1496 < #line 1444 "MDTreeParser.cpp"
1496 > #line 1497 "MDTreeParser.cpp"
1497                          break;
1498                  }
1499                  default:
# Line 1459 | Line 1512 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1512  
1513   void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1514          ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515 < #line 211 "MDTreeParser.g"
1515 > #line 212 "MDTreeParser.g"
1516          
1517          int icent;
1518 +        vector<int> ivec;
1519          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1520          
1521 < #line 1468 "MDTreeParser.cpp"
1521 > #line 1522 "MDTreeParser.cpp"
1522          
1523          try {      // for error handling
1524                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1479 | Line 1533 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1533                  case CENTER:
1534                  {
1535                          ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1536 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1536 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1537                          match(_t,CENTER);
1538                          _t = _t->getFirstChild();
1539                          icent=intConst(_t);
1540                          _t = _retTree;
1541                          _t = __t68;
1542                          _t = _t->getNextSibling();
1543 < #line 217 "MDTreeParser.g"
1543 > #line 219 "MDTreeParser.g"
1544                          currInversionStamp->setCenter(icent);
1545 < #line 1492 "MDTreeParser.cpp"
1545 > #line 1546 "MDTreeParser.cpp"
1546                          break;
1547                  }
1548 +                case SATELLITES:
1549 +                {
1550 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1551 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1552 +                        match(_t,SATELLITES);
1553 +                        _t = _t->getFirstChild();
1554 +                        ivec=inttuple(_t);
1555 +                        _t = _retTree;
1556 +                        _t = __t69;
1557 +                        _t = _t->getNextSibling();
1558 + #line 220 "MDTreeParser.g"
1559 +                        currInversionStamp->setSatellites(ivec);
1560 + #line 1561 "MDTreeParser.cpp"
1561 +                        break;
1562 +                }
1563                  default:
1564                  {
1565                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 1507 | Line 1576 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1576  
1577   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1578          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1579 < #line 234 "MDTreeParser.g"
1579 > #line 237 "MDTreeParser.g"
1580          
1581          vector<int> ivec;
1582          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1583          
1584 < #line 1516 "MDTreeParser.cpp"
1584 > #line 1585 "MDTreeParser.cpp"
1585          
1586          try {      // for error handling
1587                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1526 | Line 1595 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1595                  }
1596                  case MEMBERS:
1597                  {
1598 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1599 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1598 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1599 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1600                          match(_t,MEMBERS);
1601                          _t = _t->getFirstChild();
1602                          ivec=inttuple(_t);
1603                          _t = _retTree;
1604 <                        _t = __t74;
1604 >                        _t = __t75;
1605                          _t = _t->getNextSibling();
1606 < #line 240 "MDTreeParser.g"
1606 > #line 243 "MDTreeParser.g"
1607                          currRigidBodyStamp->setMembers(ivec);
1608 < #line 1540 "MDTreeParser.cpp"
1608 > #line 1609 "MDTreeParser.cpp"
1609                          break;
1610                  }
1611                  default:
# Line 1555 | Line 1624 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1624  
1625   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1626          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1627 < #line 253 "MDTreeParser.g"
1627 > #line 256 "MDTreeParser.g"
1628          
1629          vector<int> ivec;
1630          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1631          
1632 < #line 1564 "MDTreeParser.cpp"
1632 > #line 1633 "MDTreeParser.cpp"
1633          
1634          try {      // for error handling
1635                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1574 | Line 1643 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1643                  }
1644                  case MEMBERS:
1645                  {
1646 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1647 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1646 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1647 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1648                          match(_t,MEMBERS);
1649                          _t = _t->getFirstChild();
1650                          ivec=inttuple(_t);
1651                          _t = _retTree;
1652 <                        _t = __t80;
1652 >                        _t = __t81;
1653                          _t = _t->getNextSibling();
1654 < #line 259 "MDTreeParser.g"
1654 > #line 262 "MDTreeParser.g"
1655                          currCutoffGroupStamp->setMembers(ivec);
1656 < #line 1588 "MDTreeParser.cpp"
1656 > #line 1657 "MDTreeParser.cpp"
1657                          break;
1658                  }
1659                  default:
# Line 1616 | Line 1685 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1685          _retTree = _t;
1686   }
1687  
1688 + void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1689 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1690 + #line 288 "MDTreeParser.g"
1691 +        
1692 +        vector<int> ivec;
1693 +        ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1694 +        
1695 + #line 1696 "MDTreeParser.cpp"
1696 +        
1697 +        try {      // for error handling
1698 +                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1699 +                        _t = ASTNULL;
1700 +                switch ( _t->getType()) {
1701 +                case ASSIGNEQUAL:
1702 +                {
1703 +                        assignment(_t);
1704 +                        _t = _retTree;
1705 +                        break;
1706 +                }
1707 +                case MEMBERS:
1708 +                {
1709 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1710 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1711 +                        match(_t,MEMBERS);
1712 +                        _t = _t->getFirstChild();
1713 +                        ivec=inttuple(_t);
1714 +                        _t = _retTree;
1715 +                        _t = __t92;
1716 +                        _t = _t->getNextSibling();
1717 + #line 294 "MDTreeParser.g"
1718 +                        currConstraintStamp->setMembers(ivec);
1719 + #line 1720 "MDTreeParser.cpp"
1720 +                        break;
1721 +                }
1722 +                default:
1723 +                {
1724 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1725 +                }
1726 +                }
1727 +        }
1728 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1729 +                reportError(ex);
1730 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1731 +                        _t = _t->getNextSibling();
1732 +        }
1733 +        _retTree = _t;
1734 + }
1735 +
1736   void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1737   {
1738   }
# Line 1635 | Line 1752 | const char* MDTreeParser::tokenNames[] = {
1752          "\"inversion\"",
1753          "\"rigidBody\"",
1754          "\"cutoffGroup\"",
1755 +        "\"constraint\"",
1756 +        "\"distance\"",
1757          "\"fragment\"",
1758          "\"members\"",
1759          "\"center\"",
1760 +        "\"satellites\"",
1761          "\"position\"",
1762          "\"orientation\"",
1763          "\"flucQ\"",
# Line 1680 | Line 1800 | const char* MDTreeParser::tokenNames[] = {
1800          0
1801   };
1802  
1803 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1803 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1804   // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1805   // ASSIGNEQUAL
1806   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1807 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1807 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1808   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1809 < // "fragment" ASSIGNEQUAL
1809 > // "constraint" "fragment" ASSIGNEQUAL
1810   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1811  
1812  

Diff Legend

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