# | Line 1 | Line 1 | |
---|---|---|
1 | < | /* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */ |
1 | > | /* $ANTLR 2.7.4: "MDParser.g" -> "MDParser.cpp"$ */ |
2 | #include "MDParser.hpp" | |
3 | #include <antlr/NoViableAltException.hpp> | |
4 | #include <antlr/SemanticException.hpp> | |
# | Line 53 | Line 53 | void MDParser::mdfile() { | |
53 | } | |
54 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
55 | reportError(ex); | |
56 | < | recover(ex,_tokenSet_1); |
56 | > | consume(); |
57 | > | consumeUntil(_tokenSet_1); |
58 | } | |
59 | returnAST = mdfile_AST; | |
60 | } | |
# | Line 101 | Line 102 | void MDParser::statement() { | |
102 | } | |
103 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
104 | reportError(ex); | |
105 | < | recover(ex,_tokenSet_2); |
105 | > | consume(); |
106 | > | consumeUntil(_tokenSet_2); |
107 | } | |
108 | returnAST = statement_AST; | |
109 | } | |
# | Line 127 | Line 129 | void MDParser::assignment() { | |
129 | } | |
130 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
131 | reportError(ex); | |
132 | < | recover(ex,_tokenSet_3); |
132 | > | consume(); |
133 | > | consumeUntil(_tokenSet_3); |
134 | } | |
135 | returnAST = assignment_AST; | |
136 | } | |
# | Line 160 | Line 163 | void MDParser::componentblock() { | |
163 | tmp6_AST = astFactory->create(LT(1)); | |
164 | astFactory->addASTChild(currentAST, tmp6_AST); | |
165 | match(RCURLY); | |
166 | < | #line 63 "MDParser.g" |
166 | > | #line 65 "MDParser.g" |
167 | tmp6_AST->setType(ENDBLOCK); | |
168 | < | #line 166 "MDParser.cpp" |
168 | > | #line 169 "MDParser.cpp" |
169 | componentblock_AST = currentAST.root; | |
170 | } | |
171 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
172 | reportError(ex); | |
173 | < | recover(ex,_tokenSet_2); |
173 | > | consume(); |
174 | > | consumeUntil(_tokenSet_2); |
175 | } | |
176 | returnAST = componentblock_AST; | |
177 | } | |
# | Line 200 | Line 204 | void MDParser::moleculeblock() { | |
204 | tmp9_AST = astFactory->create(LT(1)); | |
205 | astFactory->addASTChild(currentAST, tmp9_AST); | |
206 | match(RCURLY); | |
207 | < | #line 69 "MDParser.g" |
207 | > | #line 71 "MDParser.g" |
208 | tmp9_AST->setType(ENDBLOCK); | |
209 | < | #line 206 "MDParser.cpp" |
209 | > | #line 210 "MDParser.cpp" |
210 | moleculeblock_AST = currentAST.root; | |
211 | } | |
212 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
213 | reportError(ex); | |
214 | < | recover(ex,_tokenSet_2); |
214 | > | consume(); |
215 | > | consumeUntil(_tokenSet_2); |
216 | } | |
217 | returnAST = moleculeblock_AST; | |
218 | } | |
# | Line 240 | Line 245 | void MDParser::zconstraintblock() { | |
245 | tmp12_AST = astFactory->create(LT(1)); | |
246 | astFactory->addASTChild(currentAST, tmp12_AST); | |
247 | match(RCURLY); | |
248 | < | #line 66 "MDParser.g" |
248 | > | #line 68 "MDParser.g" |
249 | tmp12_AST->setType(ENDBLOCK); | |
250 | < | #line 246 "MDParser.cpp" |
250 | > | #line 251 "MDParser.cpp" |
251 | zconstraintblock_AST = currentAST.root; | |
252 | } | |
253 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
254 | reportError(ex); | |
255 | < | recover(ex,_tokenSet_2); |
255 | > | consume(); |
256 | > | consumeUntil(_tokenSet_2); |
257 | } | |
258 | returnAST = zconstraintblock_AST; | |
259 | } | |
# | Line 301 | Line 307 | void MDParser::constant() { | |
307 | } | |
308 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
309 | reportError(ex); | |
310 | < | recover(ex,_tokenSet_5); |
310 | > | consume(); |
311 | > | consumeUntil(_tokenSet_5); |
312 | } | |
313 | returnAST = constant_AST; | |
314 | } | |
# | Line 339 | Line 346 | void MDParser::intConst() { | |
346 | } | |
347 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
348 | reportError(ex); | |
349 | < | recover(ex,_tokenSet_6); |
349 | > | consume(); |
350 | > | consumeUntil(_tokenSet_6); |
351 | } | |
352 | returnAST = intConst_AST; | |
353 | } | |
# | Line 377 | Line 385 | void MDParser::floatConst() { | |
385 | } | |
386 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
387 | reportError(ex); | |
388 | < | recover(ex,_tokenSet_7); |
388 | > | consume(); |
389 | > | consumeUntil(_tokenSet_7); |
390 | } | |
391 | returnAST = floatConst_AST; | |
392 | } | |
# | Line 453 | Line 462 | void MDParser::moleculestatement() { | |
462 | } | |
463 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
464 | reportError(ex); | |
465 | < | recover(ex,_tokenSet_8); |
465 | > | consume(); |
466 | > | consumeUntil(_tokenSet_8); |
467 | } | |
468 | returnAST = moleculestatement_AST; | |
469 | } | |
# | Line 490 | Line 500 | void MDParser::atomblock() { | |
500 | tmp23_AST = astFactory->create(LT(1)); | |
501 | astFactory->addASTChild(currentAST, tmp23_AST); | |
502 | match(RCURLY); | |
503 | < | #line 82 "MDParser.g" |
503 | > | #line 84 "MDParser.g" |
504 | tmp23_AST->setType(ENDBLOCK); | |
505 | < | #line 496 "MDParser.cpp" |
505 | > | #line 506 "MDParser.cpp" |
506 | atomblock_AST = currentAST.root; | |
507 | } | |
508 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
509 | reportError(ex); | |
510 | < | recover(ex,_tokenSet_8); |
510 | > | consume(); |
511 | > | consumeUntil(_tokenSet_8); |
512 | } | |
513 | returnAST = atomblock_AST; | |
514 | } | |
# | Line 549 | Line 560 | void MDParser::bondblock() { | |
560 | tmp28_AST = astFactory->create(LT(1)); | |
561 | astFactory->addASTChild(currentAST, tmp28_AST); | |
562 | match(RCURLY); | |
563 | < | #line 91 "MDParser.g" |
563 | > | #line 93 "MDParser.g" |
564 | tmp28_AST->setType(ENDBLOCK); | |
565 | < | #line 555 "MDParser.cpp" |
565 | > | #line 566 "MDParser.cpp" |
566 | bondblock_AST = currentAST.root; | |
567 | } | |
568 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
569 | reportError(ex); | |
570 | < | recover(ex,_tokenSet_8); |
570 | > | consume(); |
571 | > | consumeUntil(_tokenSet_8); |
572 | } | |
573 | returnAST = bondblock_AST; | |
574 | } | |
# | Line 608 | Line 620 | void MDParser::bendblock() { | |
620 | tmp33_AST = astFactory->create(LT(1)); | |
621 | astFactory->addASTChild(currentAST, tmp33_AST); | |
622 | match(RCURLY); | |
623 | < | #line 98 "MDParser.g" |
623 | > | #line 100 "MDParser.g" |
624 | tmp33_AST->setType(ENDBLOCK); | |
625 | < | #line 614 "MDParser.cpp" |
625 | > | #line 626 "MDParser.cpp" |
626 | bendblock_AST = currentAST.root; | |
627 | } | |
628 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
629 | reportError(ex); | |
630 | < | recover(ex,_tokenSet_8); |
630 | > | consume(); |
631 | > | consumeUntil(_tokenSet_8); |
632 | } | |
633 | returnAST = bendblock_AST; | |
634 | } | |
# | Line 667 | Line 680 | void MDParser::torsionblock() { | |
680 | tmp38_AST = astFactory->create(LT(1)); | |
681 | astFactory->addASTChild(currentAST, tmp38_AST); | |
682 | match(RCURLY); | |
683 | < | #line 105 "MDParser.g" |
683 | > | #line 107 "MDParser.g" |
684 | tmp38_AST->setType(ENDBLOCK); | |
685 | < | #line 673 "MDParser.cpp" |
685 | > | #line 686 "MDParser.cpp" |
686 | torsionblock_AST = currentAST.root; | |
687 | } | |
688 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
689 | reportError(ex); | |
690 | < | recover(ex,_tokenSet_8); |
690 | > | consume(); |
691 | > | consumeUntil(_tokenSet_8); |
692 | } | |
693 | returnAST = torsionblock_AST; | |
694 | } | |
# | Line 701 | Line 715 | void MDParser::rigidbodyblock() { | |
715 | astFactory->addASTChild( currentAST, returnAST ); | |
716 | } | |
717 | else { | |
718 | < | goto _loop38; |
718 | > | goto _loop43; |
719 | } | |
720 | ||
721 | } | |
722 | < | _loop38:; |
722 | > | _loop43:; |
723 | } // ( ... )* | |
724 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
725 | tmp43_AST = astFactory->create(LT(1)); | |
726 | astFactory->addASTChild(currentAST, tmp43_AST); | |
727 | match(RCURLY); | |
728 | < | #line 112 "MDParser.g" |
728 | > | #line 121 "MDParser.g" |
729 | tmp43_AST->setType(ENDBLOCK); | |
730 | < | #line 717 "MDParser.cpp" |
730 | > | #line 731 "MDParser.cpp" |
731 | rigidbodyblock_AST = currentAST.root; | |
732 | } | |
733 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
734 | reportError(ex); | |
735 | < | recover(ex,_tokenSet_8); |
735 | > | consume(); |
736 | > | consumeUntil(_tokenSet_8); |
737 | } | |
738 | returnAST = rigidbodyblock_AST; | |
739 | } | |
# | Line 760 | Line 775 | void MDParser::cutoffgroupblock() { | |
775 | astFactory->addASTChild( currentAST, returnAST ); | |
776 | } | |
777 | else { | |
778 | < | goto _loop43; |
778 | > | goto _loop48; |
779 | } | |
780 | ||
781 | } | |
782 | < | _loop43:; |
782 | > | _loop48:; |
783 | } // ( ... )* | |
784 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
785 | tmp48_AST = astFactory->create(LT(1)); | |
786 | astFactory->addASTChild(currentAST, tmp48_AST); | |
787 | match(RCURLY); | |
788 | < | #line 119 "MDParser.g" |
788 | > | #line 128 "MDParser.g" |
789 | tmp48_AST->setType(ENDBLOCK); | |
790 | < | #line 776 "MDParser.cpp" |
790 | > | #line 791 "MDParser.cpp" |
791 | cutoffgroupblock_AST = currentAST.root; | |
792 | } | |
793 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
794 | reportError(ex); | |
795 | < | recover(ex,_tokenSet_8); |
795 | > | consume(); |
796 | > | consumeUntil(_tokenSet_8); |
797 | } | |
798 | returnAST = cutoffgroupblock_AST; | |
799 | } | |
# | Line 804 | Line 820 | void MDParser::fragmentblock() { | |
820 | astFactory->addASTChild( currentAST, returnAST ); | |
821 | } | |
822 | else { | |
823 | < | goto _loop47; |
823 | > | goto _loop52; |
824 | } | |
825 | ||
826 | } | |
827 | < | _loop47:; |
827 | > | _loop52:; |
828 | } // ( ... )* | |
829 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
830 | tmp53_AST = astFactory->create(LT(1)); | |
831 | astFactory->addASTChild(currentAST, tmp53_AST); | |
832 | match(RCURLY); | |
833 | < | #line 126 "MDParser.g" |
833 | > | #line 135 "MDParser.g" |
834 | tmp53_AST->setType(ENDBLOCK); | |
835 | < | #line 820 "MDParser.cpp" |
835 | > | #line 836 "MDParser.cpp" |
836 | fragmentblock_AST = currentAST.root; | |
837 | } | |
838 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
839 | reportError(ex); | |
840 | < | recover(ex,_tokenSet_8); |
840 | > | consume(); |
841 | > | consumeUntil(_tokenSet_8); |
842 | } | |
843 | returnAST = fragmentblock_AST; | |
844 | } | |
# | Line 876 | Line 893 | void MDParser::atomstatement() { | |
893 | } | |
894 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
895 | reportError(ex); | |
896 | < | recover(ex,_tokenSet_10); |
896 | > | consume(); |
897 | > | consumeUntil(_tokenSet_10); |
898 | } | |
899 | returnAST = atomstatement_AST; | |
900 | } | |
# | Line 897 | Line 915 | void MDParser::doubleNumberTuple() { | |
915 | astFactory->addASTChild( currentAST, returnAST ); | |
916 | } | |
917 | else { | |
918 | < | goto _loop51; |
918 | > | goto _loop56; |
919 | } | |
920 | ||
921 | } | |
922 | < | _loop51:; |
922 | > | _loop56:; |
923 | } // ( ... )* | |
924 | doubleNumberTuple_AST = currentAST.root; | |
925 | } | |
926 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
927 | reportError(ex); | |
928 | < | recover(ex,_tokenSet_11); |
928 | > | consume(); |
929 | > | consumeUntil(_tokenSet_11); |
930 | } | |
931 | returnAST = doubleNumberTuple_AST; | |
932 | } | |
# | Line 948 | Line 967 | void MDParser::bondstatement() { | |
967 | } | |
968 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
969 | reportError(ex); | |
970 | < | recover(ex,_tokenSet_12); |
970 | > | consume(); |
971 | > | consumeUntil(_tokenSet_12); |
972 | } | |
973 | returnAST = bondstatement_AST; | |
974 | } | |
# | Line 969 | Line 989 | void MDParser::inttuple() { | |
989 | astFactory->addASTChild( currentAST, returnAST ); | |
990 | } | |
991 | else { | |
992 | < | goto _loop54; |
992 | > | goto _loop59; |
993 | } | |
994 | ||
995 | } | |
996 | < | _loop54:; |
996 | > | _loop59:; |
997 | } // ( ... )* | |
998 | inttuple_AST = currentAST.root; | |
999 | } | |
1000 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1001 | reportError(ex); | |
1002 | < | recover(ex,_tokenSet_11); |
1002 | > | consume(); |
1003 | > | consumeUntil(_tokenSet_11); |
1004 | } | |
1005 | returnAST = inttuple_AST; | |
1006 | } | |
# | Line 1020 | Line 1041 | void MDParser::bendstatement() { | |
1041 | } | |
1042 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1043 | reportError(ex); | |
1044 | < | recover(ex,_tokenSet_12); |
1044 | > | consume(); |
1045 | > | consumeUntil(_tokenSet_12); |
1046 | } | |
1047 | returnAST = bendstatement_AST; | |
1048 | } | |
# | Line 1061 | Line 1083 | void MDParser::torsionstatement() { | |
1083 | } | |
1084 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1085 | reportError(ex); | |
1086 | < | recover(ex,_tokenSet_12); |
1086 | > | consume(); |
1087 | > | consumeUntil(_tokenSet_12); |
1088 | } | |
1089 | returnAST = torsionstatement_AST; | |
1090 | + | } |
1091 | + | |
1092 | + | void MDParser::inversionblock() { |
1093 | + | returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1094 | + | ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1095 | + | ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1096 | + | |
1097 | + | try { // for error handling |
1098 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1099 | + | tmp76_AST = astFactory->create(LT(1)); |
1100 | + | astFactory->makeASTRoot(currentAST, tmp76_AST); |
1101 | + | match(INVERSION); |
1102 | + | { |
1103 | + | switch ( LA(1)) { |
1104 | + | case LBRACKET: |
1105 | + | { |
1106 | + | match(LBRACKET); |
1107 | + | intConst(); |
1108 | + | match(RBRACKET); |
1109 | + | break; |
1110 | + | } |
1111 | + | case LCURLY: |
1112 | + | { |
1113 | + | break; |
1114 | + | } |
1115 | + | default: |
1116 | + | { |
1117 | + | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1118 | + | } |
1119 | + | } |
1120 | + | } |
1121 | + | match(LCURLY); |
1122 | + | { // ( ... )* |
1123 | + | for (;;) { |
1124 | + | if ((LA(1) == CENTER || LA(1) == ID)) { |
1125 | + | inversionstatement(); |
1126 | + | astFactory->addASTChild( currentAST, returnAST ); |
1127 | + | } |
1128 | + | else { |
1129 | + | goto _loop39; |
1130 | + | } |
1131 | + | |
1132 | + | } |
1133 | + | _loop39:; |
1134 | + | } // ( ... )* |
1135 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1136 | + | tmp80_AST = astFactory->create(LT(1)); |
1137 | + | astFactory->addASTChild(currentAST, tmp80_AST); |
1138 | + | match(RCURLY); |
1139 | + | #line 114 "MDParser.g" |
1140 | + | tmp80_AST->setType(ENDBLOCK); |
1141 | + | #line 1142 "MDParser.cpp" |
1142 | + | inversionblock_AST = currentAST.root; |
1143 | + | } |
1144 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1145 | + | reportError(ex); |
1146 | + | consume(); |
1147 | + | consumeUntil(_tokenSet_1); |
1148 | + | } |
1149 | + | returnAST = inversionblock_AST; |
1150 | } | |
1151 | ||
1152 | + | void MDParser::inversionstatement() { |
1153 | + | returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1154 | + | ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1155 | + | ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1156 | + | |
1157 | + | try { // for error handling |
1158 | + | switch ( LA(1)) { |
1159 | + | case ID: |
1160 | + | { |
1161 | + | assignment(); |
1162 | + | astFactory->addASTChild( currentAST, returnAST ); |
1163 | + | inversionstatement_AST = currentAST.root; |
1164 | + | break; |
1165 | + | } |
1166 | + | case CENTER: |
1167 | + | { |
1168 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1169 | + | tmp81_AST = astFactory->create(LT(1)); |
1170 | + | astFactory->makeASTRoot(currentAST, tmp81_AST); |
1171 | + | match(CENTER); |
1172 | + | match(LPAREN); |
1173 | + | intConst(); |
1174 | + | astFactory->addASTChild( currentAST, returnAST ); |
1175 | + | match(RPAREN); |
1176 | + | match(SEMICOLON); |
1177 | + | inversionstatement_AST = currentAST.root; |
1178 | + | break; |
1179 | + | } |
1180 | + | default: |
1181 | + | { |
1182 | + | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1183 | + | } |
1184 | + | } |
1185 | + | } |
1186 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1187 | + | reportError(ex); |
1188 | + | consume(); |
1189 | + | consumeUntil(_tokenSet_13); |
1190 | + | } |
1191 | + | returnAST = inversionstatement_AST; |
1192 | + | } |
1193 | + | |
1194 | void MDParser::rigidbodystatement() { | |
1195 | returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
1196 | ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; | |
# | Line 1082 | Line 1207 | void MDParser::rigidbodystatement() { | |
1207 | } | |
1208 | case MEMBERS: | |
1209 | { | |
1210 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1211 | < | tmp76_AST = astFactory->create(LT(1)); |
1212 | < | astFactory->makeASTRoot(currentAST, tmp76_AST); |
1210 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1211 | > | tmp85_AST = astFactory->create(LT(1)); |
1212 | > | astFactory->makeASTRoot(currentAST, tmp85_AST); |
1213 | match(MEMBERS); | |
1214 | match(LPAREN); | |
1215 | inttuple(); | |
# | Line 1102 | Line 1227 | void MDParser::rigidbodystatement() { | |
1227 | } | |
1228 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1229 | reportError(ex); | |
1230 | < | recover(ex,_tokenSet_12); |
1230 | > | consume(); |
1231 | > | consumeUntil(_tokenSet_12); |
1232 | } | |
1233 | returnAST = rigidbodystatement_AST; | |
1234 | } | |
# | Line 1123 | Line 1249 | void MDParser::cutoffgroupstatement() { | |
1249 | } | |
1250 | case MEMBERS: | |
1251 | { | |
1252 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1253 | < | tmp80_AST = astFactory->create(LT(1)); |
1254 | < | astFactory->makeASTRoot(currentAST, tmp80_AST); |
1252 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1253 | > | tmp89_AST = astFactory->create(LT(1)); |
1254 | > | astFactory->makeASTRoot(currentAST, tmp89_AST); |
1255 | match(MEMBERS); | |
1256 | match(LPAREN); | |
1257 | inttuple(); | |
# | Line 1143 | Line 1269 | void MDParser::cutoffgroupstatement() { | |
1269 | } | |
1270 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1271 | reportError(ex); | |
1272 | < | recover(ex,_tokenSet_12); |
1272 | > | consume(); |
1273 | > | consumeUntil(_tokenSet_12); |
1274 | } | |
1275 | returnAST = cutoffgroupstatement_AST; | |
1276 | } | |
# | Line 1160 | Line 1287 | void MDParser::fragmentstatement() { | |
1287 | } | |
1288 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1289 | reportError(ex); | |
1290 | < | recover(ex,_tokenSet_13); |
1290 | > | consume(); |
1291 | > | consumeUntil(_tokenSet_14); |
1292 | } | |
1293 | returnAST = fragmentstatement_AST; | |
1294 | } | |
# | Line 1197 | Line 1325 | void MDParser::doubleNumber() { | |
1325 | } | |
1326 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1327 | reportError(ex); | |
1328 | < | recover(ex,_tokenSet_14); |
1328 | > | consume(); |
1329 | > | consumeUntil(_tokenSet_15); |
1330 | } | |
1331 | returnAST = doubleNumber_AST; | |
1332 | } | |
1333 | ||
1334 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) | |
1335 | { | |
1336 | < | factory.setMaxNodeType(50); |
1336 | > | factory.setMaxNodeType(52); |
1337 | } | |
1338 | const char* MDParser::tokenNames[] = { | |
1339 | "<0>", | |
# | Line 1218 | Line 1347 | const char* MDParser::tokenNames[] = { | |
1347 | "\"bond\"", | |
1348 | "\"bend\"", | |
1349 | "\"torsion\"", | |
1350 | + | "\"inversion\"", |
1351 | "\"rigidBody\"", | |
1352 | "\"cutoffGroup\"", | |
1353 | "\"fragment\"", | |
1354 | "\"members\"", | |
1355 | + | "\"center\"", |
1356 | "\"position\"", | |
1357 | "\"orientation\"", | |
1358 | "ENDBLOCK", | |
# | Line 1261 | Line 1392 | const char* MDParser::tokenNames[] = { | |
1392 | 0 | |
1393 | }; | |
1394 | ||
1395 | < | const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL }; |
1395 | > | const unsigned long MDParser::_tokenSet_0_data_[] = { 1048688UL, 0UL, 0UL, 0UL }; |
1396 | // "component" "molecule" "zconstraint" ID | |
1397 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4); | |
1398 | const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL }; | |
1399 | // EOF | |
1400 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4); | |
1401 | < | const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL }; |
1401 | > | const unsigned long MDParser::_tokenSet_2_data_[] = { 1048690UL, 0UL, 0UL, 0UL }; |
1402 | // EOF "component" "molecule" "zconstraint" ID | |
1403 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4); | |
1404 | < | const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL }; |
1404 | > | const unsigned long MDParser::_tokenSet_3_data_[] = { 35125234UL, 0UL, 0UL, 0UL }; |
1405 | // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion" | |
1406 | < | // "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation" |
1406 | > | // "rigidBody" "cutoffGroup" "fragment" "members" "center" "position" "orientation" |
1407 | // ID RCURLY | |
1408 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4); | |
1409 | < | const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL }; |
1409 | > | const unsigned long MDParser::_tokenSet_4_data_[] = { 1079168UL, 0UL, 0UL, 0UL }; |
1410 | // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" | |
1411 | // ID | |
1412 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4); | |
1413 | < | const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL }; |
1413 | > | const unsigned long MDParser::_tokenSet_5_data_[] = { 4194304UL, 0UL, 0UL, 0UL }; |
1414 | // SEMICOLON | |
1415 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4); | |
1416 | < | const unsigned long MDParser::_tokenSet_6_data_[] = { 437256192UL, 0UL, 0UL, 0UL }; |
1416 | > | const unsigned long MDParser::_tokenSet_6_data_[] = { 1749024768UL, 0UL, 0UL, 0UL }; |
1417 | // SEMICOLON RBRACKET RPAREN COMMA | |
1418 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4); | |
1419 | < | const unsigned long MDParser::_tokenSet_7_data_[] = { 403701760UL, 0UL, 0UL, 0UL }; |
1419 | > | const unsigned long MDParser::_tokenSet_7_data_[] = { 1614807040UL, 0UL, 0UL, 0UL }; |
1420 | // SEMICOLON RPAREN COMMA | |
1421 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4); | |
1422 | < | const unsigned long MDParser::_tokenSet_8_data_[] = { 8667008UL, 0UL, 0UL, 0UL }; |
1422 | > | const unsigned long MDParser::_tokenSet_8_data_[] = { 34633600UL, 0UL, 0UL, 0UL }; |
1423 | // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" | |
1424 | // ID RCURLY | |
1425 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4); | |
1426 | < | const unsigned long MDParser::_tokenSet_9_data_[] = { 360448UL, 0UL, 0UL, 0UL }; |
1426 | > | const unsigned long MDParser::_tokenSet_9_data_[] = { 1441792UL, 0UL, 0UL, 0UL }; |
1427 | // "position" "orientation" ID | |
1428 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4); | |
1429 | < | const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL }; |
1429 | > | const unsigned long MDParser::_tokenSet_10_data_[] = { 34996224UL, 0UL, 0UL, 0UL }; |
1430 | // "position" "orientation" ID RCURLY | |
1431 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4); | |
1432 | < | const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL }; |
1432 | > | const unsigned long MDParser::_tokenSet_11_data_[] = { 536870912UL, 0UL, 0UL, 0UL }; |
1433 | // RPAREN | |
1434 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4); | |
1435 | < | const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL }; |
1435 | > | const unsigned long MDParser::_tokenSet_12_data_[] = { 34635776UL, 0UL, 0UL, 0UL }; |
1436 | // "members" ID RCURLY | |
1437 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4); | |
1438 | < | const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL }; |
1439 | < | // ID RCURLY |
1438 | > | const unsigned long MDParser::_tokenSet_13_data_[] = { 34668544UL, 0UL, 0UL, 0UL }; |
1439 | > | // "center" ID RCURLY |
1440 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4); | |
1441 | < | const unsigned long MDParser::_tokenSet_14_data_[] = { 402653184UL, 0UL, 0UL, 0UL }; |
1442 | < | // RPAREN COMMA |
1441 | > | const unsigned long MDParser::_tokenSet_14_data_[] = { 34603008UL, 0UL, 0UL, 0UL }; |
1442 | > | // ID RCURLY |
1443 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4); | |
1444 | + | const unsigned long MDParser::_tokenSet_15_data_[] = { 1610612736UL, 0UL, 0UL, 0UL }; |
1445 | + | // RPAREN COMMA |
1446 | + | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4); |
1447 | ||
1448 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |