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

Comparing branches/development/src/mdParser/MDParser.cpp (file contents):
Revision 1775 by gezelter, Wed Jun 6 02:18:54 2012 UTC vs.
Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20110725): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20120725): "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 73 "MDParser.g"
191 > #line 74 "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 91 "MDParser.g"
231 > #line 92 "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 76 "MDParser.g"
271 > #line 77 "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 79 "MDParser.g"
311 > #line 80 "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 82 "MDParser.g"
351 > #line 83 "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 85 "MDParser.g"
391 > #line 86 "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 88 "MDParser.g"
431 > #line 89 "MDParser.g"
432                  tmp24_AST->setType(ENDBLOCK);
433   #line 434 "MDParser.cpp"
434                  minimizerblock_AST = currentAST.root;
# Line 459 | Line 459 | void MDParser::constant() {
459                  case NUM_DOUBLE:
460                  {
461                          floatConst();
462 +                        astFactory->addASTChild( currentAST, returnAST );
463 +                        constant_AST = currentAST.root;
464 +                        break;
465 +                }
466 +                case LPAREN:
467 +                {
468 +                        vectorConst();
469                          astFactory->addASTChild( currentAST, returnAST );
470                          constant_AST = currentAST.root;
471                          break;
# Line 570 | Line 577 | void MDParser::floatConst() {
577          returnAST = floatConst_AST;
578   }
579  
580 + void MDParser::vectorConst() {
581 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
582 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
583 +        ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
584 +        
585 +        try {      // for error handling
586 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
587 +                tmp31_AST = astFactory->create(LT(1));
588 +                astFactory->makeASTRoot(currentAST, tmp31_AST);
589 +                match(LPAREN);
590 +                doubleNumber();
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);
607 +                match(RPAREN);
608 +                vectorConst_AST = currentAST.root;
609 +        }
610 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
611 +                reportError(ex);
612 +                recover(ex,_tokenSet_5);
613 +        }
614 +        returnAST = vectorConst_AST;
615 + }
616 +
617   void MDParser::moleculestatement() {
618          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
619          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 659 | Line 703 | void MDParser::atomblock() {
703          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
704          
705          try {      // for error handling
706 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 <                tmp31_AST = astFactory->create(LT(1));
708 <                astFactory->makeASTRoot(currentAST, tmp31_AST);
706 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 >                tmp35_AST = astFactory->create(LT(1));
708 >                astFactory->makeASTRoot(currentAST, tmp35_AST);
709                  match(ATOM);
710                  match(LBRACKET);
711                  intConst();
# Line 681 | Line 725 | void MDParser::atomblock() {
725                  }
726                  _loop31:;
727                  } // ( ... )*
728 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 <                tmp35_AST = astFactory->create(LT(1));
730 <                astFactory->addASTChild(currentAST, tmp35_AST);
728 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 >                tmp39_AST = astFactory->create(LT(1));
730 >                astFactory->addASTChild(currentAST, tmp39_AST);
731                  match(RCURLY);
732 < #line 105 "MDParser.g"
733 <                tmp35_AST->setType(ENDBLOCK);
734 < #line 691 "MDParser.cpp"
732 > #line 106 "MDParser.g"
733 >                tmp39_AST->setType(ENDBLOCK);
734 > #line 735 "MDParser.cpp"
735                  atomblock_AST = currentAST.root;
736          }
737          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 703 | Line 747 | void MDParser::bondblock() {
747          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
748          
749          try {      // for error handling
750 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 <                tmp36_AST = astFactory->create(LT(1));
752 <                astFactory->makeASTRoot(currentAST, tmp36_AST);
750 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 >                tmp40_AST = astFactory->create(LT(1));
752 >                astFactory->makeASTRoot(currentAST, tmp40_AST);
753                  match(BOND);
754                  {
755                  switch ( LA(1)) {
# Line 740 | Line 784 | void MDParser::bondblock() {
784                  }
785                  _loop36:;
786                  } // ( ... )*
787 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 <                tmp40_AST = astFactory->create(LT(1));
789 <                astFactory->addASTChild(currentAST, tmp40_AST);
787 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 >                tmp44_AST = astFactory->create(LT(1));
789 >                astFactory->addASTChild(currentAST, tmp44_AST);
790                  match(RCURLY);
791 < #line 114 "MDParser.g"
792 <                tmp40_AST->setType(ENDBLOCK);
793 < #line 750 "MDParser.cpp"
791 > #line 115 "MDParser.g"
792 >                tmp44_AST->setType(ENDBLOCK);
793 > #line 794 "MDParser.cpp"
794                  bondblock_AST = currentAST.root;
795          }
796          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 762 | Line 806 | void MDParser::bendblock() {
806          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
807          
808          try {      // for error handling
809 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 <                tmp41_AST = astFactory->create(LT(1));
811 <                astFactory->makeASTRoot(currentAST, tmp41_AST);
809 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 >                tmp45_AST = astFactory->create(LT(1));
811 >                astFactory->makeASTRoot(currentAST, tmp45_AST);
812                  match(BEND);
813                  {
814                  switch ( LA(1)) {
# Line 799 | Line 843 | void MDParser::bendblock() {
843                  }
844                  _loop41:;
845                  } // ( ... )*
846 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 <                tmp45_AST = astFactory->create(LT(1));
848 <                astFactory->addASTChild(currentAST, tmp45_AST);
846 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 >                tmp49_AST = astFactory->create(LT(1));
848 >                astFactory->addASTChild(currentAST, tmp49_AST);
849                  match(RCURLY);
850 < #line 121 "MDParser.g"
851 <                tmp45_AST->setType(ENDBLOCK);
852 < #line 809 "MDParser.cpp"
850 > #line 122 "MDParser.g"
851 >                tmp49_AST->setType(ENDBLOCK);
852 > #line 853 "MDParser.cpp"
853                  bendblock_AST = currentAST.root;
854          }
855          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 821 | Line 865 | void MDParser::torsionblock() {
865          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
866          
867          try {      // for error handling
868 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 <                tmp46_AST = astFactory->create(LT(1));
870 <                astFactory->makeASTRoot(currentAST, tmp46_AST);
868 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 >                tmp50_AST = astFactory->create(LT(1));
870 >                astFactory->makeASTRoot(currentAST, tmp50_AST);
871                  match(TORSION);
872                  {
873                  switch ( LA(1)) {
# Line 858 | Line 902 | void MDParser::torsionblock() {
902                  }
903                  _loop46:;
904                  } // ( ... )*
905 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 <                tmp50_AST = astFactory->create(LT(1));
907 <                astFactory->addASTChild(currentAST, tmp50_AST);
905 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 >                tmp54_AST = astFactory->create(LT(1));
907 >                astFactory->addASTChild(currentAST, tmp54_AST);
908                  match(RCURLY);
909 < #line 128 "MDParser.g"
910 <                tmp50_AST->setType(ENDBLOCK);
911 < #line 868 "MDParser.cpp"
909 > #line 129 "MDParser.g"
910 >                tmp54_AST->setType(ENDBLOCK);
911 > #line 912 "MDParser.cpp"
912                  torsionblock_AST = currentAST.root;
913          }
914          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 880 | Line 924 | void MDParser::inversionblock() {
924          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
925          
926          try {      // for error handling
927 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 <                tmp51_AST = astFactory->create(LT(1));
929 <                astFactory->makeASTRoot(currentAST, tmp51_AST);
927 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 >                tmp55_AST = astFactory->create(LT(1));
929 >                astFactory->makeASTRoot(currentAST, tmp55_AST);
930                  match(INVERSION);
931                  {
932                  switch ( LA(1)) {
# Line 917 | Line 961 | void MDParser::inversionblock() {
961                  }
962                  _loop51:;
963                  } // ( ... )*
964 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 <                tmp55_AST = astFactory->create(LT(1));
966 <                astFactory->addASTChild(currentAST, tmp55_AST);
964 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 >                tmp59_AST = astFactory->create(LT(1));
966 >                astFactory->addASTChild(currentAST, tmp59_AST);
967                  match(RCURLY);
968 < #line 135 "MDParser.g"
969 <                tmp55_AST->setType(ENDBLOCK);
970 < #line 927 "MDParser.cpp"
968 > #line 136 "MDParser.g"
969 >                tmp59_AST->setType(ENDBLOCK);
970 > #line 971 "MDParser.cpp"
971                  inversionblock_AST = currentAST.root;
972          }
973          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 939 | Line 983 | void MDParser::rigidbodyblock() {
983          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
984          
985          try {      // for error handling
986 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 <                tmp56_AST = astFactory->create(LT(1));
988 <                astFactory->makeASTRoot(currentAST, tmp56_AST);
986 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 >                tmp60_AST = astFactory->create(LT(1));
988 >                astFactory->makeASTRoot(currentAST, tmp60_AST);
989                  match(RIGIDBODY);
990                  match(LBRACKET);
991                  intConst();
# Line 961 | Line 1005 | void MDParser::rigidbodyblock() {
1005                  }
1006                  _loop55:;
1007                  } // ( ... )*
1008 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 <                tmp60_AST = astFactory->create(LT(1));
1010 <                astFactory->addASTChild(currentAST, tmp60_AST);
1008 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 >                tmp64_AST = astFactory->create(LT(1));
1010 >                astFactory->addASTChild(currentAST, tmp64_AST);
1011                  match(RCURLY);
1012 < #line 142 "MDParser.g"
1013 <                tmp60_AST->setType(ENDBLOCK);
1014 < #line 971 "MDParser.cpp"
1012 > #line 143 "MDParser.g"
1013 >                tmp64_AST->setType(ENDBLOCK);
1014 > #line 1015 "MDParser.cpp"
1015                  rigidbodyblock_AST = currentAST.root;
1016          }
1017          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 983 | Line 1027 | void MDParser::cutoffgroupblock() {
1027          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1028          
1029          try {      // for error handling
1030 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 <                tmp61_AST = astFactory->create(LT(1));
1032 <                astFactory->makeASTRoot(currentAST, tmp61_AST);
1030 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 >                tmp65_AST = astFactory->create(LT(1));
1032 >                astFactory->makeASTRoot(currentAST, tmp65_AST);
1033                  match(CUTOFFGROUP);
1034                  {
1035                  switch ( LA(1)) {
# Line 1020 | Line 1064 | void MDParser::cutoffgroupblock() {
1064                  }
1065                  _loop60:;
1066                  } // ( ... )*
1067 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 <                tmp65_AST = astFactory->create(LT(1));
1069 <                astFactory->addASTChild(currentAST, tmp65_AST);
1067 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 >                tmp69_AST = astFactory->create(LT(1));
1069 >                astFactory->addASTChild(currentAST, tmp69_AST);
1070                  match(RCURLY);
1071 < #line 149 "MDParser.g"
1072 <                tmp65_AST->setType(ENDBLOCK);
1073 < #line 1030 "MDParser.cpp"
1071 > #line 150 "MDParser.g"
1072 >                tmp69_AST->setType(ENDBLOCK);
1073 > #line 1074 "MDParser.cpp"
1074                  cutoffgroupblock_AST = currentAST.root;
1075          }
1076          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1042 | Line 1086 | void MDParser::fragmentblock() {
1086          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1087          
1088          try {      // for error handling
1089 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 <                tmp66_AST = astFactory->create(LT(1));
1091 <                astFactory->makeASTRoot(currentAST, tmp66_AST);
1089 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 >                tmp70_AST = astFactory->create(LT(1));
1091 >                astFactory->makeASTRoot(currentAST, tmp70_AST);
1092                  match(FRAGMENT);
1093                  match(LBRACKET);
1094                  intConst();
# Line 1064 | Line 1108 | void MDParser::fragmentblock() {
1108                  }
1109                  _loop64:;
1110                  } // ( ... )*
1111 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 <                tmp70_AST = astFactory->create(LT(1));
1113 <                astFactory->addASTChild(currentAST, tmp70_AST);
1111 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 >                tmp74_AST = astFactory->create(LT(1));
1113 >                astFactory->addASTChild(currentAST, tmp74_AST);
1114                  match(RCURLY);
1115 < #line 156 "MDParser.g"
1116 <                tmp70_AST->setType(ENDBLOCK);
1117 < #line 1074 "MDParser.cpp"
1115 > #line 157 "MDParser.g"
1116 >                tmp74_AST->setType(ENDBLOCK);
1117 > #line 1118 "MDParser.cpp"
1118                  fragmentblock_AST = currentAST.root;
1119          }
1120          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1096 | Line 1140 | void MDParser::atomstatement() {
1140                  }
1141                  case POSITION:
1142                  {
1143 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 <                        tmp71_AST = astFactory->create(LT(1));
1145 <                        astFactory->makeASTRoot(currentAST, tmp71_AST);
1143 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 >                        tmp75_AST = astFactory->create(LT(1));
1145 >                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1146                          match(POSITION);
1147                          match(LPAREN);
1148                          doubleNumberTuple();
# Line 1110 | Line 1154 | void MDParser::atomstatement() {
1154                  }
1155                  case ORIENTATION:
1156                  {
1157 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 <                        tmp75_AST = astFactory->create(LT(1));
1159 <                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1157 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 >                        tmp79_AST = astFactory->create(LT(1));
1159 >                        astFactory->makeASTRoot(currentAST, tmp79_AST);
1160                          match(ORIENTATION);
1161                          match(LPAREN);
1162                          doubleNumberTuple();
# Line 1182 | Line 1226 | void MDParser::bondstatement() {
1226                  }
1227                  case MEMBERS:
1228                  {
1229 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 <                        tmp80_AST = astFactory->create(LT(1));
1231 <                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1229 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 >                        tmp84_AST = astFactory->create(LT(1));
1231 >                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1232                          match(MEMBERS);
1233                          match(LPAREN);
1234                          inttuple();
# Line 1254 | Line 1298 | void MDParser::bendstatement() {
1298                  }
1299                  case MEMBERS:
1300                  {
1301 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 <                        tmp85_AST = astFactory->create(LT(1));
1303 <                        astFactory->makeASTRoot(currentAST, tmp85_AST);
1301 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 >                        tmp89_AST = astFactory->create(LT(1));
1303 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1304                          match(MEMBERS);
1305                          match(LPAREN);
1306                          inttuple();
# Line 1295 | Line 1339 | void MDParser::torsionstatement() {
1339                  }
1340                  case MEMBERS:
1341                  {
1342 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 <                        tmp89_AST = astFactory->create(LT(1));
1344 <                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1342 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 >                        tmp93_AST = astFactory->create(LT(1));
1344 >                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1345                          match(MEMBERS);
1346                          match(LPAREN);
1347                          inttuple();
# Line 1336 | Line 1380 | void MDParser::inversionstatement() {
1380                  }
1381                  case CENTER:
1382                  {
1383 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 <                        tmp93_AST = astFactory->create(LT(1));
1385 <                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1383 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 >                        tmp97_AST = astFactory->create(LT(1));
1385 >                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1386                          match(CENTER);
1387                          match(LPAREN);
1388                          intConst();
# Line 1377 | Line 1421 | void MDParser::rigidbodystatement() {
1421                  }
1422                  case MEMBERS:
1423                  {
1424 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1425 <                        tmp97_AST = astFactory->create(LT(1));
1426 <                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1424 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1425 >                        tmp101_AST = astFactory->create(LT(1));
1426 >                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1427                          match(MEMBERS);
1428                          match(LPAREN);
1429                          inttuple();
# Line 1418 | Line 1462 | void MDParser::cutoffgroupstatement() {
1462                  }
1463                  case MEMBERS:
1464                  {
1465 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1466 <                        tmp101_AST = astFactory->create(LT(1));
1467 <                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1465 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1466 >                        tmp105_AST = astFactory->create(LT(1));
1467 >                        astFactory->makeASTRoot(currentAST, tmp105_AST);
1468                          match(MEMBERS);
1469                          match(LPAREN);
1470                          inttuple();

Diff Legend

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