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

Comparing trunk/src/mdParser/MDParser.cpp (file contents):
Revision 1782 by gezelter, Wed Aug 22 02:28:28 2012 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20120725): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20141024): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 188 | Line 188 | void MDParser::componentblock() {
188                  tmp6_AST = astFactory->create(LT(1));
189                  astFactory->addASTChild(currentAST, tmp6_AST);
190                  match(RCURLY);
191 < #line 74 "MDParser.g"
191 > #line 77 "MDParser.g"
192                  tmp6_AST->setType(ENDBLOCK);
193   #line 194 "MDParser.cpp"
194                  componentblock_AST = currentAST.root;
# Line 228 | Line 228 | void MDParser::moleculeblock() {
228                  tmp9_AST = astFactory->create(LT(1));
229                  astFactory->addASTChild(currentAST, tmp9_AST);
230                  match(RCURLY);
231 < #line 92 "MDParser.g"
231 > #line 95 "MDParser.g"
232                  tmp9_AST->setType(ENDBLOCK);
233   #line 234 "MDParser.cpp"
234                  moleculeblock_AST = currentAST.root;
# Line 268 | Line 268 | void MDParser::zconstraintblock() {
268                  tmp12_AST = astFactory->create(LT(1));
269                  astFactory->addASTChild(currentAST, tmp12_AST);
270                  match(RCURLY);
271 < #line 77 "MDParser.g"
271 > #line 80 "MDParser.g"
272                  tmp12_AST->setType(ENDBLOCK);
273   #line 274 "MDParser.cpp"
274                  zconstraintblock_AST = currentAST.root;
# Line 308 | Line 308 | void MDParser::restraintblock() {
308                  tmp15_AST = astFactory->create(LT(1));
309                  astFactory->addASTChild(currentAST, tmp15_AST);
310                  match(RCURLY);
311 < #line 80 "MDParser.g"
311 > #line 83 "MDParser.g"
312                  tmp15_AST->setType(ENDBLOCK);
313   #line 314 "MDParser.cpp"
314                  restraintblock_AST = currentAST.root;
# Line 348 | Line 348 | void MDParser::flucqblock() {
348                  tmp18_AST = astFactory->create(LT(1));
349                  astFactory->addASTChild(currentAST, tmp18_AST);
350                  match(RCURLY);
351 < #line 83 "MDParser.g"
351 > #line 86 "MDParser.g"
352                  tmp18_AST->setType(ENDBLOCK);
353   #line 354 "MDParser.cpp"
354                  flucqblock_AST = currentAST.root;
# Line 388 | Line 388 | void MDParser::rnemdblock() {
388                  tmp21_AST = astFactory->create(LT(1));
389                  astFactory->addASTChild(currentAST, tmp21_AST);
390                  match(RCURLY);
391 < #line 86 "MDParser.g"
391 > #line 89 "MDParser.g"
392                  tmp21_AST->setType(ENDBLOCK);
393   #line 394 "MDParser.cpp"
394                  rnemdblock_AST = currentAST.root;
# Line 428 | Line 428 | void MDParser::minimizerblock() {
428                  tmp24_AST = astFactory->create(LT(1));
429                  astFactory->addASTChild(currentAST, tmp24_AST);
430                  match(RCURLY);
431 < #line 89 "MDParser.g"
431 > #line 92 "MDParser.g"
432                  tmp24_AST->setType(ENDBLOCK);
433   #line 434 "MDParser.cpp"
434                  minimizerblock_AST = currentAST.root;
# Line 587 | Line 587 | void MDParser::vectorConst() {
587                  tmp31_AST = astFactory->create(LT(1));
588                  astFactory->makeASTRoot(currentAST, tmp31_AST);
589                  match(LPAREN);
590 <                doubleNumber();
590 >                doubleNumberTuple();
591                  astFactory->addASTChild( currentAST, returnAST );
592                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
593                  tmp32_AST = astFactory->create(LT(1));
594                  astFactory->addASTChild(currentAST, tmp32_AST);
595 –                match(COMMA);
596 –                doubleNumber();
597 –                astFactory->addASTChild( currentAST, returnAST );
598 –                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 –                tmp33_AST = astFactory->create(LT(1));
600 –                astFactory->addASTChild(currentAST, tmp33_AST);
601 –                match(COMMA);
602 –                doubleNumber();
603 –                astFactory->addASTChild( currentAST, returnAST );
604 –                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
605 –                tmp34_AST = astFactory->create(LT(1));
606 –                astFactory->addASTChild(currentAST, tmp34_AST);
595                  match(RPAREN);
596                  vectorConst_AST = currentAST.root;
597          }
# Line 680 | Line 668 | void MDParser::moleculestatement() {
668                  case FRAGMENT:
669                  {
670                          fragmentblock();
671 +                        astFactory->addASTChild( currentAST, returnAST );
672 +                        moleculestatement_AST = currentAST.root;
673 +                        break;
674 +                }
675 +                case CONSTRAINT:
676 +                {
677 +                        constraintblock();
678                          astFactory->addASTChild( currentAST, returnAST );
679                          moleculestatement_AST = currentAST.root;
680                          break;
# Line 703 | Line 698 | void MDParser::atomblock() {
698          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
699          
700          try {      // for error handling
701 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
702 <                tmp35_AST = astFactory->create(LT(1));
703 <                astFactory->makeASTRoot(currentAST, tmp35_AST);
701 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
702 >                tmp33_AST = astFactory->create(LT(1));
703 >                astFactory->makeASTRoot(currentAST, tmp33_AST);
704                  match(ATOM);
705                  match(LBRACKET);
706                  intConst();
# Line 725 | Line 720 | void MDParser::atomblock() {
720                  }
721                  _loop31:;
722                  } // ( ... )*
723 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
724 <                tmp39_AST = astFactory->create(LT(1));
725 <                astFactory->addASTChild(currentAST, tmp39_AST);
723 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
724 >                tmp37_AST = astFactory->create(LT(1));
725 >                astFactory->addASTChild(currentAST, tmp37_AST);
726                  match(RCURLY);
727 < #line 106 "MDParser.g"
728 <                tmp39_AST->setType(ENDBLOCK);
729 < #line 735 "MDParser.cpp"
727 > #line 110 "MDParser.g"
728 >                tmp37_AST->setType(ENDBLOCK);
729 > #line 730 "MDParser.cpp"
730                  atomblock_AST = currentAST.root;
731          }
732          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 747 | Line 742 | void MDParser::bondblock() {
742          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
743          
744          try {      // for error handling
745 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
746 <                tmp40_AST = astFactory->create(LT(1));
747 <                astFactory->makeASTRoot(currentAST, tmp40_AST);
745 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
746 >                tmp38_AST = astFactory->create(LT(1));
747 >                astFactory->makeASTRoot(currentAST, tmp38_AST);
748                  match(BOND);
749                  {
750                  switch ( LA(1)) {
# Line 784 | Line 779 | void MDParser::bondblock() {
779                  }
780                  _loop36:;
781                  } // ( ... )*
782 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
783 <                tmp44_AST = astFactory->create(LT(1));
784 <                astFactory->addASTChild(currentAST, tmp44_AST);
782 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
783 >                tmp42_AST = astFactory->create(LT(1));
784 >                astFactory->addASTChild(currentAST, tmp42_AST);
785                  match(RCURLY);
786 < #line 115 "MDParser.g"
787 <                tmp44_AST->setType(ENDBLOCK);
788 < #line 794 "MDParser.cpp"
786 > #line 119 "MDParser.g"
787 >                tmp42_AST->setType(ENDBLOCK);
788 > #line 789 "MDParser.cpp"
789                  bondblock_AST = currentAST.root;
790          }
791          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 806 | Line 801 | void MDParser::bendblock() {
801          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
802          
803          try {      // for error handling
804 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
805 <                tmp45_AST = astFactory->create(LT(1));
806 <                astFactory->makeASTRoot(currentAST, tmp45_AST);
804 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
805 >                tmp43_AST = astFactory->create(LT(1));
806 >                astFactory->makeASTRoot(currentAST, tmp43_AST);
807                  match(BEND);
808                  {
809                  switch ( LA(1)) {
# Line 843 | Line 838 | void MDParser::bendblock() {
838                  }
839                  _loop41:;
840                  } // ( ... )*
841 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
842 <                tmp49_AST = astFactory->create(LT(1));
843 <                astFactory->addASTChild(currentAST, tmp49_AST);
841 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
842 >                tmp47_AST = astFactory->create(LT(1));
843 >                astFactory->addASTChild(currentAST, tmp47_AST);
844                  match(RCURLY);
845 < #line 122 "MDParser.g"
846 <                tmp49_AST->setType(ENDBLOCK);
847 < #line 853 "MDParser.cpp"
845 > #line 126 "MDParser.g"
846 >                tmp47_AST->setType(ENDBLOCK);
847 > #line 848 "MDParser.cpp"
848                  bendblock_AST = currentAST.root;
849          }
850          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 865 | Line 860 | void MDParser::torsionblock() {
860          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
861          
862          try {      // for error handling
863 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
864 <                tmp50_AST = astFactory->create(LT(1));
865 <                astFactory->makeASTRoot(currentAST, tmp50_AST);
863 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
864 >                tmp48_AST = astFactory->create(LT(1));
865 >                astFactory->makeASTRoot(currentAST, tmp48_AST);
866                  match(TORSION);
867                  {
868                  switch ( LA(1)) {
# Line 902 | Line 897 | void MDParser::torsionblock() {
897                  }
898                  _loop46:;
899                  } // ( ... )*
900 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
901 <                tmp54_AST = astFactory->create(LT(1));
902 <                astFactory->addASTChild(currentAST, tmp54_AST);
900 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
901 >                tmp52_AST = astFactory->create(LT(1));
902 >                astFactory->addASTChild(currentAST, tmp52_AST);
903                  match(RCURLY);
904 < #line 129 "MDParser.g"
905 <                tmp54_AST->setType(ENDBLOCK);
906 < #line 912 "MDParser.cpp"
904 > #line 133 "MDParser.g"
905 >                tmp52_AST->setType(ENDBLOCK);
906 > #line 907 "MDParser.cpp"
907                  torsionblock_AST = currentAST.root;
908          }
909          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 924 | Line 919 | void MDParser::inversionblock() {
919          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
920          
921          try {      // for error handling
922 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
923 <                tmp55_AST = astFactory->create(LT(1));
924 <                astFactory->makeASTRoot(currentAST, tmp55_AST);
922 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
923 >                tmp53_AST = astFactory->create(LT(1));
924 >                astFactory->makeASTRoot(currentAST, tmp53_AST);
925                  match(INVERSION);
926                  {
927                  switch ( LA(1)) {
# Line 950 | Line 945 | void MDParser::inversionblock() {
945                  match(LCURLY);
946                  { // ( ... )*
947                  for (;;) {
948 <                        if ((LA(1) == CENTER || LA(1) == ID)) {
948 >                        if ((_tokenSet_10.member(LA(1)))) {
949                                  inversionstatement();
950                                  astFactory->addASTChild( currentAST, returnAST );
951                          }
# Line 961 | Line 956 | void MDParser::inversionblock() {
956                  }
957                  _loop51:;
958                  } // ( ... )*
959 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
960 <                tmp59_AST = astFactory->create(LT(1));
961 <                astFactory->addASTChild(currentAST, tmp59_AST);
959 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
960 >                tmp57_AST = astFactory->create(LT(1));
961 >                astFactory->addASTChild(currentAST, tmp57_AST);
962                  match(RCURLY);
963 < #line 136 "MDParser.g"
964 <                tmp59_AST->setType(ENDBLOCK);
965 < #line 971 "MDParser.cpp"
963 > #line 140 "MDParser.g"
964 >                tmp57_AST->setType(ENDBLOCK);
965 > #line 966 "MDParser.cpp"
966                  inversionblock_AST = currentAST.root;
967          }
968          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 983 | Line 978 | void MDParser::rigidbodyblock() {
978          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
979          
980          try {      // for error handling
981 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
982 <                tmp60_AST = astFactory->create(LT(1));
983 <                astFactory->makeASTRoot(currentAST, tmp60_AST);
981 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
982 >                tmp58_AST = astFactory->create(LT(1));
983 >                astFactory->makeASTRoot(currentAST, tmp58_AST);
984                  match(RIGIDBODY);
985                  match(LBRACKET);
986                  intConst();
# Line 1005 | Line 1000 | void MDParser::rigidbodyblock() {
1000                  }
1001                  _loop55:;
1002                  } // ( ... )*
1003 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1004 <                tmp64_AST = astFactory->create(LT(1));
1005 <                astFactory->addASTChild(currentAST, tmp64_AST);
1003 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1004 >                tmp62_AST = astFactory->create(LT(1));
1005 >                astFactory->addASTChild(currentAST, tmp62_AST);
1006                  match(RCURLY);
1007 < #line 143 "MDParser.g"
1008 <                tmp64_AST->setType(ENDBLOCK);
1009 < #line 1015 "MDParser.cpp"
1007 > #line 148 "MDParser.g"
1008 >                tmp62_AST->setType(ENDBLOCK);
1009 > #line 1010 "MDParser.cpp"
1010                  rigidbodyblock_AST = currentAST.root;
1011          }
1012          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1027 | Line 1022 | void MDParser::cutoffgroupblock() {
1022          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1023          
1024          try {      // for error handling
1025 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026 <                tmp65_AST = astFactory->create(LT(1));
1027 <                astFactory->makeASTRoot(currentAST, tmp65_AST);
1025 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026 >                tmp63_AST = astFactory->create(LT(1));
1027 >                astFactory->makeASTRoot(currentAST, tmp63_AST);
1028                  match(CUTOFFGROUP);
1029                  {
1030                  switch ( LA(1)) {
# Line 1064 | Line 1059 | void MDParser::cutoffgroupblock() {
1059                  }
1060                  _loop60:;
1061                  } // ( ... )*
1062 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1063 <                tmp69_AST = astFactory->create(LT(1));
1064 <                astFactory->addASTChild(currentAST, tmp69_AST);
1062 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1063 >                tmp67_AST = astFactory->create(LT(1));
1064 >                astFactory->addASTChild(currentAST, tmp67_AST);
1065                  match(RCURLY);
1066 < #line 150 "MDParser.g"
1067 <                tmp69_AST->setType(ENDBLOCK);
1068 < #line 1074 "MDParser.cpp"
1066 > #line 155 "MDParser.g"
1067 >                tmp67_AST->setType(ENDBLOCK);
1068 > #line 1069 "MDParser.cpp"
1069                  cutoffgroupblock_AST = currentAST.root;
1070          }
1071          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1086 | Line 1081 | void MDParser::fragmentblock() {
1081          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1082          
1083          try {      // for error handling
1084 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1085 <                tmp70_AST = astFactory->create(LT(1));
1086 <                astFactory->makeASTRoot(currentAST, tmp70_AST);
1084 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1085 >                tmp68_AST = astFactory->create(LT(1));
1086 >                astFactory->makeASTRoot(currentAST, tmp68_AST);
1087                  match(FRAGMENT);
1088                  match(LBRACKET);
1089                  intConst();
# Line 1108 | Line 1103 | void MDParser::fragmentblock() {
1103                  }
1104                  _loop64:;
1105                  } // ( ... )*
1106 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1107 <                tmp74_AST = astFactory->create(LT(1));
1108 <                astFactory->addASTChild(currentAST, tmp74_AST);
1106 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1107 >                tmp72_AST = astFactory->create(LT(1));
1108 >                astFactory->addASTChild(currentAST, tmp72_AST);
1109                  match(RCURLY);
1110 < #line 157 "MDParser.g"
1111 <                tmp74_AST->setType(ENDBLOCK);
1112 < #line 1118 "MDParser.cpp"
1110 > #line 162 "MDParser.g"
1111 >                tmp72_AST->setType(ENDBLOCK);
1112 > #line 1113 "MDParser.cpp"
1113                  fragmentblock_AST = currentAST.root;
1114          }
1115          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1122 | Line 1117 | void MDParser::fragmentblock() {
1117                  recover(ex,_tokenSet_8);
1118          }
1119          returnAST = fragmentblock_AST;
1120 + }
1121 +
1122 + void MDParser::constraintblock() {
1123 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1124 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1125 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1126 +        
1127 +        try {      // for error handling
1128 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1129 +                tmp73_AST = astFactory->create(LT(1));
1130 +                astFactory->makeASTRoot(currentAST, tmp73_AST);
1131 +                match(CONSTRAINT);
1132 +                {
1133 +                switch ( LA(1)) {
1134 +                case LBRACKET:
1135 +                {
1136 +                        match(LBRACKET);
1137 +                        intConst();
1138 +                        match(RBRACKET);
1139 +                        break;
1140 +                }
1141 +                case LCURLY:
1142 +                {
1143 +                        break;
1144 +                }
1145 +                default:
1146 +                {
1147 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1148 +                }
1149 +                }
1150 +                }
1151 +                match(LCURLY);
1152 +                { // ( ... )*
1153 +                for (;;) {
1154 +                        if ((LA(1) == MEMBERS || LA(1) == ID)) {
1155 +                                constraintstatement();
1156 +                                astFactory->addASTChild( currentAST, returnAST );
1157 +                        }
1158 +                        else {
1159 +                                goto _loop69;
1160 +                        }
1161 +                        
1162 +                }
1163 +                _loop69:;
1164 +                } // ( ... )*
1165 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1166 +                tmp77_AST = astFactory->create(LT(1));
1167 +                astFactory->addASTChild(currentAST, tmp77_AST);
1168 +                match(RCURLY);
1169 + #line 168 "MDParser.g"
1170 +                tmp77_AST->setType(ENDBLOCK);
1171 + #line 1172 "MDParser.cpp"
1172 +                constraintblock_AST = currentAST.root;
1173 +        }
1174 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1175 +                reportError(ex);
1176 +                recover(ex,_tokenSet_8);
1177 +        }
1178 +        returnAST = constraintblock_AST;
1179   }
1180  
1181   void MDParser::atomstatement() {
# Line 1140 | Line 1194 | void MDParser::atomstatement() {
1194                  }
1195                  case POSITION:
1196                  {
1197 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1198 <                        tmp75_AST = astFactory->create(LT(1));
1199 <                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1197 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1198 >                        tmp78_AST = astFactory->create(LT(1));
1199 >                        astFactory->makeASTRoot(currentAST, tmp78_AST);
1200                          match(POSITION);
1201                          match(LPAREN);
1202                          doubleNumberTuple();
# Line 1154 | Line 1208 | void MDParser::atomstatement() {
1208                  }
1209                  case ORIENTATION:
1210                  {
1211 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 <                        tmp79_AST = astFactory->create(LT(1));
1213 <                        astFactory->makeASTRoot(currentAST, tmp79_AST);
1211 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 >                        tmp82_AST = astFactory->create(LT(1));
1213 >                        astFactory->makeASTRoot(currentAST, tmp82_AST);
1214                          match(ORIENTATION);
1215                          match(LPAREN);
1216                          doubleNumberTuple();
# Line 1174 | Line 1228 | void MDParser::atomstatement() {
1228          }
1229          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1230                  reportError(ex);
1231 <                recover(ex,_tokenSet_10);
1231 >                recover(ex,_tokenSet_11);
1232          }
1233          returnAST = atomstatement_AST;
1234   }
# Line 1195 | Line 1249 | void MDParser::doubleNumberTuple() {
1249                                  astFactory->addASTChild( currentAST, returnAST );
1250                          }
1251                          else {
1252 <                                goto _loop68;
1252 >                                goto _loop73;
1253                          }
1254                          
1255                  }
1256 <                _loop68:;
1256 >                _loop73:;
1257                  } // ( ... )*
1258                  doubleNumberTuple_AST = currentAST.root;
1259          }
1260          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1261                  reportError(ex);
1262 <                recover(ex,_tokenSet_11);
1262 >                recover(ex,_tokenSet_12);
1263          }
1264          returnAST = doubleNumberTuple_AST;
1265   }
# Line 1226 | Line 1280 | void MDParser::bondstatement() {
1280                  }
1281                  case MEMBERS:
1282                  {
1283 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1284 <                        tmp84_AST = astFactory->create(LT(1));
1285 <                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1283 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1284 >                        tmp87_AST = astFactory->create(LT(1));
1285 >                        astFactory->makeASTRoot(currentAST, tmp87_AST);
1286                          match(MEMBERS);
1287                          match(LPAREN);
1288                          inttuple();
# Line 1246 | Line 1300 | void MDParser::bondstatement() {
1300          }
1301          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1302                  reportError(ex);
1303 <                recover(ex,_tokenSet_12);
1303 >                recover(ex,_tokenSet_13);
1304          }
1305          returnAST = bondstatement_AST;
1306   }
# Line 1267 | Line 1321 | void MDParser::inttuple() {
1321                                  astFactory->addASTChild( currentAST, returnAST );
1322                          }
1323                          else {
1324 <                                goto _loop71;
1324 >                                goto _loop76;
1325                          }
1326                          
1327                  }
1328 <                _loop71:;
1328 >                _loop76:;
1329                  } // ( ... )*
1330                  inttuple_AST = currentAST.root;
1331          }
1332          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1333                  reportError(ex);
1334 <                recover(ex,_tokenSet_11);
1334 >                recover(ex,_tokenSet_12);
1335          }
1336          returnAST = inttuple_AST;
1337   }
# Line 1298 | Line 1352 | void MDParser::bendstatement() {
1352                  }
1353                  case MEMBERS:
1354                  {
1355 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1356 <                        tmp89_AST = astFactory->create(LT(1));
1357 <                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1355 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1356 >                        tmp92_AST = astFactory->create(LT(1));
1357 >                        astFactory->makeASTRoot(currentAST, tmp92_AST);
1358                          match(MEMBERS);
1359                          match(LPAREN);
1360                          inttuple();
# Line 1318 | Line 1372 | void MDParser::bendstatement() {
1372          }
1373          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1374                  reportError(ex);
1375 <                recover(ex,_tokenSet_12);
1375 >                recover(ex,_tokenSet_13);
1376          }
1377          returnAST = bendstatement_AST;
1378   }
# Line 1339 | Line 1393 | void MDParser::torsionstatement() {
1393                  }
1394                  case MEMBERS:
1395                  {
1396 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 <                        tmp93_AST = astFactory->create(LT(1));
1398 <                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1396 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 >                        tmp96_AST = astFactory->create(LT(1));
1398 >                        astFactory->makeASTRoot(currentAST, tmp96_AST);
1399                          match(MEMBERS);
1400                          match(LPAREN);
1401                          inttuple();
# Line 1359 | Line 1413 | void MDParser::torsionstatement() {
1413          }
1414          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1415                  reportError(ex);
1416 <                recover(ex,_tokenSet_12);
1416 >                recover(ex,_tokenSet_13);
1417          }
1418          returnAST = torsionstatement_AST;
1419   }
# Line 1380 | Line 1434 | void MDParser::inversionstatement() {
1434                  }
1435                  case CENTER:
1436                  {
1437 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438 <                        tmp97_AST = astFactory->create(LT(1));
1439 <                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1437 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438 >                        tmp100_AST = astFactory->create(LT(1));
1439 >                        astFactory->makeASTRoot(currentAST, tmp100_AST);
1440                          match(CENTER);
1441                          match(LPAREN);
1442                          intConst();
# Line 1392 | Line 1446 | void MDParser::inversionstatement() {
1446                          inversionstatement_AST = currentAST.root;
1447                          break;
1448                  }
1449 +                case SATELLITES:
1450 +                {
1451 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1452 +                        tmp104_AST = astFactory->create(LT(1));
1453 +                        astFactory->makeASTRoot(currentAST, tmp104_AST);
1454 +                        match(SATELLITES);
1455 +                        match(LPAREN);
1456 +                        inttuple();
1457 +                        astFactory->addASTChild( currentAST, returnAST );
1458 +                        match(RPAREN);
1459 +                        match(SEMICOLON);
1460 +                        inversionstatement_AST = currentAST.root;
1461 +                        break;
1462 +                }
1463                  default:
1464                  {
1465                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 1400 | Line 1468 | void MDParser::inversionstatement() {
1468          }
1469          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1470                  reportError(ex);
1471 <                recover(ex,_tokenSet_13);
1471 >                recover(ex,_tokenSet_14);
1472          }
1473          returnAST = inversionstatement_AST;
1474   }
# Line 1421 | Line 1489 | void MDParser::rigidbodystatement() {
1489                  }
1490                  case MEMBERS:
1491                  {
1492 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1493 <                        tmp101_AST = astFactory->create(LT(1));
1494 <                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1492 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1493 >                        tmp108_AST = astFactory->create(LT(1));
1494 >                        astFactory->makeASTRoot(currentAST, tmp108_AST);
1495                          match(MEMBERS);
1496                          match(LPAREN);
1497                          inttuple();
# Line 1441 | Line 1509 | void MDParser::rigidbodystatement() {
1509          }
1510          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1511                  reportError(ex);
1512 <                recover(ex,_tokenSet_12);
1512 >                recover(ex,_tokenSet_13);
1513          }
1514          returnAST = rigidbodystatement_AST;
1515   }
# Line 1462 | Line 1530 | void MDParser::cutoffgroupstatement() {
1530                  }
1531                  case MEMBERS:
1532                  {
1533 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1534 <                        tmp105_AST = astFactory->create(LT(1));
1535 <                        astFactory->makeASTRoot(currentAST, tmp105_AST);
1533 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1534 >                        tmp112_AST = astFactory->create(LT(1));
1535 >                        astFactory->makeASTRoot(currentAST, tmp112_AST);
1536                          match(MEMBERS);
1537                          match(LPAREN);
1538                          inttuple();
# Line 1482 | Line 1550 | void MDParser::cutoffgroupstatement() {
1550          }
1551          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1552                  reportError(ex);
1553 <                recover(ex,_tokenSet_12);
1553 >                recover(ex,_tokenSet_13);
1554          }
1555          returnAST = cutoffgroupstatement_AST;
1556   }
# Line 1499 | Line 1567 | void MDParser::fragmentstatement() {
1567          }
1568          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1569                  reportError(ex);
1570 <                recover(ex,_tokenSet_14);
1570 >                recover(ex,_tokenSet_15);
1571          }
1572          returnAST = fragmentstatement_AST;
1573 + }
1574 +
1575 + void MDParser::constraintstatement() {
1576 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1577 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1578 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1579 +        
1580 +        try {      // for error handling
1581 +                switch ( LA(1)) {
1582 +                case ID:
1583 +                {
1584 +                        assignment();
1585 +                        astFactory->addASTChild( currentAST, returnAST );
1586 +                        constraintstatement_AST = currentAST.root;
1587 +                        break;
1588 +                }
1589 +                case MEMBERS:
1590 +                {
1591 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1592 +                        tmp116_AST = astFactory->create(LT(1));
1593 +                        astFactory->makeASTRoot(currentAST, tmp116_AST);
1594 +                        match(MEMBERS);
1595 +                        match(LPAREN);
1596 +                        inttuple();
1597 +                        astFactory->addASTChild( currentAST, returnAST );
1598 +                        match(RPAREN);
1599 +                        match(SEMICOLON);
1600 +                        constraintstatement_AST = currentAST.root;
1601 +                        break;
1602 +                }
1603 +                default:
1604 +                {
1605 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1606 +                }
1607 +                }
1608 +        }
1609 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1610 +                reportError(ex);
1611 +                recover(ex,_tokenSet_13);
1612 +        }
1613 +        returnAST = constraintstatement_AST;
1614   }
1615  
1616   void MDParser::doubleNumber() {
# Line 1536 | Line 1645 | void MDParser::doubleNumber() {
1645          }
1646          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1647                  reportError(ex);
1648 <                recover(ex,_tokenSet_15);
1648 >                recover(ex,_tokenSet_16);
1649          }
1650          returnAST = doubleNumber_AST;
1651   }
1652  
1653   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1654   {
1655 <        factory.setMaxNodeType(56);
1655 >        factory.setMaxNodeType(59);
1656   }
1657   const char* MDParser::tokenNames[] = {
1658          "<0>",
# Line 1561 | Line 1670 | const char* MDParser::tokenNames[] = {
1670          "\"inversion\"",
1671          "\"rigidBody\"",
1672          "\"cutoffGroup\"",
1673 +        "\"constraint\"",
1674 +        "\"distance\"",
1675          "\"fragment\"",
1676          "\"members\"",
1677          "\"center\"",
1678 +        "\"satellites\"",
1679          "\"position\"",
1680          "\"orientation\"",
1681          "\"flucQ\"",
# Line 1606 | Line 1718 | const char* MDParser::tokenNames[] = {
1718          0
1719   };
1720  
1721 < const unsigned long MDParser::_tokenSet_0_data_[] = { 24117488UL, 0UL, 0UL, 0UL };
1721 > const unsigned long MDParser::_tokenSet_0_data_[] = { 192938224UL, 0UL, 0UL, 0UL };
1722   // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1723   // ID
1724   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1725   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1726   // EOF
1727   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1728 < const unsigned long MDParser::_tokenSet_2_data_[] = { 24117490UL, 0UL, 0UL, 0UL };
1728 > const unsigned long MDParser::_tokenSet_2_data_[] = { 192938226UL, 0UL, 0UL, 0UL };
1729   // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1730   // "minimizer" ID
1731   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1732 < const unsigned long MDParser::_tokenSet_3_data_[] = { 562036722UL, 0UL, 0UL, 0UL };
1732 > const unsigned long MDParser::_tokenSet_3_data_[] = { 201261042UL, 1UL, 0UL, 0UL };
1733   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1734 < // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1735 < // "center" "position" "orientation" "flucQ" "RNEMD" "minimizer" ID RCURLY
1734 > // "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment"
1735 > // "members" "center" "satellites" "position" "orientation" "flucQ" "RNEMD"
1736 > // "minimizer" ID RCURLY
1737   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1738 < const unsigned long MDParser::_tokenSet_4_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1738 > const unsigned long MDParser::_tokenSet_4_data_[] = { 134414080UL, 0UL, 0UL, 0UL };
1739   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1740 < // "fragment" ID
1740 > // "constraint" "fragment" ID
1741   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1742 < const unsigned long MDParser::_tokenSet_5_data_[] = { 67108864UL, 0UL, 0UL, 0UL };
1742 > const unsigned long MDParser::_tokenSet_5_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1743   // SEMICOLON
1744   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1745 < const unsigned long MDParser::_tokenSet_6_data_[] = { 2214592512UL, 6UL, 0UL, 0UL };
1745 > const unsigned long MDParser::_tokenSet_6_data_[] = { 536870912UL, 52UL, 0UL, 0UL };
1746   // SEMICOLON RBRACKET RPAREN COMMA
1747   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1748 < const unsigned long MDParser::_tokenSet_7_data_[] = { 67108864UL, 6UL, 0UL, 0UL };
1748 > const unsigned long MDParser::_tokenSet_7_data_[] = { 536870912UL, 48UL, 0UL, 0UL };
1749   // SEMICOLON RPAREN COMMA
1750   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1751 < const unsigned long MDParser::_tokenSet_8_data_[] = { 553713408UL, 0UL, 0UL, 0UL };
1751 > const unsigned long MDParser::_tokenSet_8_data_[] = { 134414080UL, 1UL, 0UL, 0UL };
1752   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1753 < // "fragment" ID RCURLY
1753 > // "constraint" "fragment" ID RCURLY
1754   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1755 < const unsigned long MDParser::_tokenSet_9_data_[] = { 17563648UL, 0UL, 0UL, 0UL };
1755 > const unsigned long MDParser::_tokenSet_9_data_[] = { 140509184UL, 0UL, 0UL, 0UL };
1756   // "position" "orientation" ID
1757   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1758 < const unsigned long MDParser::_tokenSet_10_data_[] = { 554434560UL, 0UL, 0UL, 0UL };
1759 < // "position" "orientation" ID RCURLY
1758 > const unsigned long MDParser::_tokenSet_10_data_[] = { 135790592UL, 0UL, 0UL, 0UL };
1759 > // "center" "satellites" ID
1760   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1761 < const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 2UL, 0UL, 0UL };
1762 < // RPAREN
1761 > const unsigned long MDParser::_tokenSet_11_data_[] = { 140509184UL, 1UL, 0UL, 0UL };
1762 > // "position" "orientation" ID RCURLY
1763   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1764 < const unsigned long MDParser::_tokenSet_12_data_[] = { 553713664UL, 0UL, 0UL, 0UL };
1765 < // "members" ID RCURLY
1764 > const unsigned long MDParser::_tokenSet_12_data_[] = { 0UL, 16UL, 0UL, 0UL };
1765 > // RPAREN
1766   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1767 < const unsigned long MDParser::_tokenSet_13_data_[] = { 553779200UL, 0UL, 0UL, 0UL };
1768 < // "center" ID RCURLY
1767 > const unsigned long MDParser::_tokenSet_13_data_[] = { 134479872UL, 1UL, 0UL, 0UL };
1768 > // "members" ID RCURLY
1769   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1770 < const unsigned long MDParser::_tokenSet_14_data_[] = { 553648128UL, 0UL, 0UL, 0UL };
1771 < // ID RCURLY
1770 > const unsigned long MDParser::_tokenSet_14_data_[] = { 135790592UL, 1UL, 0UL, 0UL };
1771 > // "center" "satellites" ID RCURLY
1772   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1773 < const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 6UL, 0UL, 0UL };
1774 < // RPAREN COMMA
1773 > const unsigned long MDParser::_tokenSet_15_data_[] = { 134217728UL, 1UL, 0UL, 0UL };
1774 > // ID RCURLY
1775   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1776 + const unsigned long MDParser::_tokenSet_16_data_[] = { 0UL, 48UL, 0UL, 0UL };
1777 + // RPAREN COMMA
1778 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
1779  
1780  

Diff Legend

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