--- trunk/src/mdParser/MDParser.cpp 2005/12/02 15:38:03 770 +++ trunk/src/mdParser/MDParser.cpp 2014/12/02 22:11:04 2046 @@ -1,4 +1,4 @@ -/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */ +/* $ANTLR 2.7.7 (20141024): "MDParser.g" -> "MDParser.cpp"$ */ #include "MDParser.hpp" #include #include @@ -89,6 +89,34 @@ void MDParser::statement() { case ZCONSTRAINT: { zconstraintblock(); + astFactory->addASTChild( currentAST, returnAST ); + statement_AST = currentAST.root; + break; + } + case RESTRAINT: + { + restraintblock(); + astFactory->addASTChild( currentAST, returnAST ); + statement_AST = currentAST.root; + break; + } + case FLUCQ: + { + flucqblock(); + astFactory->addASTChild( currentAST, returnAST ); + statement_AST = currentAST.root; + break; + } + case RNEMD: + { + rnemdblock(); + astFactory->addASTChild( currentAST, returnAST ); + statement_AST = currentAST.root; + break; + } + case MINIMIZER: + { + minimizerblock(); astFactory->addASTChild( currentAST, returnAST ); statement_AST = currentAST.root; break; @@ -160,9 +188,9 @@ void MDParser::componentblock() { tmp6_AST = astFactory->create(LT(1)); astFactory->addASTChild(currentAST, tmp6_AST); match(RCURLY); -#line 65 "MDParser.g" +#line 95 "MDParser.g" tmp6_AST->setType(ENDBLOCK); -#line 166 "MDParser.cpp" +#line 194 "MDParser.cpp" componentblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { @@ -190,19 +218,19 @@ void MDParser::moleculeblock() { astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop15; + goto _loop27; } } - _loop15:; + _loop27:; } // ( ... )* ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; tmp9_AST = astFactory->create(LT(1)); astFactory->addASTChild(currentAST, tmp9_AST); match(RCURLY); -#line 71 "MDParser.g" +#line 113 "MDParser.g" tmp9_AST->setType(ENDBLOCK); -#line 206 "MDParser.cpp" +#line 234 "MDParser.cpp" moleculeblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { @@ -240,9 +268,9 @@ void MDParser::zconstraintblock() { tmp12_AST = astFactory->create(LT(1)); astFactory->addASTChild(currentAST, tmp12_AST); match(RCURLY); -#line 68 "MDParser.g" +#line 98 "MDParser.g" tmp12_AST->setType(ENDBLOCK); -#line 246 "MDParser.cpp" +#line 274 "MDParser.cpp" zconstraintblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { @@ -250,6 +278,166 @@ void MDParser::zconstraintblock() { recover(ex,_tokenSet_2); } returnAST = zconstraintblock_AST; +} + +void MDParser::restraintblock() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp13_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp13_AST); + match(RESTRAINT); + match(LCURLY); + { // ( ... )* + for (;;) { + if ((LA(1) == ID)) { + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop15; + } + + } + _loop15:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp15_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp15_AST); + match(RCURLY); +#line 101 "MDParser.g" + tmp15_AST->setType(ENDBLOCK); +#line 314 "MDParser.cpp" + restraintblock_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_2); + } + returnAST = restraintblock_AST; +} + +void MDParser::flucqblock() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp16_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp16_AST); + match(FLUCQ); + match(LCURLY); + { // ( ... )* + for (;;) { + if ((LA(1) == ID)) { + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop18; + } + + } + _loop18:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp18_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp18_AST); + match(RCURLY); +#line 104 "MDParser.g" + tmp18_AST->setType(ENDBLOCK); +#line 354 "MDParser.cpp" + flucqblock_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_2); + } + returnAST = flucqblock_AST; +} + +void MDParser::rnemdblock() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp19_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp19_AST); + match(RNEMD); + match(LCURLY); + { // ( ... )* + for (;;) { + if ((LA(1) == ID)) { + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop21; + } + + } + _loop21:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp21_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp21_AST); + match(RCURLY); +#line 107 "MDParser.g" + tmp21_AST->setType(ENDBLOCK); +#line 394 "MDParser.cpp" + rnemdblock_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_2); + } + returnAST = rnemdblock_AST; +} + +void MDParser::minimizerblock() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp22_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp22_AST); + match(MINIMIZER); + match(LCURLY); + { // ( ... )* + for (;;) { + if ((LA(1) == ID)) { + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop24; + } + + } + _loop24:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp24_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp24_AST); + match(RCURLY); +#line 110 "MDParser.g" + tmp24_AST->setType(ENDBLOCK); +#line 434 "MDParser.cpp" + minimizerblock_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_2); + } + returnAST = minimizerblock_AST; } void MDParser::constant() { @@ -259,33 +447,43 @@ void MDParser::constant() { try { // for error handling switch ( LA(1)) { - case OCTALINT: - case DECIMALINT: - case HEXADECIMALINT: - case PLUS: - case MINUS: - case FLOATONE: - case FLOATTWO: + case NUM_INT: + case NUM_LONG: { - signedNumber(); + intConst(); astFactory->addASTChild( currentAST, returnAST ); constant_AST = currentAST.root; break; } + case NUM_FLOAT: + case NUM_DOUBLE: + { + floatConst(); + astFactory->addASTChild( currentAST, returnAST ); + constant_AST = currentAST.root; + break; + } + case LPAREN: + { + vectorConst(); + astFactory->addASTChild( currentAST, returnAST ); + constant_AST = currentAST.root; + break; + } case ID: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp13_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp13_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp25_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp25_AST); match(ID); constant_AST = currentAST.root; break; } case StringLiteral: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp14_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp14_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp26_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp26_AST); match(StringLiteral); constant_AST = currentAST.root; break; @@ -303,56 +501,67 @@ void MDParser::constant() { returnAST = constant_AST; } -void MDParser::signedNumber() { +void MDParser::intConst() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; - ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - { switch ( LA(1)) { - case PLUS: + case NUM_INT: { - match(PLUS); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp27_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp27_AST); + match(NUM_INT); + intConst_AST = currentAST.root; break; } - case MINUS: + case NUM_LONG: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp16_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp16_AST); - match(MINUS); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp28_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp28_AST); + match(NUM_LONG); + intConst_AST = currentAST.root; break; } - case OCTALINT: - case DECIMALINT: - case HEXADECIMALINT: - case FLOATONE: - case FLOATTWO: - { - break; - } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } - } - { - switch ( LA(1)) { - case OCTALINT: - case DECIMALINT: - case HEXADECIMALINT: + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_6); + } + returnAST = intConst_AST; +} + +void MDParser::floatConst() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case NUM_FLOAT: { - intConst(); - astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp29_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp29_AST); + match(NUM_FLOAT); + floatConst_AST = currentAST.root; break; } - case FLOATONE: - case FLOATTWO: + case NUM_DOUBLE: { - floatConst(); - astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp30_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp30_AST); + match(NUM_DOUBLE); + floatConst_AST = currentAST.root; break; } default: @@ -360,16 +569,39 @@ void MDParser::signedNumber() { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } - } - signedNumber_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_6); + recover(ex,_tokenSet_7); } - returnAST = signedNumber_AST; + returnAST = floatConst_AST; } +void MDParser::vectorConst() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp31_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp31_AST); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp32_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp32_AST); + match(RPAREN); + vectorConst_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_5); + } + returnAST = vectorConst_AST; +} + void MDParser::moleculestatement() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; @@ -412,6 +644,13 @@ void MDParser::moleculestatement() { moleculestatement_AST = currentAST.root; break; } + case INVERSION: + { + inversionblock(); + astFactory->addASTChild( currentAST, returnAST ); + moleculestatement_AST = currentAST.root; + break; + } case RIGIDBODY: { rigidbodyblock(); @@ -433,6 +672,13 @@ void MDParser::moleculestatement() { moleculestatement_AST = currentAST.root; break; } + case CONSTRAINT: + { + constraintblock(); + astFactory->addASTChild( currentAST, returnAST ); + moleculestatement_AST = currentAST.root; + break; + } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); @@ -441,7 +687,7 @@ void MDParser::moleculestatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = moleculestatement_AST; } @@ -452,9 +698,9 @@ void MDParser::atomblock() { ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp17_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp17_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp33_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp33_AST); match(ATOM); match(LBRACKET); intConst(); @@ -463,29 +709,29 @@ void MDParser::atomblock() { match(LCURLY); { // ( ... )* for (;;) { - if ((_tokenSet_8.member(LA(1)))) { + if ((_tokenSet_9.member(LA(1)))) { atomstatement(); astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop19; + goto _loop31; } } - _loop19:; + _loop31:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp21_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp21_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp37_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp37_AST); match(RCURLY); -#line 84 "MDParser.g" - tmp21_AST->setType(ENDBLOCK); -#line 484 "MDParser.cpp" +#line 128 "MDParser.g" + tmp37_AST->setType(ENDBLOCK); +#line 730 "MDParser.cpp" atomblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = atomblock_AST; } @@ -496,9 +742,9 @@ void MDParser::bondblock() { ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp22_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp22_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp38_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp38_AST); match(BOND); { switch ( LA(1)) { @@ -522,29 +768,29 @@ void MDParser::bondblock() { match(LCURLY); { // ( ... )* for (;;) { - if ((LA(1) == MEMBERS || LA(1) == ID)) { + if ((_tokenSet_10.member(LA(1)))) { bondstatement(); astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop24; + goto _loop36; } } - _loop24:; + _loop36:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp26_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp26_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp42_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp42_AST); match(RCURLY); -#line 93 "MDParser.g" - tmp26_AST->setType(ENDBLOCK); -#line 543 "MDParser.cpp" +#line 138 "MDParser.g" + tmp42_AST->setType(ENDBLOCK); +#line 789 "MDParser.cpp" bondblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = bondblock_AST; } @@ -555,9 +801,9 @@ void MDParser::bendblock() { ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp27_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp27_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp43_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp43_AST); match(BEND); { switch ( LA(1)) { @@ -581,29 +827,29 @@ void MDParser::bendblock() { match(LCURLY); { // ( ... )* for (;;) { - if ((LA(1) == MEMBERS || LA(1) == ID)) { + if ((_tokenSet_11.member(LA(1)))) { bendstatement(); astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop29; + goto _loop41; } } - _loop29:; + _loop41:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp31_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp31_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp47_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp47_AST); match(RCURLY); -#line 100 "MDParser.g" - tmp31_AST->setType(ENDBLOCK); -#line 602 "MDParser.cpp" +#line 151 "MDParser.g" + tmp47_AST->setType(ENDBLOCK); +#line 848 "MDParser.cpp" bendblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = bendblock_AST; } @@ -614,9 +860,9 @@ void MDParser::torsionblock() { ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp32_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp32_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp48_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp48_AST); match(TORSION); { switch ( LA(1)) { @@ -640,31 +886,90 @@ void MDParser::torsionblock() { match(LCURLY); { // ( ... )* for (;;) { - if ((LA(1) == MEMBERS || LA(1) == ID)) { + if ((_tokenSet_12.member(LA(1)))) { torsionstatement(); astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop34; + goto _loop46; } } - _loop34:; + _loop46:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp36_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp36_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp52_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp52_AST); match(RCURLY); -#line 107 "MDParser.g" - tmp36_AST->setType(ENDBLOCK); -#line 661 "MDParser.cpp" +#line 165 "MDParser.g" + tmp52_AST->setType(ENDBLOCK); +#line 907 "MDParser.cpp" torsionblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = torsionblock_AST; +} + +void MDParser::inversionblock() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp53_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp53_AST); + match(INVERSION); + { + switch ( LA(1)) { + case LBRACKET: + { + match(LBRACKET); + intConst(); + match(RBRACKET); + break; + } + case LCURLY: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(LCURLY); + { // ( ... )* + for (;;) { + if ((_tokenSet_13.member(LA(1)))) { + inversionstatement(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop51; + } + + } + _loop51:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp57_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp57_AST); + match(RCURLY); +#line 180 "MDParser.g" + tmp57_AST->setType(ENDBLOCK); +#line 966 "MDParser.cpp" + inversionblock_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_8); + } + returnAST = inversionblock_AST; } void MDParser::rigidbodyblock() { @@ -673,9 +978,9 @@ void MDParser::rigidbodyblock() { ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp37_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp37_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp58_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp58_AST); match(RIGIDBODY); match(LBRACKET); intConst(); @@ -689,24 +994,24 @@ void MDParser::rigidbodyblock() { astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop38; + goto _loop55; } } - _loop38:; + _loop55:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp41_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp41_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp62_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp62_AST); match(RCURLY); -#line 114 "MDParser.g" - tmp41_AST->setType(ENDBLOCK); -#line 705 "MDParser.cpp" +#line 193 "MDParser.g" + tmp62_AST->setType(ENDBLOCK); +#line 1010 "MDParser.cpp" rigidbodyblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = rigidbodyblock_AST; } @@ -717,9 +1022,9 @@ void MDParser::cutoffgroupblock() { ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp42_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp42_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp63_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp63_AST); match(CUTOFFGROUP); { switch ( LA(1)) { @@ -748,24 +1053,24 @@ void MDParser::cutoffgroupblock() { astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop43; + goto _loop60; } } - _loop43:; + _loop60:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp46_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp46_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp67_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp67_AST); match(RCURLY); -#line 121 "MDParser.g" - tmp46_AST->setType(ENDBLOCK); -#line 764 "MDParser.cpp" +#line 200 "MDParser.g" + tmp67_AST->setType(ENDBLOCK); +#line 1069 "MDParser.cpp" cutoffgroupblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = cutoffgroupblock_AST; } @@ -776,9 +1081,9 @@ void MDParser::fragmentblock() { ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp47_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp47_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp68_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp68_AST); match(FRAGMENT); match(LBRACKET); intConst(); @@ -792,73 +1097,85 @@ void MDParser::fragmentblock() { astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop47; + goto _loop64; } } - _loop47:; + _loop64:; } // ( ... )* - ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp51_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp51_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp72_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp72_AST); match(RCURLY); -#line 128 "MDParser.g" - tmp51_AST->setType(ENDBLOCK); -#line 808 "MDParser.cpp" +#line 207 "MDParser.g" + tmp72_AST->setType(ENDBLOCK); +#line 1113 "MDParser.cpp" fragmentblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_7); + recover(ex,_tokenSet_8); } returnAST = fragmentblock_AST; } -void MDParser::intConst() { +void MDParser::constraintblock() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; - ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling + ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp73_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp73_AST); + match(CONSTRAINT); + { switch ( LA(1)) { - case OCTALINT: + case LBRACKET: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp52_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp52_AST); - match(OCTALINT); - intConst_AST = currentAST.root; + match(LBRACKET); + intConst(); + match(RBRACKET); break; } - case DECIMALINT: + case LCURLY: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp53_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp53_AST); - match(DECIMALINT); - intConst_AST = currentAST.root; break; } - case HEXADECIMALINT: - { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp54_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp54_AST); - match(HEXADECIMALINT); - intConst_AST = currentAST.root; - break; - } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } + } + match(LCURLY); + { // ( ... )* + for (;;) { + if ((LA(1) == MEMBERS || LA(1) == ID)) { + constraintstatement(); + astFactory->addASTChild( currentAST, returnAST ); + } + else { + goto _loop69; + } + + } + _loop69:; + } // ( ... )* + ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp77_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, tmp77_AST); + match(RCURLY); +#line 213 "MDParser.g" + tmp77_AST->setType(ENDBLOCK); +#line 1172 "MDParser.cpp" + constraintblock_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_9); + recover(ex,_tokenSet_8); } - returnAST = intConst_AST; + returnAST = constraintblock_AST; } void MDParser::atomstatement() { @@ -877,12 +1194,12 @@ void MDParser::atomstatement() { } case POSITION: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp55_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp55_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp78_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp78_AST); match(POSITION); match(LPAREN); - signedNumberTuple(); + doubleNumberTuple(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); @@ -891,18 +1208,32 @@ void MDParser::atomstatement() { } case ORIENTATION: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp59_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp59_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp82_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp82_AST); match(ORIENTATION); match(LPAREN); - signedNumberTuple(); + doubleNumberTuple(); astFactory->addASTChild( currentAST, returnAST ); match(RPAREN); match(SEMICOLON); atomstatement_AST = currentAST.root; break; } + case CHARGE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp86_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp86_AST); + match(CHARGE); + match(LPAREN); + floatConst(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + atomstatement_AST = currentAST.root; + break; + } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); @@ -911,40 +1242,40 @@ void MDParser::atomstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_10); + recover(ex,_tokenSet_14); } returnAST = atomstatement_AST; } -void MDParser::signedNumberTuple() { +void MDParser::doubleNumberTuple() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; - ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling - signedNumber(); + doubleNumber(); astFactory->addASTChild( currentAST, returnAST ); { // ( ... )* for (;;) { if ((LA(1) == COMMA)) { match(COMMA); - signedNumber(); + doubleNumber(); astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop51; + goto _loop73; } } - _loop51:; + _loop73:; } // ( ... )* - signedNumberTuple_AST = currentAST.root; + doubleNumberTuple_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_11); + recover(ex,_tokenSet_15); } - returnAST = signedNumberTuple_AST; + returnAST = doubleNumberTuple_AST; } void MDParser::bondstatement() { @@ -963,9 +1294,9 @@ void MDParser::bondstatement() { } case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp64_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp64_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp91_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp91_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp91_AST); match(MEMBERS); match(LPAREN); inttuple(); @@ -975,6 +1306,90 @@ void MDParser::bondstatement() { bondstatement_AST = currentAST.root; break; } + case FIXED: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp95_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp95_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp95_AST); + match(FIXED); + match(LPAREN); + floatConst(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } + case HARMONIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp99_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp99_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp99_AST); + match(HARMONIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } + case CUBIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp103_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp103_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp103_AST); + match(CUBIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } + case QUARTIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp107_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp107_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp107_AST); + match(QUARTIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } + case POLYNOMIAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp111_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp111_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp111_AST); + match(POLYNOMIAL); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } + case MORSE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp115_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp115_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp115_AST); + match(MORSE); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bondstatement_AST = currentAST.root; + break; + } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); @@ -983,7 +1398,7 @@ void MDParser::bondstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_12); + recover(ex,_tokenSet_16); } returnAST = bondstatement_AST; } @@ -1004,17 +1419,17 @@ void MDParser::inttuple() { astFactory->addASTChild( currentAST, returnAST ); } else { - goto _loop54; + goto _loop76; } } - _loop54:; + _loop76:; } // ( ... )* inttuple_AST = currentAST.root; } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_11); + recover(ex,_tokenSet_15); } returnAST = inttuple_AST; } @@ -1035,9 +1450,9 @@ void MDParser::bendstatement() { } case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp69_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp69_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp120_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp120_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp120_AST); match(MEMBERS); match(LPAREN); inttuple(); @@ -1047,6 +1462,104 @@ void MDParser::bendstatement() { bendstatement_AST = currentAST.root; break; } + case HARMONIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp124_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp124_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp124_AST); + match(HARMONIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case GHOSTBEND: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp128_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp128_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp128_AST); + match(GHOSTBEND); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case UREYBRADLEY: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp132_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp132_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp132_AST); + match(UREYBRADLEY); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case CUBIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp136_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp136_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp136_AST); + match(CUBIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case QUARTIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp140_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp140_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp140_AST); + match(QUARTIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case POLYNOMIAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp144_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp144_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp144_AST); + match(POLYNOMIAL); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } + case COSINE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp148_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp148_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp148_AST); + match(COSINE); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + bendstatement_AST = currentAST.root; + break; + } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); @@ -1055,7 +1568,7 @@ void MDParser::bendstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_12); + recover(ex,_tokenSet_17); } returnAST = bendstatement_AST; } @@ -1076,9 +1589,9 @@ void MDParser::torsionstatement() { } case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp73_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp73_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp152_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp152_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp152_AST); match(MEMBERS); match(LPAREN); inttuple(); @@ -1088,6 +1601,118 @@ void MDParser::torsionstatement() { torsionstatement_AST = currentAST.root; break; } + case GHOSTTORSION: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp156_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp156_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp156_AST); + match(GHOSTTORSION); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case CUBIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp160_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp160_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp160_AST); + match(CUBIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case QUARTIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp164_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp164_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp164_AST); + match(QUARTIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case POLYNOMIAL: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp168_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp168_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp168_AST); + match(POLYNOMIAL); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case CHARMM: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp172_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp172_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp172_AST); + match(CHARMM); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case OPLS: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp176_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp176_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp176_AST); + match(OPLS); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case TRAPPE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp180_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp180_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp180_AST); + match(TRAPPE); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } + case HARMONIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp184_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp184_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp184_AST); + match(HARMONIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + torsionstatement_AST = currentAST.root; + break; + } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); @@ -1096,11 +1721,136 @@ void MDParser::torsionstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_12); + recover(ex,_tokenSet_18); } returnAST = torsionstatement_AST; } +void MDParser::inversionstatement() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + switch ( LA(1)) { + case ID: + { + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + inversionstatement_AST = currentAST.root; + break; + } + case CENTER: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp188_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp188_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp188_AST); + match(CENTER); + match(LPAREN); + intConst(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case SATELLITES: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp192_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp192_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp192_AST); + match(SATELLITES); + match(LPAREN); + inttuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case AMBERIMPROPER: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp196_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp196_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp196_AST); + match(AMBERIMPROPER); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case IMPROPERCOSINE: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp200_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp200_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp200_AST); + match(IMPROPERCOSINE); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case HARMONIC: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp204_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp204_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp204_AST); + match(HARMONIC); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case CENTRALATOMHEIGHT: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp208_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp208_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp208_AST); + match(CENTRALATOMHEIGHT); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + case DREIDING: + { + ANTLR_USE_NAMESPACE(antlr)RefAST tmp212_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp212_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp212_AST); + match(DREIDING); + match(LPAREN); + doubleNumberTuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + inversionstatement_AST = currentAST.root; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_19); + } + returnAST = inversionstatement_AST; +} + void MDParser::rigidbodystatement() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; @@ -1117,9 +1867,9 @@ void MDParser::rigidbodystatement() { } case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp77_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp77_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp216_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp216_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp216_AST); match(MEMBERS); match(LPAREN); inttuple(); @@ -1137,7 +1887,7 @@ void MDParser::rigidbodystatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_12); + recover(ex,_tokenSet_20); } returnAST = rigidbodystatement_AST; } @@ -1158,9 +1908,9 @@ void MDParser::cutoffgroupstatement() { } case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp81_AST = astFactory->create(LT(1)); - astFactory->makeASTRoot(currentAST, tmp81_AST); + ANTLR_USE_NAMESPACE(antlr)RefAST tmp220_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp220_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp220_AST); match(MEMBERS); match(LPAREN); inttuple(); @@ -1178,7 +1928,7 @@ void MDParser::cutoffgroupstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_12); + recover(ex,_tokenSet_20); } returnAST = cutoffgroupstatement_AST; } @@ -1195,34 +1945,37 @@ void MDParser::fragmentstatement() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_13); + recover(ex,_tokenSet_21); } returnAST = fragmentstatement_AST; } -void MDParser::floatConst() { +void MDParser::constraintstatement() { returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; - ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; try { // for error handling switch ( LA(1)) { - case FLOATONE: + case ID: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp85_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp85_AST); - match(FLOATONE); - floatConst_AST = currentAST.root; + assignment(); + astFactory->addASTChild( currentAST, returnAST ); + constraintstatement_AST = currentAST.root; break; } - case FLOATTWO: + case MEMBERS: { - ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; - tmp86_AST = astFactory->create(LT(1)); - astFactory->addASTChild(currentAST, tmp86_AST); - match(FLOATTWO); - floatConst_AST = currentAST.root; + ANTLR_USE_NAMESPACE(antlr)RefAST tmp224_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + tmp224_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, tmp224_AST); + match(MEMBERS); + match(LPAREN); + inttuple(); + astFactory->addASTChild( currentAST, returnAST ); + match(RPAREN); + match(SEMICOLON); + constraintstatement_AST = currentAST.root; break; } default: @@ -1233,14 +1986,51 @@ void MDParser::floatConst() { } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { reportError(ex); - recover(ex,_tokenSet_6); + recover(ex,_tokenSet_20); } - returnAST = floatConst_AST; + returnAST = constraintstatement_AST; } +void MDParser::doubleNumber() { + returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; + + try { // for error handling + { + switch ( LA(1)) { + case NUM_INT: + case NUM_LONG: + { + intConst(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + case NUM_FLOAT: + case NUM_DOUBLE: + { + floatConst(); + astFactory->addASTChild( currentAST, returnAST ); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + doubleNumber_AST = currentAST.root; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + recover(ex,_tokenSet_22); + } + returnAST = doubleNumber_AST; +} + void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) { - factory.setMaxNodeType(55); + factory.setMaxNodeType(77); } const char* MDParser::tokenNames[] = { "<0>", @@ -1250,16 +2040,43 @@ const char* MDParser::tokenNames[] = { "\"component\"", "\"molecule\"", "\"zconstraint\"", + "\"restraint\"", "\"atom\"", "\"bond\"", "\"bend\"", "\"torsion\"", + "\"inversion\"", "\"rigidBody\"", "\"cutoffGroup\"", + "\"constraint\"", + "\"distance\"", "\"fragment\"", "\"members\"", + "\"center\"", + "\"satellites\"", "\"position\"", "\"orientation\"", + "\"flucQ\"", + "\"RNEMD\"", + "\"minimizer\"", + "\"Fixed\"", + "\"Harmonic\"", + "\"Cubic\"", + "\"Quartic\"", + "\"Polynomial\"", + "\"Morse\"", + "\"GhostBend\"", + "\"UreyBradley\"", + "\"Cosine\"", + "\"GhostTorsion\"", + "\"Charmm\"", + "\"Opls\"", + "\"Trappe\"", + "\"AmberImproper\"", + "\"ImproperCosine\"", + "\"CentralAtomHeight\"", + "\"Dreiding\"", + "\"charge\"", "ENDBLOCK", "ID", "ASSIGNEQUAL", @@ -1272,13 +2089,10 @@ const char* MDParser::tokenNames[] = { "LPAREN", "RPAREN", "COMMA", - "OCTALINT", - "DECIMALINT", - "HEXADECIMALINT", - "PLUS", - "MINUS", - "FLOATONE", - "FLOATTWO", + "NUM_INT", + "NUM_LONG", + "NUM_FLOAT", + "NUM_DOUBLE", "DOT", "COLON", "QUESTIONMARK", @@ -1291,62 +2105,101 @@ const char* MDParser::tokenNames[] = { "CharLiteral", "EndOfLine", "Escape", + "Vocabulary", "Digit", "Decimal", - "LongSuffix", - "UnsignedSuffix", - "FloatSuffix", - "Exponent", - "Vocabulary", - "Number", + "HEX_DIGIT", + "EXPONENT", + "FLOAT_SUFFIX", 0 }; -const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL }; -// "component" "molecule" "zconstraint" ID +const unsigned long MDParser::_tokenSet_0_data_[] = { 58720496UL, 8192UL, 0UL, 0UL }; +// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer" +// ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4); const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL }; // EOF const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4); -const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL }; -// EOF "component" "molecule" "zconstraint" ID +const unsigned long MDParser::_tokenSet_2_data_[] = { 58720498UL, 8192UL, 0UL, 0UL }; +// EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" +// "minimizer" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4); -const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL }; -// EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion" -// "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation" +const unsigned long MDParser::_tokenSet_3_data_[] = { 4294901746UL, 274431UL, 0UL, 0UL }; +// EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend" +// "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment" +// "members" "center" "satellites" "position" "orientation" "flucQ" "RNEMD" +// "minimizer" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse" +// "GhostBend" "UreyBradley" "Cosine" "GhostTorsion" "Charmm" "Opls" "Trappe" +// "AmberImproper" "ImproperCosine" "CentralAtomHeight" "Dreiding" "charge" // ID RCURLY const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4); -const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL }; -// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" -// ID +const unsigned long MDParser::_tokenSet_4_data_[] = { 196352UL, 8192UL, 0UL, 0UL }; +// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup" +// "constraint" "fragment" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4); -const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL }; +const unsigned long MDParser::_tokenSet_5_data_[] = { 0UL, 32768UL, 0UL, 0UL }; // SEMICOLON const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4); -const unsigned long MDParser::_tokenSet_6_data_[] = { 403701760UL, 0UL, 0UL, 0UL }; -// SEMICOLON RPAREN COMMA +const unsigned long MDParser::_tokenSet_6_data_[] = { 0UL, 13664256UL, 0UL, 0UL }; +// SEMICOLON RBRACKET RPAREN COMMA const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4); -const unsigned long MDParser::_tokenSet_7_data_[] = { 8667008UL, 0UL, 0UL, 0UL }; -// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" -// ID RCURLY +const unsigned long MDParser::_tokenSet_7_data_[] = { 0UL, 12615680UL, 0UL, 0UL }; +// SEMICOLON RPAREN COMMA const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4); -const unsigned long MDParser::_tokenSet_8_data_[] = { 360448UL, 0UL, 0UL, 0UL }; -// "position" "orientation" ID +const unsigned long MDParser::_tokenSet_8_data_[] = { 196352UL, 270336UL, 0UL, 0UL }; +// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup" +// "constraint" "fragment" ID RCURLY const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4); -const unsigned long MDParser::_tokenSet_9_data_[] = { 437256192UL, 0UL, 0UL, 0UL }; -// SEMICOLON RBRACKET RPAREN COMMA +const unsigned long MDParser::_tokenSet_9_data_[] = { 6291456UL, 10240UL, 0UL, 0UL }; +// "position" "orientation" "charge" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4); -const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL }; -// "position" "orientation" ID RCURLY +const unsigned long MDParser::_tokenSet_10_data_[] = { 4228120576UL, 8192UL, 0UL, 0UL }; +// "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse" +// ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4); -const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL }; -// RPAREN +const unsigned long MDParser::_tokenSet_11_data_[] = { 2013528064UL, 8199UL, 0UL, 0UL }; +// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley" +// "Cosine" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4); -const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL }; -// "members" ID RCURLY +const unsigned long MDParser::_tokenSet_12_data_[] = { 2013528064UL, 8312UL, 0UL, 0UL }; +// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm" +// "Opls" "Trappe" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4); -const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL }; -// ID RCURLY +const unsigned long MDParser::_tokenSet_13_data_[] = { 135790592UL, 10112UL, 0UL, 0UL }; +// "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight" +// "Dreiding" ID const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4); +const unsigned long MDParser::_tokenSet_14_data_[] = { 6291456UL, 272384UL, 0UL, 0UL }; +// "position" "orientation" "charge" ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4); +const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 4194304UL, 0UL, 0UL }; +// RPAREN +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4); +const unsigned long MDParser::_tokenSet_16_data_[] = { 4228120576UL, 270336UL, 0UL, 0UL }; +// "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse" +// ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4); +const unsigned long MDParser::_tokenSet_17_data_[] = { 2013528064UL, 270343UL, 0UL, 0UL }; +// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley" +// "Cosine" ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_17(_tokenSet_17_data_,4); +const unsigned long MDParser::_tokenSet_18_data_[] = { 2013528064UL, 270456UL, 0UL, 0UL }; +// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm" +// "Opls" "Trappe" ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_18(_tokenSet_18_data_,4); +const unsigned long MDParser::_tokenSet_19_data_[] = { 135790592UL, 272256UL, 0UL, 0UL }; +// "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight" +// "Dreiding" ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_19(_tokenSet_19_data_,4); +const unsigned long MDParser::_tokenSet_20_data_[] = { 262144UL, 270336UL, 0UL, 0UL }; +// "members" ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_20(_tokenSet_20_data_,4); +const unsigned long MDParser::_tokenSet_21_data_[] = { 0UL, 270336UL, 0UL, 0UL }; +// ID RCURLY +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_21(_tokenSet_21_data_,4); +const unsigned long MDParser::_tokenSet_22_data_[] = { 0UL, 12582912UL, 0UL, 0UL }; +// RPAREN COMMA +const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_22(_tokenSet_22_data_,4);