3#include <antlr/NoViableAltException.hpp>
4#include <antlr/SemanticException.hpp>
5#include <antlr/ASTFactory.hpp>
8MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf,
int k)
9: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
13MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
14: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
18MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer,
int k)
19: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
23MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
24: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
28MDParser::MDParser(
const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
29: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
33void MDParser::mdfile() {
34 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
35 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
36 ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
41 if ((_tokenSet_0.member(LA(1)))) {
43 astFactory->addASTChild( currentAST, returnAST );
52 mdfile_AST = currentAST.root;
54 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
56 recover(ex,_tokenSet_1);
58 returnAST = mdfile_AST;
61void MDParser::statement() {
62 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
63 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
64 ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
71 astFactory->addASTChild( currentAST, returnAST );
72 statement_AST = currentAST.root;
78 astFactory->addASTChild( currentAST, returnAST );
79 statement_AST = currentAST.root;
85 astFactory->addASTChild( currentAST, returnAST );
86 statement_AST = currentAST.root;
92 astFactory->addASTChild( currentAST, returnAST );
93 statement_AST = currentAST.root;
99 astFactory->addASTChild( currentAST, returnAST );
100 statement_AST = currentAST.root;
106 astFactory->addASTChild( currentAST, returnAST );
107 statement_AST = currentAST.root;
113 astFactory->addASTChild( currentAST, returnAST );
114 statement_AST = currentAST.root;
120 astFactory->addASTChild( currentAST, returnAST );
121 statement_AST = currentAST.root;
127 astFactory->addASTChild( currentAST, returnAST );
128 statement_AST = currentAST.root;
133 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
137 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
139 recover(ex,_tokenSet_2);
141 returnAST = statement_AST;
144void MDParser::assignment() {
145 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
146 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
147 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
150 ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
151 tmp1_AST = astFactory->create(LT(1));
152 astFactory->addASTChild(currentAST, tmp1_AST);
154 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
155 tmp2_AST = astFactory->create(LT(1));
156 astFactory->makeASTRoot(currentAST, tmp2_AST);
159 astFactory->addASTChild( currentAST, returnAST );
161 assignment_AST = currentAST.root;
163 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
165 recover(ex,_tokenSet_3);
167 returnAST = assignment_AST;
170void MDParser::componentblock() {
171 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
172 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
173 ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
176 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
177 tmp4_AST = astFactory->create(LT(1));
178 astFactory->makeASTRoot(currentAST, tmp4_AST);
185 astFactory->addASTChild( currentAST, returnAST );
194 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
195 tmp6_AST = astFactory->create(LT(1));
196 astFactory->addASTChild(currentAST, tmp6_AST);
199 tmp6_AST->setType(ENDBLOCK);
200#line 201 "MDParser.cpp"
201 componentblock_AST = currentAST.root;
203 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
205 recover(ex,_tokenSet_2);
207 returnAST = componentblock_AST;
210void MDParser::moleculeblock() {
211 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
212 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
213 ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
216 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
217 tmp7_AST = astFactory->create(LT(1));
218 astFactory->makeASTRoot(currentAST, tmp7_AST);
223 if ((_tokenSet_4.member(LA(1)))) {
225 astFactory->addASTChild( currentAST, returnAST );
234 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
235 tmp9_AST = astFactory->create(LT(1));
236 astFactory->addASTChild(currentAST, tmp9_AST);
238#line 116 "MDParser.g"
239 tmp9_AST->setType(ENDBLOCK);
240#line 241 "MDParser.cpp"
241 moleculeblock_AST = currentAST.root;
243 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
245 recover(ex,_tokenSet_2);
247 returnAST = moleculeblock_AST;
250void MDParser::fragmentblock() {
251 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
252 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
253 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
256 ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
257 tmp10_AST = astFactory->create(LT(1));
258 astFactory->makeASTRoot(currentAST, tmp10_AST);
263 if ((_tokenSet_5.member(LA(1)))) {
265 astFactory->addASTChild( currentAST, returnAST );
274 ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
275 tmp12_AST = astFactory->create(LT(1));
276 astFactory->addASTChild(currentAST, tmp12_AST);
278#line 217 "MDParser.g"
279 tmp12_AST->setType(ENDBLOCK);
280#line 281 "MDParser.cpp"
281 fragmentblock_AST = currentAST.root;
283 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
285 recover(ex,_tokenSet_2);
287 returnAST = fragmentblock_AST;
290void MDParser::zconstraintblock() {
291 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
292 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
293 ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
296 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
297 tmp13_AST = astFactory->create(LT(1));
298 astFactory->makeASTRoot(currentAST, tmp13_AST);
305 astFactory->addASTChild( currentAST, returnAST );
314 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
315 tmp15_AST = astFactory->create(LT(1));
316 astFactory->addASTChild(currentAST, tmp15_AST);
318#line 101 "MDParser.g"
319 tmp15_AST->setType(ENDBLOCK);
320#line 321 "MDParser.cpp"
321 zconstraintblock_AST = currentAST.root;
323 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
325 recover(ex,_tokenSet_2);
327 returnAST = zconstraintblock_AST;
330void MDParser::restraintblock() {
331 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
332 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
333 ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
336 ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
337 tmp16_AST = astFactory->create(LT(1));
338 astFactory->makeASTRoot(currentAST, tmp16_AST);
345 astFactory->addASTChild( currentAST, returnAST );
354 ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
355 tmp18_AST = astFactory->create(LT(1));
356 astFactory->addASTChild(currentAST, tmp18_AST);
358#line 104 "MDParser.g"
359 tmp18_AST->setType(ENDBLOCK);
360#line 361 "MDParser.cpp"
361 restraintblock_AST = currentAST.root;
363 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
365 recover(ex,_tokenSet_2);
367 returnAST = restraintblock_AST;
370void MDParser::flucqblock() {
371 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
372 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
373 ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
376 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
377 tmp19_AST = astFactory->create(LT(1));
378 astFactory->makeASTRoot(currentAST, tmp19_AST);
385 astFactory->addASTChild( currentAST, returnAST );
394 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
395 tmp21_AST = astFactory->create(LT(1));
396 astFactory->addASTChild(currentAST, tmp21_AST);
398#line 107 "MDParser.g"
399 tmp21_AST->setType(ENDBLOCK);
400#line 401 "MDParser.cpp"
401 flucqblock_AST = currentAST.root;
403 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
405 recover(ex,_tokenSet_2);
407 returnAST = flucqblock_AST;
410void MDParser::rnemdblock() {
411 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
412 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
413 ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
416 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
417 tmp22_AST = astFactory->create(LT(1));
418 astFactory->makeASTRoot(currentAST, tmp22_AST);
425 astFactory->addASTChild( currentAST, returnAST );
434 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
435 tmp24_AST = astFactory->create(LT(1));
436 astFactory->addASTChild(currentAST, tmp24_AST);
438#line 110 "MDParser.g"
439 tmp24_AST->setType(ENDBLOCK);
440#line 441 "MDParser.cpp"
441 rnemdblock_AST = currentAST.root;
443 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
445 recover(ex,_tokenSet_2);
447 returnAST = rnemdblock_AST;
450void MDParser::minimizerblock() {
451 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
452 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
453 ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
456 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
457 tmp25_AST = astFactory->create(LT(1));
458 astFactory->makeASTRoot(currentAST, tmp25_AST);
465 astFactory->addASTChild( currentAST, returnAST );
474 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
475 tmp27_AST = astFactory->create(LT(1));
476 astFactory->addASTChild(currentAST, tmp27_AST);
478#line 113 "MDParser.g"
479 tmp27_AST->setType(ENDBLOCK);
480#line 481 "MDParser.cpp"
481 minimizerblock_AST = currentAST.root;
483 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
485 recover(ex,_tokenSet_2);
487 returnAST = minimizerblock_AST;
490void MDParser::constant() {
491 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
492 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
493 ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
501 astFactory->addASTChild( currentAST, returnAST );
502 constant_AST = currentAST.root;
509 astFactory->addASTChild( currentAST, returnAST );
510 constant_AST = currentAST.root;
516 astFactory->addASTChild( currentAST, returnAST );
517 constant_AST = currentAST.root;
522 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 tmp28_AST = astFactory->create(LT(1));
524 astFactory->addASTChild(currentAST, tmp28_AST);
526 constant_AST = currentAST.root;
531 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
532 tmp29_AST = astFactory->create(LT(1));
533 astFactory->addASTChild(currentAST, tmp29_AST);
534 match(StringLiteral);
535 constant_AST = currentAST.root;
540 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
544 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
546 recover(ex,_tokenSet_6);
548 returnAST = constant_AST;
551void MDParser::intConst() {
552 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
553 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
554 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
560 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 tmp30_AST = astFactory->create(LT(1));
562 astFactory->addASTChild(currentAST, tmp30_AST);
564 intConst_AST = currentAST.root;
569 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
570 tmp31_AST = astFactory->create(LT(1));
571 astFactory->addASTChild(currentAST, tmp31_AST);
573 intConst_AST = currentAST.root;
578 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
582 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
584 recover(ex,_tokenSet_7);
586 returnAST = intConst_AST;
589void MDParser::floatConst() {
590 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
591 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
592 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
598 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 tmp32_AST = astFactory->create(LT(1));
600 astFactory->addASTChild(currentAST, tmp32_AST);
602 floatConst_AST = currentAST.root;
607 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
608 tmp33_AST = astFactory->create(LT(1));
609 astFactory->addASTChild(currentAST, tmp33_AST);
611 floatConst_AST = currentAST.root;
616 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
620 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
622 recover(ex,_tokenSet_8);
624 returnAST = floatConst_AST;
627void MDParser::vectorConst() {
628 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
629 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
630 ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
633 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
634 tmp34_AST = astFactory->create(LT(1));
635 astFactory->makeASTRoot(currentAST, tmp34_AST);
638 astFactory->addASTChild( currentAST, returnAST );
639 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
640 tmp35_AST = astFactory->create(LT(1));
641 astFactory->addASTChild(currentAST, tmp35_AST);
643 vectorConst_AST = currentAST.root;
645 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
647 recover(ex,_tokenSet_6);
649 returnAST = vectorConst_AST;
652void MDParser::moleculestatement() {
653 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
654 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
655 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
662 astFactory->addASTChild( currentAST, returnAST );
663 moleculestatement_AST = currentAST.root;
669 astFactory->addASTChild( currentAST, returnAST );
670 moleculestatement_AST = currentAST.root;
676 astFactory->addASTChild( currentAST, returnAST );
677 moleculestatement_AST = currentAST.root;
683 astFactory->addASTChild( currentAST, returnAST );
684 moleculestatement_AST = currentAST.root;
690 astFactory->addASTChild( currentAST, returnAST );
691 moleculestatement_AST = currentAST.root;
697 astFactory->addASTChild( currentAST, returnAST );
698 moleculestatement_AST = currentAST.root;
704 astFactory->addASTChild( currentAST, returnAST );
705 moleculestatement_AST = currentAST.root;
711 astFactory->addASTChild( currentAST, returnAST );
712 moleculestatement_AST = currentAST.root;
718 astFactory->addASTChild( currentAST, returnAST );
719 moleculestatement_AST = currentAST.root;
725 astFactory->addASTChild( currentAST, returnAST );
726 moleculestatement_AST = currentAST.root;
731 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
735 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
737 recover(ex,_tokenSet_9);
739 returnAST = moleculestatement_AST;
742void MDParser::atomblock() {
743 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
744 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
745 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
748 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
749 tmp36_AST = astFactory->create(LT(1));
750 astFactory->makeASTRoot(currentAST, tmp36_AST);
754 astFactory->addASTChild( currentAST, returnAST );
759 if ((_tokenSet_10.member(LA(1)))) {
761 astFactory->addASTChild( currentAST, returnAST );
770 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
771 tmp40_AST = astFactory->create(LT(1));
772 astFactory->addASTChild(currentAST, tmp40_AST);
774#line 131 "MDParser.g"
775 tmp40_AST->setType(ENDBLOCK);
776#line 777 "MDParser.cpp"
777 atomblock_AST = currentAST.root;
779 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
781 recover(ex,_tokenSet_11);
783 returnAST = atomblock_AST;
786void MDParser::bondblock() {
787 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
789 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
792 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
793 tmp41_AST = astFactory->create(LT(1));
794 astFactory->makeASTRoot(currentAST, tmp41_AST);
811 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
818 if ((_tokenSet_12.member(LA(1)))) {
820 astFactory->addASTChild( currentAST, returnAST );
829 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
830 tmp45_AST = astFactory->create(LT(1));
831 astFactory->addASTChild(currentAST, tmp45_AST);
833#line 141 "MDParser.g"
834 tmp45_AST->setType(ENDBLOCK);
835#line 836 "MDParser.cpp"
836 bondblock_AST = currentAST.root;
838 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
840 recover(ex,_tokenSet_11);
842 returnAST = bondblock_AST;
845void MDParser::bendblock() {
846 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
848 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
851 ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
852 tmp46_AST = astFactory->create(LT(1));
853 astFactory->makeASTRoot(currentAST, tmp46_AST);
870 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
877 if ((_tokenSet_13.member(LA(1)))) {
879 astFactory->addASTChild( currentAST, returnAST );
888 ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
889 tmp50_AST = astFactory->create(LT(1));
890 astFactory->addASTChild(currentAST, tmp50_AST);
892#line 154 "MDParser.g"
893 tmp50_AST->setType(ENDBLOCK);
894#line 895 "MDParser.cpp"
895 bendblock_AST = currentAST.root;
897 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
899 recover(ex,_tokenSet_11);
901 returnAST = bendblock_AST;
904void MDParser::torsionblock() {
905 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
907 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
910 ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
911 tmp51_AST = astFactory->create(LT(1));
912 astFactory->makeASTRoot(currentAST, tmp51_AST);
929 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
936 if ((_tokenSet_14.member(LA(1)))) {
938 astFactory->addASTChild( currentAST, returnAST );
947 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
948 tmp55_AST = astFactory->create(LT(1));
949 astFactory->addASTChild(currentAST, tmp55_AST);
951#line 168 "MDParser.g"
952 tmp55_AST->setType(ENDBLOCK);
953#line 954 "MDParser.cpp"
954 torsionblock_AST = currentAST.root;
956 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
958 recover(ex,_tokenSet_11);
960 returnAST = torsionblock_AST;
963void MDParser::inversionblock() {
964 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
966 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
969 ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
970 tmp56_AST = astFactory->create(LT(1));
971 astFactory->makeASTRoot(currentAST, tmp56_AST);
988 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
995 if ((_tokenSet_15.member(LA(1)))) {
996 inversionstatement();
997 astFactory->addASTChild( currentAST, returnAST );
1006 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1007 tmp60_AST = astFactory->create(LT(1));
1008 astFactory->addASTChild(currentAST, tmp60_AST);
1010#line 183 "MDParser.g"
1011 tmp60_AST->setType(ENDBLOCK);
1012#line 1013 "MDParser.cpp"
1013 inversionblock_AST = currentAST.root;
1015 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1017 recover(ex,_tokenSet_11);
1019 returnAST = inversionblock_AST;
1022void MDParser::rigidbodyblock() {
1023 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1025 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1028 ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1029 tmp61_AST = astFactory->create(LT(1));
1030 astFactory->makeASTRoot(currentAST, tmp61_AST);
1034 astFactory->addASTChild( currentAST, returnAST );
1039 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1040 rigidbodystatement();
1041 astFactory->addASTChild( currentAST, returnAST );
1050 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1051 tmp65_AST = astFactory->create(LT(1));
1052 astFactory->addASTChild(currentAST, tmp65_AST);
1054#line 196 "MDParser.g"
1055 tmp65_AST->setType(ENDBLOCK);
1056#line 1057 "MDParser.cpp"
1057 rigidbodyblock_AST = currentAST.root;
1059 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1061 recover(ex,_tokenSet_11);
1063 returnAST = rigidbodyblock_AST;
1066void MDParser::cutoffgroupblock() {
1067 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1069 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1072 ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1073 tmp66_AST = astFactory->create(LT(1));
1074 astFactory->makeASTRoot(currentAST, tmp66_AST);
1091 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1098 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1099 cutoffgroupstatement();
1100 astFactory->addASTChild( currentAST, returnAST );
1109 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1110 tmp70_AST = astFactory->create(LT(1));
1111 astFactory->addASTChild(currentAST, tmp70_AST);
1113#line 203 "MDParser.g"
1114 tmp70_AST->setType(ENDBLOCK);
1115#line 1116 "MDParser.cpp"
1116 cutoffgroupblock_AST = currentAST.root;
1118 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1120 recover(ex,_tokenSet_11);
1122 returnAST = cutoffgroupblock_AST;
1125void MDParser::constraintblock() {
1126 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1127 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1128 ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1131 ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1132 tmp71_AST = astFactory->create(LT(1));
1133 astFactory->makeASTRoot(currentAST, tmp71_AST);
1150 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1157 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1158 constraintstatement();
1159 astFactory->addASTChild( currentAST, returnAST );
1168 ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1169 tmp75_AST = astFactory->create(LT(1));
1170 astFactory->addASTChild(currentAST, tmp75_AST);
1172#line 232 "MDParser.g"
1173 tmp75_AST->setType(ENDBLOCK);
1174#line 1175 "MDParser.cpp"
1175 constraintblock_AST = currentAST.root;
1177 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1179 recover(ex,_tokenSet_11);
1181 returnAST = constraintblock_AST;
1184void MDParser::sequencestring() {
1185 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1186 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1187 ANTLR_USE_NAMESPACE(antlr)RefAST sequencestring_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1190 ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1191 tmp76_AST = astFactory->create(LT(1));
1192 astFactory->addASTChild(currentAST, tmp76_AST);
1194 ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1195 tmp77_AST = astFactory->create(LT(1));
1196 astFactory->makeASTRoot(currentAST, tmp77_AST);
1199 astFactory->addASTChild( currentAST, returnAST );
1201 sequencestring_AST = currentAST.root;
1203 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1205 recover(ex,_tokenSet_9);
1207 returnAST = sequencestring_AST;
1210void MDParser::atomstatement() {
1211 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1213 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1220 astFactory->addASTChild( currentAST, returnAST );
1221 atomstatement_AST = currentAST.root;
1226 ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1227 tmp79_AST = astFactory->create(LT(1));
1228 astFactory->makeASTRoot(currentAST, tmp79_AST);
1231 doubleNumberTuple();
1232 astFactory->addASTChild( currentAST, returnAST );
1235 atomstatement_AST = currentAST.root;
1240 ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1241 tmp83_AST = astFactory->create(LT(1));
1242 astFactory->makeASTRoot(currentAST, tmp83_AST);
1245 doubleNumberTuple();
1246 astFactory->addASTChild( currentAST, returnAST );
1249 atomstatement_AST = currentAST.root;
1254 ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1255 tmp87_AST = astFactory->create(LT(1));
1256 astFactory->makeASTRoot(currentAST, tmp87_AST);
1260 astFactory->addASTChild( currentAST, returnAST );
1263 atomstatement_AST = currentAST.root;
1268 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1272 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1274 recover(ex,_tokenSet_16);
1276 returnAST = atomstatement_AST;
1279void MDParser::doubleNumberTuple() {
1280 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1281 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1282 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1286 astFactory->addASTChild( currentAST, returnAST );
1289 if ((LA(1) == COMMA)) {
1292 astFactory->addASTChild( currentAST, returnAST );
1301 doubleNumberTuple_AST = currentAST.root;
1303 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1305 recover(ex,_tokenSet_17);
1307 returnAST = doubleNumberTuple_AST;
1310void MDParser::bondstatement() {
1311 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1312 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1313 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1320 astFactory->addASTChild( currentAST, returnAST );
1321 bondstatement_AST = currentAST.root;
1326 ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1327 tmp92_AST = astFactory->create(LT(1));
1328 astFactory->makeASTRoot(currentAST, tmp92_AST);
1332 astFactory->addASTChild( currentAST, returnAST );
1335 bondstatement_AST = currentAST.root;
1340 ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1341 tmp96_AST = astFactory->create(LT(1));
1342 astFactory->makeASTRoot(currentAST, tmp96_AST);
1346 astFactory->addASTChild( currentAST, returnAST );
1349 bondstatement_AST = currentAST.root;
1354 ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1355 tmp100_AST = astFactory->create(LT(1));
1356 astFactory->makeASTRoot(currentAST, tmp100_AST);
1359 doubleNumberTuple();
1360 astFactory->addASTChild( currentAST, returnAST );
1363 bondstatement_AST = currentAST.root;
1368 ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1369 tmp104_AST = astFactory->create(LT(1));
1370 astFactory->makeASTRoot(currentAST, tmp104_AST);
1373 doubleNumberTuple();
1374 astFactory->addASTChild( currentAST, returnAST );
1377 bondstatement_AST = currentAST.root;
1382 ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1383 tmp108_AST = astFactory->create(LT(1));
1384 astFactory->makeASTRoot(currentAST, tmp108_AST);
1387 doubleNumberTuple();
1388 astFactory->addASTChild( currentAST, returnAST );
1391 bondstatement_AST = currentAST.root;
1396 ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 tmp112_AST = astFactory->create(LT(1));
1398 astFactory->makeASTRoot(currentAST, tmp112_AST);
1401 doubleNumberTuple();
1402 astFactory->addASTChild( currentAST, returnAST );
1405 bondstatement_AST = currentAST.root;
1410 ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1411 tmp116_AST = astFactory->create(LT(1));
1412 astFactory->makeASTRoot(currentAST, tmp116_AST);
1415 doubleNumberTuple();
1416 astFactory->addASTChild( currentAST, returnAST );
1419 bondstatement_AST = currentAST.root;
1424 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1428 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1430 recover(ex,_tokenSet_18);
1432 returnAST = bondstatement_AST;
1435void MDParser::inttuple() {
1436 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1437 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1438 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1442 astFactory->addASTChild( currentAST, returnAST );
1445 if ((LA(1) == COMMA)) {
1448 astFactory->addASTChild( currentAST, returnAST );
1457 inttuple_AST = currentAST.root;
1459 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1461 recover(ex,_tokenSet_17);
1463 returnAST = inttuple_AST;
1466void MDParser::bendstatement() {
1467 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1468 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1469 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1476 astFactory->addASTChild( currentAST, returnAST );
1477 bendstatement_AST = currentAST.root;
1482 ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1483 tmp121_AST = astFactory->create(LT(1));
1484 astFactory->makeASTRoot(currentAST, tmp121_AST);
1488 astFactory->addASTChild( currentAST, returnAST );
1491 bendstatement_AST = currentAST.root;
1496 ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1497 tmp125_AST = astFactory->create(LT(1));
1498 astFactory->makeASTRoot(currentAST, tmp125_AST);
1501 doubleNumberTuple();
1502 astFactory->addASTChild( currentAST, returnAST );
1505 bendstatement_AST = currentAST.root;
1510 ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1511 tmp129_AST = astFactory->create(LT(1));
1512 astFactory->makeASTRoot(currentAST, tmp129_AST);
1515 doubleNumberTuple();
1516 astFactory->addASTChild( currentAST, returnAST );
1519 bendstatement_AST = currentAST.root;
1524 ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1525 tmp133_AST = astFactory->create(LT(1));
1526 astFactory->makeASTRoot(currentAST, tmp133_AST);
1529 doubleNumberTuple();
1530 astFactory->addASTChild( currentAST, returnAST );
1533 bendstatement_AST = currentAST.root;
1538 ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1539 tmp137_AST = astFactory->create(LT(1));
1540 astFactory->makeASTRoot(currentAST, tmp137_AST);
1543 doubleNumberTuple();
1544 astFactory->addASTChild( currentAST, returnAST );
1547 bendstatement_AST = currentAST.root;
1552 ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1553 tmp141_AST = astFactory->create(LT(1));
1554 astFactory->makeASTRoot(currentAST, tmp141_AST);
1557 doubleNumberTuple();
1558 astFactory->addASTChild( currentAST, returnAST );
1561 bendstatement_AST = currentAST.root;
1566 ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1567 tmp145_AST = astFactory->create(LT(1));
1568 astFactory->makeASTRoot(currentAST, tmp145_AST);
1571 doubleNumberTuple();
1572 astFactory->addASTChild( currentAST, returnAST );
1575 bendstatement_AST = currentAST.root;
1580 ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1581 tmp149_AST = astFactory->create(LT(1));
1582 astFactory->makeASTRoot(currentAST, tmp149_AST);
1585 doubleNumberTuple();
1586 astFactory->addASTChild( currentAST, returnAST );
1589 bendstatement_AST = currentAST.root;
1594 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1598 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1600 recover(ex,_tokenSet_19);
1602 returnAST = bendstatement_AST;
1605void MDParser::torsionstatement() {
1606 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1607 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1608 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1615 astFactory->addASTChild( currentAST, returnAST );
1616 torsionstatement_AST = currentAST.root;
1621 ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1622 tmp153_AST = astFactory->create(LT(1));
1623 astFactory->makeASTRoot(currentAST, tmp153_AST);
1627 astFactory->addASTChild( currentAST, returnAST );
1630 torsionstatement_AST = currentAST.root;
1635 ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1636 tmp157_AST = astFactory->create(LT(1));
1637 astFactory->makeASTRoot(currentAST, tmp157_AST);
1638 match(GHOSTTORSION);
1640 doubleNumberTuple();
1641 astFactory->addASTChild( currentAST, returnAST );
1644 torsionstatement_AST = currentAST.root;
1649 ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1650 tmp161_AST = astFactory->create(LT(1));
1651 astFactory->makeASTRoot(currentAST, tmp161_AST);
1654 doubleNumberTuple();
1655 astFactory->addASTChild( currentAST, returnAST );
1658 torsionstatement_AST = currentAST.root;
1663 ANTLR_USE_NAMESPACE(antlr)RefAST tmp165_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1664 tmp165_AST = astFactory->create(LT(1));
1665 astFactory->makeASTRoot(currentAST, tmp165_AST);
1668 doubleNumberTuple();
1669 astFactory->addASTChild( currentAST, returnAST );
1672 torsionstatement_AST = currentAST.root;
1677 ANTLR_USE_NAMESPACE(antlr)RefAST tmp169_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1678 tmp169_AST = astFactory->create(LT(1));
1679 astFactory->makeASTRoot(currentAST, tmp169_AST);
1682 doubleNumberTuple();
1683 astFactory->addASTChild( currentAST, returnAST );
1686 torsionstatement_AST = currentAST.root;
1691 ANTLR_USE_NAMESPACE(antlr)RefAST tmp173_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1692 tmp173_AST = astFactory->create(LT(1));
1693 astFactory->makeASTRoot(currentAST, tmp173_AST);
1696 doubleNumberTuple();
1697 astFactory->addASTChild( currentAST, returnAST );
1700 torsionstatement_AST = currentAST.root;
1705 ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1706 tmp177_AST = astFactory->create(LT(1));
1707 astFactory->makeASTRoot(currentAST, tmp177_AST);
1710 doubleNumberTuple();
1711 astFactory->addASTChild( currentAST, returnAST );
1714 torsionstatement_AST = currentAST.root;
1719 ANTLR_USE_NAMESPACE(antlr)RefAST tmp181_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1720 tmp181_AST = astFactory->create(LT(1));
1721 astFactory->makeASTRoot(currentAST, tmp181_AST);
1724 doubleNumberTuple();
1725 astFactory->addASTChild( currentAST, returnAST );
1728 torsionstatement_AST = currentAST.root;
1733 ANTLR_USE_NAMESPACE(antlr)RefAST tmp185_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1734 tmp185_AST = astFactory->create(LT(1));
1735 astFactory->makeASTRoot(currentAST, tmp185_AST);
1738 doubleNumberTuple();
1739 astFactory->addASTChild( currentAST, returnAST );
1742 torsionstatement_AST = currentAST.root;
1747 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1751 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1753 recover(ex,_tokenSet_20);
1755 returnAST = torsionstatement_AST;
1758void MDParser::inversionstatement() {
1759 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1760 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1761 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1768 astFactory->addASTChild( currentAST, returnAST );
1769 inversionstatement_AST = currentAST.root;
1774 ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1775 tmp189_AST = astFactory->create(LT(1));
1776 astFactory->makeASTRoot(currentAST, tmp189_AST);
1780 astFactory->addASTChild( currentAST, returnAST );
1783 inversionstatement_AST = currentAST.root;
1788 ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1789 tmp193_AST = astFactory->create(LT(1));
1790 astFactory->makeASTRoot(currentAST, tmp193_AST);
1794 astFactory->addASTChild( currentAST, returnAST );
1797 inversionstatement_AST = currentAST.root;
1802 ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1803 tmp197_AST = astFactory->create(LT(1));
1804 astFactory->makeASTRoot(currentAST, tmp197_AST);
1805 match(AMBERIMPROPER);
1807 doubleNumberTuple();
1808 astFactory->addASTChild( currentAST, returnAST );
1811 inversionstatement_AST = currentAST.root;
1814 case IMPROPERCOSINE:
1816 ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1817 tmp201_AST = astFactory->create(LT(1));
1818 astFactory->makeASTRoot(currentAST, tmp201_AST);
1819 match(IMPROPERCOSINE);
1821 doubleNumberTuple();
1822 astFactory->addASTChild( currentAST, returnAST );
1825 inversionstatement_AST = currentAST.root;
1830 ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1831 tmp205_AST = astFactory->create(LT(1));
1832 astFactory->makeASTRoot(currentAST, tmp205_AST);
1835 doubleNumberTuple();
1836 astFactory->addASTChild( currentAST, returnAST );
1839 inversionstatement_AST = currentAST.root;
1842 case CENTRALATOMHEIGHT:
1844 ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1845 tmp209_AST = astFactory->create(LT(1));
1846 astFactory->makeASTRoot(currentAST, tmp209_AST);
1847 match(CENTRALATOMHEIGHT);
1849 doubleNumberTuple();
1850 astFactory->addASTChild( currentAST, returnAST );
1853 inversionstatement_AST = currentAST.root;
1858 ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1859 tmp213_AST = astFactory->create(LT(1));
1860 astFactory->makeASTRoot(currentAST, tmp213_AST);
1863 doubleNumberTuple();
1864 astFactory->addASTChild( currentAST, returnAST );
1867 inversionstatement_AST = currentAST.root;
1872 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1876 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1878 recover(ex,_tokenSet_21);
1880 returnAST = inversionstatement_AST;
1883void MDParser::rigidbodystatement() {
1884 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1885 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1886 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1893 astFactory->addASTChild( currentAST, returnAST );
1894 rigidbodystatement_AST = currentAST.root;
1899 ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1900 tmp217_AST = astFactory->create(LT(1));
1901 astFactory->makeASTRoot(currentAST, tmp217_AST);
1905 astFactory->addASTChild( currentAST, returnAST );
1908 rigidbodystatement_AST = currentAST.root;
1913 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1917 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1919 recover(ex,_tokenSet_22);
1921 returnAST = rigidbodystatement_AST;
1924void MDParser::cutoffgroupstatement() {
1925 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1926 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1927 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1934 astFactory->addASTChild( currentAST, returnAST );
1935 cutoffgroupstatement_AST = currentAST.root;
1940 ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1941 tmp221_AST = astFactory->create(LT(1));
1942 astFactory->makeASTRoot(currentAST, tmp221_AST);
1946 astFactory->addASTChild( currentAST, returnAST );
1949 cutoffgroupstatement_AST = currentAST.root;
1954 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1958 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1960 recover(ex,_tokenSet_22);
1962 returnAST = cutoffgroupstatement_AST;
1965void MDParser::nodesblock() {
1966 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1967 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1968 ANTLR_USE_NAMESPACE(antlr)RefAST nodesblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1971 ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1972 tmp225_AST = astFactory->create(LT(1));
1973 astFactory->makeASTRoot(currentAST, tmp225_AST);
1990 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1997 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1999 astFactory->addASTChild( currentAST, returnAST );
2008 ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2009 tmp229_AST = astFactory->create(LT(1));
2010 astFactory->addASTChild(currentAST, tmp229_AST);
2012#line 210 "MDParser.g"
2013 tmp229_AST->setType(ENDBLOCK);
2014#line 2015 "MDParser.cpp"
2015 nodesblock_AST = currentAST.root;
2017 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2019 recover(ex,_tokenSet_23);
2021 returnAST = nodesblock_AST;
2024void MDParser::nodesstatement() {
2025 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2026 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2027 ANTLR_USE_NAMESPACE(antlr)RefAST nodesstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2034 astFactory->addASTChild( currentAST, returnAST );
2035 nodesstatement_AST = currentAST.root;
2040 ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2041 tmp230_AST = astFactory->create(LT(1));
2042 astFactory->makeASTRoot(currentAST, tmp230_AST);
2046 astFactory->addASTChild( currentAST, returnAST );
2049 nodesstatement_AST = currentAST.root;
2054 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2058 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2060 recover(ex,_tokenSet_22);
2062 returnAST = nodesstatement_AST;
2065void MDParser::fragmentstatement() {
2066 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2067 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2068 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2075 astFactory->addASTChild( currentAST, returnAST );
2076 fragmentstatement_AST = currentAST.root;
2082 astFactory->addASTChild( currentAST, returnAST );
2083 fragmentstatement_AST = currentAST.root;
2089 astFactory->addASTChild( currentAST, returnAST );
2090 fragmentstatement_AST = currentAST.root;
2096 astFactory->addASTChild( currentAST, returnAST );
2097 fragmentstatement_AST = currentAST.root;
2103 astFactory->addASTChild( currentAST, returnAST );
2104 fragmentstatement_AST = currentAST.root;
2110 astFactory->addASTChild( currentAST, returnAST );
2111 fragmentstatement_AST = currentAST.root;
2117 astFactory->addASTChild( currentAST, returnAST );
2118 fragmentstatement_AST = currentAST.root;
2124 astFactory->addASTChild( currentAST, returnAST );
2125 fragmentstatement_AST = currentAST.root;
2131 astFactory->addASTChild( currentAST, returnAST );
2132 fragmentstatement_AST = currentAST.root;
2138 astFactory->addASTChild( currentAST, returnAST );
2139 fragmentstatement_AST = currentAST.root;
2144 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2148 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2150 recover(ex,_tokenSet_23);
2152 returnAST = fragmentstatement_AST;
2155void MDParser::constraintstatement() {
2156 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2157 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2158 ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2165 astFactory->addASTChild( currentAST, returnAST );
2166 constraintstatement_AST = currentAST.root;
2171 ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2172 tmp234_AST = astFactory->create(LT(1));
2173 astFactory->makeASTRoot(currentAST, tmp234_AST);
2177 astFactory->addASTChild( currentAST, returnAST );
2180 constraintstatement_AST = currentAST.root;
2185 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2189 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2191 recover(ex,_tokenSet_22);
2193 returnAST = constraintstatement_AST;
2196void MDParser::doubleNumber() {
2197 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2198 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2199 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2208 astFactory->addASTChild( currentAST, returnAST );
2215 astFactory->addASTChild( currentAST, returnAST );
2220 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2224 doubleNumber_AST = currentAST.root;
2226 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2228 recover(ex,_tokenSet_24);
2230 returnAST = doubleNumber_AST;
2233void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
2235 factory.setMaxNodeType(79);
2237const char* MDParser::tokenNames[] = {
2241 "NULL_TREE_LOOKAHEAD",
2278 "\"AmberImproper\"",
2279 "\"ImproperCosine\"",
2280 "\"CentralAtomHeight\"",
2321const unsigned long MDParser::_tokenSet_0_data_[] = { 117571824UL, 32768UL, 0UL, 0UL };
2324const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
2325const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
2327const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
2328const unsigned long MDParser::_tokenSet_2_data_[] = { 117571826UL, 32768UL, 0UL, 0UL };
2331const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
2332const unsigned long MDParser::_tokenSet_3_data_[] = { 4294901746UL, 1097727UL, 0UL, 0UL };
2340const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
2341const unsigned long MDParser::_tokenSet_4_data_[] = { 327424UL, 32768UL, 0UL, 0UL };
2344const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
2345const unsigned long MDParser::_tokenSet_5_data_[] = { 65280UL, 40960UL, 0UL, 0UL };
2348const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
2349const unsigned long MDParser::_tokenSet_6_data_[] = { 0UL, 131072UL, 0UL, 0UL };
2351const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
2352const unsigned long MDParser::_tokenSet_7_data_[] = { 0UL, 54657024UL, 0UL, 0UL };
2354const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
2355const unsigned long MDParser::_tokenSet_8_data_[] = { 0UL, 50462720UL, 0UL, 0UL };
2357const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
2358const unsigned long MDParser::_tokenSet_9_data_[] = { 327424UL, 1081344UL, 0UL, 0UL };
2361const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
2362const unsigned long MDParser::_tokenSet_10_data_[] = { 12582912UL, 36864UL, 0UL, 0UL };
2364const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
2365const unsigned long MDParser::_tokenSet_11_data_[] = { 327424UL, 1089536UL, 0UL, 0UL };
2368const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
2369const unsigned long MDParser::_tokenSet_12_data_[] = { 4161273856UL, 32769UL, 0UL, 0UL };
2372const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
2373const unsigned long MDParser::_tokenSet_13_data_[] = { 4027056128UL, 32782UL, 0UL, 0UL };
2376const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
2377const unsigned long MDParser::_tokenSet_14_data_[] = { 4027056128UL, 33008UL, 0UL, 0UL };
2380const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
2381const unsigned long MDParser::_tokenSet_15_data_[] = { 271581184UL, 36608UL, 0UL, 0UL };
2384const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
2385const unsigned long MDParser::_tokenSet_16_data_[] = { 12582912UL, 1085440UL, 0UL, 0UL };
2387const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
2388const unsigned long MDParser::_tokenSet_17_data_[] = { 0UL, 16777216UL, 0UL, 0UL };
2390const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_17(_tokenSet_17_data_,4);
2391const unsigned long MDParser::_tokenSet_18_data_[] = { 4161273856UL, 1081345UL, 0UL, 0UL };
2394const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_18(_tokenSet_18_data_,4);
2395const unsigned long MDParser::_tokenSet_19_data_[] = { 4027056128UL, 1081358UL, 0UL, 0UL };
2398const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_19(_tokenSet_19_data_,4);
2399const unsigned long MDParser::_tokenSet_20_data_[] = { 4027056128UL, 1081584UL, 0UL, 0UL };
2402const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_20(_tokenSet_20_data_,4);
2403const unsigned long MDParser::_tokenSet_21_data_[] = { 271581184UL, 1085184UL, 0UL, 0UL };
2406const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_21(_tokenSet_21_data_,4);
2407const unsigned long MDParser::_tokenSet_22_data_[] = { 524288UL, 1081344UL, 0UL, 0UL };
2409const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_22(_tokenSet_22_data_,4);
2410const unsigned long MDParser::_tokenSet_23_data_[] = { 65280UL, 1089536UL, 0UL, 0UL };
2413const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_23(_tokenSet_23_data_,4);
2414const unsigned long MDParser::_tokenSet_24_data_[] = { 0UL, 50331648UL, 0UL, 0UL };
2416const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_24(_tokenSet_24_data_,4);