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 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20140107): "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 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 710 | 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 732 | 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 110 "MDParser.g"
728 <                tmp39_AST->setType(ENDBLOCK);
729 < #line 742 "MDParser.cpp"
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 754 | 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 791 | 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 119 "MDParser.g"
787 <                tmp44_AST->setType(ENDBLOCK);
788 < #line 801 "MDParser.cpp"
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 813 | 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 850 | 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 126 "MDParser.g"
846 <                tmp49_AST->setType(ENDBLOCK);
847 < #line 860 "MDParser.cpp"
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 872 | 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 909 | 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 133 "MDParser.g"
905 <                tmp54_AST->setType(ENDBLOCK);
906 < #line 919 "MDParser.cpp"
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 931 | 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 968 | 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 140 "MDParser.g"
964 <                tmp59_AST->setType(ENDBLOCK);
965 < #line 978 "MDParser.cpp"
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 990 | 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 1012 | 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 148 "MDParser.g"
1008 <                tmp64_AST->setType(ENDBLOCK);
1009 < #line 1022 "MDParser.cpp"
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 1034 | 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 1071 | 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 155 "MDParser.g"
1067 <                tmp69_AST->setType(ENDBLOCK);
1068 < #line 1081 "MDParser.cpp"
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 1093 | 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 1115 | 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 162 "MDParser.g"
1111 <                tmp74_AST->setType(ENDBLOCK);
1112 < #line 1125 "MDParser.cpp"
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 1137 | Line 1125 | void MDParser::constraintblock() {
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 tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1129 <                tmp75_AST = astFactory->create(LT(1));
1130 <                astFactory->makeASTRoot(currentAST, tmp75_AST);
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)) {
# Line 1174 | Line 1162 | void MDParser::constraintblock() {
1162                  }
1163                  _loop69:;
1164                  } // ( ... )*
1165 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1166 <                tmp79_AST = astFactory->create(LT(1));
1167 <                astFactory->addASTChild(currentAST, tmp79_AST);
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 <                tmp79_AST->setType(ENDBLOCK);
1171 < #line 1184 "MDParser.cpp"
1170 >                tmp77_AST->setType(ENDBLOCK);
1171 > #line 1172 "MDParser.cpp"
1172                  constraintblock_AST = currentAST.root;
1173          }
1174          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1206 | Line 1194 | void MDParser::atomstatement() {
1194                  }
1195                  case POSITION:
1196                  {
1197 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1198 <                        tmp80_AST = astFactory->create(LT(1));
1199 <                        astFactory->makeASTRoot(currentAST, tmp80_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 1220 | Line 1208 | void MDParser::atomstatement() {
1208                  }
1209                  case ORIENTATION:
1210                  {
1211 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 <                        tmp84_AST = astFactory->create(LT(1));
1213 <                        astFactory->makeASTRoot(currentAST, tmp84_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 1292 | Line 1280 | void MDParser::bondstatement() {
1280                  }
1281                  case MEMBERS:
1282                  {
1283 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1284 <                        tmp89_AST = astFactory->create(LT(1));
1285 <                        astFactory->makeASTRoot(currentAST, tmp89_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 1364 | Line 1352 | void MDParser::bendstatement() {
1352                  }
1353                  case MEMBERS:
1354                  {
1355 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1356 <                        tmp94_AST = astFactory->create(LT(1));
1357 <                        astFactory->makeASTRoot(currentAST, tmp94_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 1405 | Line 1393 | void MDParser::torsionstatement() {
1393                  }
1394                  case MEMBERS:
1395                  {
1396 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 <                        tmp98_AST = astFactory->create(LT(1));
1398 <                        astFactory->makeASTRoot(currentAST, tmp98_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 1446 | Line 1434 | void MDParser::inversionstatement() {
1434                  }
1435                  case CENTER:
1436                  {
1437 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438 <                        tmp102_AST = astFactory->create(LT(1));
1439 <                        astFactory->makeASTRoot(currentAST, tmp102_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 1460 | Line 1448 | void MDParser::inversionstatement() {
1448                  }
1449                  case SATELLITES:
1450                  {
1451 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1452 <                        tmp106_AST = astFactory->create(LT(1));
1453 <                        astFactory->makeASTRoot(currentAST, tmp106_AST);
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();
# Line 1501 | Line 1489 | void MDParser::rigidbodystatement() {
1489                  }
1490                  case MEMBERS:
1491                  {
1492 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1493 <                        tmp110_AST = astFactory->create(LT(1));
1494 <                        astFactory->makeASTRoot(currentAST, tmp110_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 1542 | Line 1530 | void MDParser::cutoffgroupstatement() {
1530                  }
1531                  case MEMBERS:
1532                  {
1533 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1534 <                        tmp114_AST = astFactory->create(LT(1));
1535 <                        astFactory->makeASTRoot(currentAST, tmp114_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 1600 | Line 1588 | void MDParser::constraintstatement() {
1588                  }
1589                  case MEMBERS:
1590                  {
1591 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1592 <                        tmp118_AST = astFactory->create(LT(1));
1593 <                        astFactory->makeASTRoot(currentAST, tmp118_AST);
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();

Diff Legend

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