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

Comparing trunk/src/mdParser/MDParser.cpp (file contents):
Revision 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20080702): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 160 | Line 160 | void MDParser::componentblock() {
160                  tmp6_AST = astFactory->create(LT(1));
161                  astFactory->addASTChild(currentAST, tmp6_AST);
162                  match(RCURLY);
163 < #line 63 "MDParser.g"
163 > #line 65 "MDParser.g"
164                  tmp6_AST->setType(ENDBLOCK);
165   #line 166 "MDParser.cpp"
166                  componentblock_AST = currentAST.root;
# Line 200 | Line 200 | void MDParser::moleculeblock() {
200                  tmp9_AST = astFactory->create(LT(1));
201                  astFactory->addASTChild(currentAST, tmp9_AST);
202                  match(RCURLY);
203 < #line 69 "MDParser.g"
203 > #line 71 "MDParser.g"
204                  tmp9_AST->setType(ENDBLOCK);
205   #line 206 "MDParser.cpp"
206                  moleculeblock_AST = currentAST.root;
# Line 240 | Line 240 | void MDParser::zconstraintblock() {
240                  tmp12_AST = astFactory->create(LT(1));
241                  astFactory->addASTChild(currentAST, tmp12_AST);
242                  match(RCURLY);
243 < #line 66 "MDParser.g"
243 > #line 68 "MDParser.g"
244                  tmp12_AST->setType(ENDBLOCK);
245   #line 246 "MDParser.cpp"
246                  zconstraintblock_AST = currentAST.root;
# Line 424 | Line 424 | void MDParser::moleculestatement() {
424                          moleculestatement_AST = currentAST.root;
425                          break;
426                  }
427 +                case INVERSION:
428 +                {
429 +                        inversionblock();
430 +                        astFactory->addASTChild( currentAST, returnAST );
431 +                        moleculestatement_AST = currentAST.root;
432 +                        break;
433 +                }
434                  case RIGIDBODY:
435                  {
436                          rigidbodyblock();
# Line 490 | Line 497 | void MDParser::atomblock() {
497                  tmp23_AST = astFactory->create(LT(1));
498                  astFactory->addASTChild(currentAST, tmp23_AST);
499                  match(RCURLY);
500 < #line 82 "MDParser.g"
500 > #line 85 "MDParser.g"
501                  tmp23_AST->setType(ENDBLOCK);
502 < #line 496 "MDParser.cpp"
502 > #line 503 "MDParser.cpp"
503                  atomblock_AST = currentAST.root;
504          }
505          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 549 | Line 556 | void MDParser::bondblock() {
556                  tmp28_AST = astFactory->create(LT(1));
557                  astFactory->addASTChild(currentAST, tmp28_AST);
558                  match(RCURLY);
559 < #line 91 "MDParser.g"
559 > #line 94 "MDParser.g"
560                  tmp28_AST->setType(ENDBLOCK);
561 < #line 555 "MDParser.cpp"
561 > #line 562 "MDParser.cpp"
562                  bondblock_AST = currentAST.root;
563          }
564          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 608 | Line 615 | void MDParser::bendblock() {
615                  tmp33_AST = astFactory->create(LT(1));
616                  astFactory->addASTChild(currentAST, tmp33_AST);
617                  match(RCURLY);
618 < #line 98 "MDParser.g"
618 > #line 101 "MDParser.g"
619                  tmp33_AST->setType(ENDBLOCK);
620 < #line 614 "MDParser.cpp"
620 > #line 621 "MDParser.cpp"
621                  bendblock_AST = currentAST.root;
622          }
623          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 667 | Line 674 | void MDParser::torsionblock() {
674                  tmp38_AST = astFactory->create(LT(1));
675                  astFactory->addASTChild(currentAST, tmp38_AST);
676                  match(RCURLY);
677 < #line 105 "MDParser.g"
677 > #line 108 "MDParser.g"
678                  tmp38_AST->setType(ENDBLOCK);
679 < #line 673 "MDParser.cpp"
679 > #line 680 "MDParser.cpp"
680                  torsionblock_AST = currentAST.root;
681          }
682          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 679 | Line 686 | void MDParser::torsionblock() {
686          returnAST = torsionblock_AST;
687   }
688  
689 < void MDParser::rigidbodyblock() {
689 > void MDParser::inversionblock() {
690          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
691          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
692 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
692 >        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
693          
694          try {      // for error handling
695                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
696                  tmp39_AST = astFactory->create(LT(1));
697                  astFactory->makeASTRoot(currentAST, tmp39_AST);
698 +                match(INVERSION);
699 +                {
700 +                switch ( LA(1)) {
701 +                case LBRACKET:
702 +                {
703 +                        match(LBRACKET);
704 +                        intConst();
705 +                        match(RBRACKET);
706 +                        break;
707 +                }
708 +                case LCURLY:
709 +                {
710 +                        break;
711 +                }
712 +                default:
713 +                {
714 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
715 +                }
716 +                }
717 +                }
718 +                match(LCURLY);
719 +                { // ( ... )*
720 +                for (;;) {
721 +                        if ((LA(1) == CENTER || LA(1) == ID)) {
722 +                                inversionstatement();
723 +                                astFactory->addASTChild( currentAST, returnAST );
724 +                        }
725 +                        else {
726 +                                goto _loop39;
727 +                        }
728 +                        
729 +                }
730 +                _loop39:;
731 +                } // ( ... )*
732 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
733 +                tmp43_AST = astFactory->create(LT(1));
734 +                astFactory->addASTChild(currentAST, tmp43_AST);
735 +                match(RCURLY);
736 + #line 115 "MDParser.g"
737 +                tmp43_AST->setType(ENDBLOCK);
738 + #line 739 "MDParser.cpp"
739 +                inversionblock_AST = currentAST.root;
740 +        }
741 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
742 +                reportError(ex);
743 +                recover(ex,_tokenSet_8);
744 +        }
745 +        returnAST = inversionblock_AST;
746 + }
747 +
748 + void MDParser::rigidbodyblock() {
749 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
750 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
751 +        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
752 +        
753 +        try {      // for error handling
754 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755 +                tmp44_AST = astFactory->create(LT(1));
756 +                astFactory->makeASTRoot(currentAST, tmp44_AST);
757                  match(RIGIDBODY);
758                  match(LBRACKET);
759                  intConst();
# Line 701 | Line 767 | void MDParser::rigidbodyblock() {
767                                  astFactory->addASTChild( currentAST, returnAST );
768                          }
769                          else {
770 <                                goto _loop38;
770 >                                goto _loop43;
771                          }
772                          
773                  }
774 <                _loop38:;
774 >                _loop43:;
775                  } // ( ... )*
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 <                tmp43_AST = astFactory->create(LT(1));
778 <                astFactory->addASTChild(currentAST, tmp43_AST);
776 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 >                tmp48_AST = astFactory->create(LT(1));
778 >                astFactory->addASTChild(currentAST, tmp48_AST);
779                  match(RCURLY);
780 < #line 112 "MDParser.g"
781 <                tmp43_AST->setType(ENDBLOCK);
782 < #line 717 "MDParser.cpp"
780 > #line 122 "MDParser.g"
781 >                tmp48_AST->setType(ENDBLOCK);
782 > #line 783 "MDParser.cpp"
783                  rigidbodyblock_AST = currentAST.root;
784          }
785          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 729 | Line 795 | void MDParser::cutoffgroupblock() {
795          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
796          
797          try {      // for error handling
798 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 <                tmp44_AST = astFactory->create(LT(1));
800 <                astFactory->makeASTRoot(currentAST, tmp44_AST);
798 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 >                tmp49_AST = astFactory->create(LT(1));
800 >                astFactory->makeASTRoot(currentAST, tmp49_AST);
801                  match(CUTOFFGROUP);
802                  {
803                  switch ( LA(1)) {
# Line 760 | Line 826 | void MDParser::cutoffgroupblock() {
826                                  astFactory->addASTChild( currentAST, returnAST );
827                          }
828                          else {
829 <                                goto _loop43;
829 >                                goto _loop48;
830                          }
831                          
832                  }
833 <                _loop43:;
833 >                _loop48:;
834                  } // ( ... )*
835 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 <                tmp48_AST = astFactory->create(LT(1));
837 <                astFactory->addASTChild(currentAST, tmp48_AST);
835 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 >                tmp53_AST = astFactory->create(LT(1));
837 >                astFactory->addASTChild(currentAST, tmp53_AST);
838                  match(RCURLY);
839 < #line 119 "MDParser.g"
840 <                tmp48_AST->setType(ENDBLOCK);
841 < #line 776 "MDParser.cpp"
839 > #line 129 "MDParser.g"
840 >                tmp53_AST->setType(ENDBLOCK);
841 > #line 842 "MDParser.cpp"
842                  cutoffgroupblock_AST = currentAST.root;
843          }
844          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 788 | Line 854 | void MDParser::fragmentblock() {
854          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
855          
856          try {      // for error handling
857 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 <                tmp49_AST = astFactory->create(LT(1));
859 <                astFactory->makeASTRoot(currentAST, tmp49_AST);
857 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 >                tmp54_AST = astFactory->create(LT(1));
859 >                astFactory->makeASTRoot(currentAST, tmp54_AST);
860                  match(FRAGMENT);
861                  match(LBRACKET);
862                  intConst();
# Line 804 | Line 870 | void MDParser::fragmentblock() {
870                                  astFactory->addASTChild( currentAST, returnAST );
871                          }
872                          else {
873 <                                goto _loop47;
873 >                                goto _loop52;
874                          }
875                          
876                  }
877 <                _loop47:;
877 >                _loop52:;
878                  } // ( ... )*
879 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 <                tmp53_AST = astFactory->create(LT(1));
881 <                astFactory->addASTChild(currentAST, tmp53_AST);
879 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 >                tmp58_AST = astFactory->create(LT(1));
881 >                astFactory->addASTChild(currentAST, tmp58_AST);
882                  match(RCURLY);
883 < #line 126 "MDParser.g"
884 <                tmp53_AST->setType(ENDBLOCK);
885 < #line 820 "MDParser.cpp"
883 > #line 136 "MDParser.g"
884 >                tmp58_AST->setType(ENDBLOCK);
885 > #line 886 "MDParser.cpp"
886                  fragmentblock_AST = currentAST.root;
887          }
888          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 842 | Line 908 | void MDParser::atomstatement() {
908                  }
909                  case POSITION:
910                  {
911 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 <                        tmp54_AST = astFactory->create(LT(1));
913 <                        astFactory->makeASTRoot(currentAST, tmp54_AST);
911 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 >                        tmp59_AST = astFactory->create(LT(1));
913 >                        astFactory->makeASTRoot(currentAST, tmp59_AST);
914                          match(POSITION);
915                          match(LPAREN);
916                          doubleNumberTuple();
# Line 856 | Line 922 | void MDParser::atomstatement() {
922                  }
923                  case ORIENTATION:
924                  {
925 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 <                        tmp58_AST = astFactory->create(LT(1));
927 <                        astFactory->makeASTRoot(currentAST, tmp58_AST);
925 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 >                        tmp63_AST = astFactory->create(LT(1));
927 >                        astFactory->makeASTRoot(currentAST, tmp63_AST);
928                          match(ORIENTATION);
929                          match(LPAREN);
930                          doubleNumberTuple();
# Line 897 | Line 963 | void MDParser::doubleNumberTuple() {
963                                  astFactory->addASTChild( currentAST, returnAST );
964                          }
965                          else {
966 <                                goto _loop51;
966 >                                goto _loop56;
967                          }
968                          
969                  }
970 <                _loop51:;
970 >                _loop56:;
971                  } // ( ... )*
972                  doubleNumberTuple_AST = currentAST.root;
973          }
# Line 928 | Line 994 | void MDParser::bondstatement() {
994                  }
995                  case MEMBERS:
996                  {
997 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 <                        tmp63_AST = astFactory->create(LT(1));
999 <                        astFactory->makeASTRoot(currentAST, tmp63_AST);
997 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 >                        tmp68_AST = astFactory->create(LT(1));
999 >                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1000                          match(MEMBERS);
1001                          match(LPAREN);
1002                          inttuple();
# Line 969 | Line 1035 | void MDParser::inttuple() {
1035                                  astFactory->addASTChild( currentAST, returnAST );
1036                          }
1037                          else {
1038 <                                goto _loop54;
1038 >                                goto _loop59;
1039                          }
1040                          
1041                  }
1042 <                _loop54:;
1042 >                _loop59:;
1043                  } // ( ... )*
1044                  inttuple_AST = currentAST.root;
1045          }
# Line 1000 | Line 1066 | void MDParser::bendstatement() {
1066                  }
1067                  case MEMBERS:
1068                  {
1069 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 <                        tmp68_AST = astFactory->create(LT(1));
1071 <                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1069 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 >                        tmp73_AST = astFactory->create(LT(1));
1071 >                        astFactory->makeASTRoot(currentAST, tmp73_AST);
1072                          match(MEMBERS);
1073                          match(LPAREN);
1074                          inttuple();
# Line 1041 | Line 1107 | void MDParser::torsionstatement() {
1107                  }
1108                  case MEMBERS:
1109                  {
1110 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 <                        tmp72_AST = astFactory->create(LT(1));
1112 <                        astFactory->makeASTRoot(currentAST, tmp72_AST);
1110 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 >                        tmp77_AST = astFactory->create(LT(1));
1112 >                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1113                          match(MEMBERS);
1114                          match(LPAREN);
1115                          inttuple();
# Line 1066 | Line 1132 | void MDParser::torsionstatement() {
1132          returnAST = torsionstatement_AST;
1133   }
1134  
1135 + void MDParser::inversionstatement() {
1136 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1137 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1138 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1139 +        
1140 +        try {      // for error handling
1141 +                switch ( LA(1)) {
1142 +                case ID:
1143 +                {
1144 +                        assignment();
1145 +                        astFactory->addASTChild( currentAST, returnAST );
1146 +                        inversionstatement_AST = currentAST.root;
1147 +                        break;
1148 +                }
1149 +                case CENTER:
1150 +                {
1151 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1152 +                        tmp81_AST = astFactory->create(LT(1));
1153 +                        astFactory->makeASTRoot(currentAST, tmp81_AST);
1154 +                        match(CENTER);
1155 +                        match(LPAREN);
1156 +                        intConst();
1157 +                        astFactory->addASTChild( currentAST, returnAST );
1158 +                        match(RPAREN);
1159 +                        match(SEMICOLON);
1160 +                        inversionstatement_AST = currentAST.root;
1161 +                        break;
1162 +                }
1163 +                default:
1164 +                {
1165 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1166 +                }
1167 +                }
1168 +        }
1169 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1170 +                reportError(ex);
1171 +                recover(ex,_tokenSet_13);
1172 +        }
1173 +        returnAST = inversionstatement_AST;
1174 + }
1175 +
1176   void MDParser::rigidbodystatement() {
1177          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1178          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 1082 | Line 1189 | void MDParser::rigidbodystatement() {
1189                  }
1190                  case MEMBERS:
1191                  {
1192 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1193 <                        tmp76_AST = astFactory->create(LT(1));
1194 <                        astFactory->makeASTRoot(currentAST, tmp76_AST);
1192 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1193 >                        tmp85_AST = astFactory->create(LT(1));
1194 >                        astFactory->makeASTRoot(currentAST, tmp85_AST);
1195                          match(MEMBERS);
1196                          match(LPAREN);
1197                          inttuple();
# Line 1123 | Line 1230 | void MDParser::cutoffgroupstatement() {
1230                  }
1231                  case MEMBERS:
1232                  {
1233 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1234 <                        tmp80_AST = astFactory->create(LT(1));
1235 <                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1233 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1234 >                        tmp89_AST = astFactory->create(LT(1));
1235 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1236                          match(MEMBERS);
1237                          match(LPAREN);
1238                          inttuple();
# Line 1160 | Line 1267 | void MDParser::fragmentstatement() {
1267          }
1268          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1269                  reportError(ex);
1270 <                recover(ex,_tokenSet_13);
1270 >                recover(ex,_tokenSet_14);
1271          }
1272          returnAST = fragmentstatement_AST;
1273   }
# Line 1197 | Line 1304 | void MDParser::doubleNumber() {
1304          }
1305          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1306                  reportError(ex);
1307 <                recover(ex,_tokenSet_14);
1307 >                recover(ex,_tokenSet_15);
1308          }
1309          returnAST = doubleNumber_AST;
1310   }
1311  
1312   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1313   {
1314 <        factory.setMaxNodeType(50);
1314 >        factory.setMaxNodeType(52);
1315   }
1316   const char* MDParser::tokenNames[] = {
1317          "<0>",
# Line 1218 | Line 1325 | const char* MDParser::tokenNames[] = {
1325          "\"bond\"",
1326          "\"bend\"",
1327          "\"torsion\"",
1328 +        "\"inversion\"",
1329          "\"rigidBody\"",
1330          "\"cutoffGroup\"",
1331          "\"fragment\"",
1332          "\"members\"",
1333 +        "\"center\"",
1334          "\"position\"",
1335          "\"orientation\"",
1336          "ENDBLOCK",
# Line 1261 | Line 1370 | const char* MDParser::tokenNames[] = {
1370          0
1371   };
1372  
1373 < const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL };
1373 > const unsigned long MDParser::_tokenSet_0_data_[] = { 1048688UL, 0UL, 0UL, 0UL };
1374   // "component" "molecule" "zconstraint" ID
1375   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1376   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1377   // EOF
1378   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1379 < const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL };
1379 > const unsigned long MDParser::_tokenSet_2_data_[] = { 1048690UL, 0UL, 0UL, 0UL };
1380   // EOF "component" "molecule" "zconstraint" ID
1381   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1382 < const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL };
1382 > const unsigned long MDParser::_tokenSet_3_data_[] = { 35127282UL, 0UL, 0UL, 0UL };
1383   // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion"
1384 < // "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation"
1385 < // ID RCURLY
1384 > // "inversion" "rigidBody" "cutoffGroup" "fragment" "members" "center"
1385 > // "position" "orientation" ID RCURLY
1386   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1387 < const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL };
1388 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1389 < // ID
1387 > const unsigned long MDParser::_tokenSet_4_data_[] = { 1081216UL, 0UL, 0UL, 0UL };
1388 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1389 > // "fragment" ID
1390   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1391 < const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL };
1391 > const unsigned long MDParser::_tokenSet_5_data_[] = { 4194304UL, 0UL, 0UL, 0UL };
1392   // SEMICOLON
1393   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1394 < const unsigned long MDParser::_tokenSet_6_data_[] = { 437256192UL, 0UL, 0UL, 0UL };
1394 > const unsigned long MDParser::_tokenSet_6_data_[] = { 1749024768UL, 0UL, 0UL, 0UL };
1395   // SEMICOLON RBRACKET RPAREN COMMA
1396   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1397 < const unsigned long MDParser::_tokenSet_7_data_[] = { 403701760UL, 0UL, 0UL, 0UL };
1397 > const unsigned long MDParser::_tokenSet_7_data_[] = { 1614807040UL, 0UL, 0UL, 0UL };
1398   // SEMICOLON RPAREN COMMA
1399   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1400 < const unsigned long MDParser::_tokenSet_8_data_[] = { 8667008UL, 0UL, 0UL, 0UL };
1401 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1402 < // ID RCURLY
1400 > const unsigned long MDParser::_tokenSet_8_data_[] = { 34635648UL, 0UL, 0UL, 0UL };
1401 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1402 > // "fragment" ID RCURLY
1403   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1404 < const unsigned long MDParser::_tokenSet_9_data_[] = { 360448UL, 0UL, 0UL, 0UL };
1404 > const unsigned long MDParser::_tokenSet_9_data_[] = { 1441792UL, 0UL, 0UL, 0UL };
1405   // "position" "orientation" ID
1406   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1407 < const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL };
1407 > const unsigned long MDParser::_tokenSet_10_data_[] = { 34996224UL, 0UL, 0UL, 0UL };
1408   // "position" "orientation" ID RCURLY
1409   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1410 < const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL };
1410 > const unsigned long MDParser::_tokenSet_11_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1411   // RPAREN
1412   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1413 < const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL };
1413 > const unsigned long MDParser::_tokenSet_12_data_[] = { 34635776UL, 0UL, 0UL, 0UL };
1414   // "members" ID RCURLY
1415   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1416 < const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL };
1417 < // ID RCURLY
1416 > const unsigned long MDParser::_tokenSet_13_data_[] = { 34668544UL, 0UL, 0UL, 0UL };
1417 > // "center" ID RCURLY
1418   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1419 < const unsigned long MDParser::_tokenSet_14_data_[] = { 402653184UL, 0UL, 0UL, 0UL };
1420 < // RPAREN COMMA
1419 > const unsigned long MDParser::_tokenSet_14_data_[] = { 34603008UL, 0UL, 0UL, 0UL };
1420 > // ID RCURLY
1421   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1422 + const unsigned long MDParser::_tokenSet_15_data_[] = { 1610612736UL, 0UL, 0UL, 0UL };
1423 + // RPAREN COMMA
1424 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1425  
1426  

Diff Legend

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