src/mdParser/MDTreeParser.g

header
{
#include <stack>
#include "io/Globals.hpp"
#include "utils/StringUtils.hpp"
using namespace std;
using namespace OpenMD;
}
options
{
    language = "Cpp";
}   

class MDTreeParser extends TreeParser;

options
{
    k = 1;
    importVocab = MD;
}
{
    public:
    Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
    {
        currConf = new Globals;
        blockStack.push(currConf);
        mdfile(tree);
        return currConf;
    }
    private:
    Globals* currConf;
    stack<DataHolder*> blockStack;    
}
mdfile  : (statement)* {blockStack.top()->validate(); blockStack.pop();}
    ;

statement : assignment
    | componentblock
    | moleculeblock
    | zconstraintblock
    | restraintblock
    | flucqblock
    | rnemdblock
    | minimizerblock
    ;

assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
    ;

constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
{
    int ival;
    RealType dval;
    std::vector<RealType> dvec;
}    
    : ival=intConst {blockStack.top()->assign(id->getText(), ival);}
    | dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
    | str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
    | str2:StringLiteral {std::string s =  str2->getText();
            s = s.substr(1, s.length()-2);
            blockStack.top()->assign(id->getText(),s);
        }
    | #(LPAREN dvec=doubleNumberTuple RPAREN) 
        { 
            blockStack.top()->assign(id->getText(), dvec);
        }
    ;


componentblock  : #(COMPONENT  {Component* currComponet = new Component(); blockStack.push(currComponet);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
    ;

zconstraintblock  : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
    ;

restraintblock  : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
    ;

flucqblock  : #(FLUCQ  {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
    ;

rnemdblock  : #(RNEMD  {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
    ;

minimizerblock  : #(MINIMIZER  {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
    ;


moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
            (moleculestatement)* 
            ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
    ;

moleculestatement : assignment
    | atomblock
    | bondblock
    | bendblock
    | torsionblock
    | inversionblock
    | rigidbodyblock
    | cutoffgroupblock
    | fragmentblock
    | constraintblock
    ;

atomblock 
{
    int index;
}
    : #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);} 
            (atomstatement)* 
            ENDBLOCK ) {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addAtomStamp(currAtomStamp); 
        }
    ;

atomstatement 
{
    vector<RealType> dvec;
    RealType rval;
    AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
    
}
    : assignment
    | #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
    | #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
    | #(CHARGE rval=doubleNumber) {currAtomStamp->overrideCharge(rval);}        
    ;


bondblock 
    : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
            (bondstatement)* 
            ENDBLOCK )  {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addBondStamp(currBondStamp); 
        }   
    ;

bondstatement 
{
    vector<int> ivec;
    RealType rval;
    vector<RealType> dvec;
    BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
}
    : assignment
    | #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
    | #(FIXED rval=doubleNumber) {currBondStamp->overrideType("Fixed", rval);}
    | #(HARMONIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Harmonic", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currBondStamp->overrideType("Polynomial", dvec);}
    | #(MORSE dvec=doubleNumberTuple) {currBondStamp->overrideType("Morse", dvec);}
    ;

bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
                  (bendstatement)* 
                   ENDBLOCK)  {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addBendStamp(currBendStamp); 
        }
        ;
    
bendstatement 
{
    vector<int> ivec;
    vector<RealType> dvec;
    BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
}
    : assignment
    | #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Harmonic", dvec);}
    | #(GHOSTBEND dvec=doubleNumberTuple) {currBendStamp->overrideType("GhostBend", dvec);}
    | #(UREYBRADLEY dvec=doubleNumberTuple) {currBendStamp->overrideType("UreyBradley", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currBendStamp->overrideType("Polynomial", dvec);}
    | #(COSINE dvec=doubleNumberTuple) {currBendStamp->overrideType("Cosine", dvec);}
              ;

torsionblock  : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
                   (torsionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addTorsionStamp(currTorsionStamp); 
                                }
          ;

torsionstatement
{
  vector<int> ivec;
  vector<RealType> dvec;
  TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
}  
              : assignment
    | #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
    | #(GHOSTTORSION dvec=doubleNumberTuple) {currTorsionStamp->overrideType("GhostTorsion", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Polynomial", dvec);}
    | #(CHARMM dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Charmm", dvec);}
    | #(OPLS dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Opls", dvec);}
    | #(TRAPPE dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Trappe", dvec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Harmonic", dvec);}

              ;

inversionblock  : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
                   (inversionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addInversionStamp(currInversionStamp); 
                                }
          ;

inversionstatement
{
  int icent;
  vector<int> ivec;
  vector<RealType> dvec;
  InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
}
 : assignment
    | #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
    | #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
    | #(AMBERIMPROPER dvec=doubleNumberTuple) {currInversionStamp->overrideType("AmberImproper", dvec);}
    | #(IMPROPERCOSINE dvec=doubleNumberTuple) {currInversionStamp->overrideType("ImproperCosine", dvec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currInversionStamp->overrideType("Harmonic", dvec);}
    | #(CENTRALATOMHEIGHT dvec=doubleNumberTuple) {currInversionStamp->overrideType("CentralAtomHeight", dvec);}
    | #(DREIDING dvec=doubleNumberTuple) {currInversionStamp->overrideType("Dreiding", dvec);}

              ;

rigidbodyblock
{
int index;
}
              : #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
                        (rigidbodystatement)* 
                        ENDBLOCK )  {
                                      blockStack.top()->validate();
                                      blockStack.pop(); 
                                      MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                      currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); 
                                    }
                ;

rigidbodystatement  
{
  vector<int> ivec;
  RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
              ;

cutoffgroupblock  : #(CUTOFFGROUP  {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
                          (cutoffgroupstatement)* 
                           ENDBLOCK ) {
                                        blockStack.top()->validate();
                                        blockStack.pop(); 
                                        MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                        currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); 
                                      }
                  ;

cutoffgroupstatement
{
  vector<int> ivec;
  CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
}  
              : assignment
              | #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}             
              ;

fragmentblock {int ival;}
               : #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
                      (fragmentstatement)* 
                      ENDBLOCK) {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addFragmentStamp(currFragmentStamp); 
                                }
              ;

fragmentstatement : assignment
    ;

constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
                (constraintstatement)* 
                 ENDBLOCK )  {
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addConstraintStamp(currConstraintStamp); 
                             }
          ;

constraintstatement 
{
  vector<int> ivec;
  ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
              ;

              
doubleNumberTuple returns [vector<RealType> dvec]
{
    RealType dval;
}   
    : (dval=doubleNumber {dvec.push_back(dval);})+  
    ;


inttuple returns [vector<int> ivec]
{
    int ival;
}
    : (ival=intConst {ivec.push_back(ival);})+ 
    ;

protected
intConst returns [int ival]
    : i1:NUM_INT {ival = lexi_cast<int>(i1->getText());} 
    | i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
    ;

protected
doubleNumber returns [RealType dval]
    : ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
    | fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}         
    ;
              
protected
floatConst returns [RealType dval]
    : d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}  
    | d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());} 
    ;
  
Revision:	2062
Committed:	Tue Mar 3 16:40:39 2015 UTC (10 years, 3 months ago) by gezelter
File size:	14396 byte(s)
Log Message:	Removed warnings, inlined common calls
#	User	Rev	Content
1	tim	770	header
2			{
3			#include <stack>
4			#include "io/Globals.hpp"
5			#include "utils/StringUtils.hpp"
6			using namespace std;
7	gezelter	1390	using namespace OpenMD;
8	tim	770	}
9			options
10	gezelter	2046	{
11			language = "Cpp";
12			}
13
14	tim	770	class MDTreeParser extends TreeParser;
15
16			options
17			{
18	gezelter	2046	k = 1;
19			importVocab = MD;
20	tim	770	}
21			{
22	gezelter	2046	public:
23	tim	770	Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
24			{
25	gezelter	2046	currConf = new Globals;
26			blockStack.push(currConf);
27			mdfile(tree);
28			return currConf;
29	tim	770	}
30	gezelter	2046	private:
31	tim	770	Globals* currConf;
32			stack<DataHolder*> blockStack;
33			}
34			mdfile : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35	gezelter	2046	;
36	tim	770
37			statement : assignment
38	gezelter	1782	\| componentblock
39			\| moleculeblock
40			\| zconstraintblock
41			\| restraintblock
42			\| flucqblock
43			\| rnemdblock
44			\| minimizerblock
45			;
46	tim	770
47			assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
48	gezelter	2046	;
49
50	tim	814	constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
51			{
52	gezelter	1782	int ival;
53	gezelter	2062	RealType dval;
54	gezelter	2026	std::vector<RealType> dvec;
55	tim	814	}
56	gezelter	1782	: ival=intConst {blockStack.top()->assign(id->getText(), ival);}
57			\| dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
58			\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
59			\| str2:StringLiteral {std::string s = str2->getText();
60			s = s.substr(1, s.length()-2);
61			blockStack.top()->assign(id->getText(),s);
62			}
63	gezelter	2026	\| #(LPAREN dvec=doubleNumberTuple RPAREN)
64			{
65			blockStack.top()->assign(id->getText(), dvec);
66			}
67	gezelter	1782	;
68	tim	770
69	gezelter	2046
70	tim	770	componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
71	gezelter	2046	(assignment)*
72			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
73			;
74
75	tim	770	zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
76	gezelter	2046	(assignment)*
77			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
78			;
79	cli2	1360
80			restraintblock : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
81	gezelter	2046	(assignment)*
82			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
83			;
84
85	gezelter	1782	flucqblock : #(FLUCQ {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
86	gezelter	2046	(assignment)*
87			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
88			;
89	gezelter	1782
90			rnemdblock : #(RNEMD {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
91	gezelter	2046	(assignment)*
92			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
93			;
94	gezelter	1782
95			minimizerblock : #(MINIMIZER {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
96	gezelter	2046	(assignment)*
97			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
98			;
99	gezelter	1782
100
101	tim	770	moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
102	gezelter	2046	(moleculestatement)*
103			ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
104			;
105	tim	770
106			moleculestatement : assignment
107	gezelter	2046	\| atomblock
108			\| bondblock
109			\| bendblock
110			\| torsionblock
111			\| inversionblock
112			\| rigidbodyblock
113			\| cutoffgroupblock
114			\| fragmentblock
115			\| constraintblock
116			;
117	tim	770
118			atomblock
119			{
120	gezelter	2046	int index;
121	tim	770	}
122	gezelter	2046	: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
123			(atomstatement)*
124			ENDBLOCK ) {
125			blockStack.top()->validate();
126			blockStack.pop();
127			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
128			currMoleculeStamp->addAtomStamp(currAtomStamp);
129			}
130			;
131	tim	770
132			atomstatement
133			{
134	gezelter	2046	vector<RealType> dvec;
135			RealType rval;
136			AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
137
138	tim	770	}
139	gezelter	2046	: assignment
140			\| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
141			\| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
142			\| #(CHARGE rval=doubleNumber) {currAtomStamp->overrideCharge(rval);}
143			;
144	tim	770
145
146	gezelter	2046	bondblock
147			: #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
148			(bondstatement)*
149			ENDBLOCK ) {
150			blockStack.top()->validate();
151			blockStack.pop();
152			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
153			currMoleculeStamp->addBondStamp(currBondStamp);
154			}
155			;
156
157	tim	770	bondstatement
158			{
159	gezelter	2046	vector<int> ivec;
160			RealType rval;
161			vector<RealType> dvec;
162			BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
163	tim	770	}
164	gezelter	2046	: assignment
165			\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
166			\| #(FIXED rval=doubleNumber) {currBondStamp->overrideType("Fixed", rval);}
167			\| #(HARMONIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Harmonic", dvec);}
168			\| #(CUBIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Cubic", dvec);}
169			\| #(QUARTIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Quartic", dvec);}
170			\| #(POLYNOMIAL dvec=doubleNumberTuple) {currBondStamp->overrideType("Polynomial", dvec);}
171			\| #(MORSE dvec=doubleNumberTuple) {currBondStamp->overrideType("Morse", dvec);}
172			;
173	tim	770
174			bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
175			(bendstatement)*
176			ENDBLOCK) {
177	gezelter	2046	blockStack.top()->validate();
178			blockStack.pop();
179			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
180			currMoleculeStamp->addBendStamp(currBendStamp);
181			}
182			;
183
184	tim	770	bendstatement
185			{
186	gezelter	2046	vector<int> ivec;
187			vector<RealType> dvec;
188			BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
189	tim	770	}
190	gezelter	2046	: assignment
191			\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
192			\| #(HARMONIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Harmonic", dvec);}
193			\| #(GHOSTBEND dvec=doubleNumberTuple) {currBendStamp->overrideType("GhostBend", dvec);}
194			\| #(UREYBRADLEY dvec=doubleNumberTuple) {currBendStamp->overrideType("UreyBradley", dvec);}
195			\| #(CUBIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Cubic", dvec);}
196			\| #(QUARTIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Quartic", dvec);}
197			\| #(POLYNOMIAL dvec=doubleNumberTuple) {currBendStamp->overrideType("Polynomial", dvec);}
198			\| #(COSINE dvec=doubleNumberTuple) {currBendStamp->overrideType("Cosine", dvec);}
199	tim	770	;
200
201			torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
202			(torsionstatement)*
203			ENDBLOCK ) {
204			blockStack.top()->validate();
205			blockStack.pop();
206			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
207			currMoleculeStamp->addTorsionStamp(currTorsionStamp);
208			}
209			;
210
211			torsionstatement
212			{
213			vector<int> ivec;
214	gezelter	2046	vector<RealType> dvec;
215	tim	770	TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
216			}
217			: assignment
218	gezelter	2046	\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
219			\| #(GHOSTTORSION dvec=doubleNumberTuple) {currTorsionStamp->overrideType("GhostTorsion", dvec);}
220			\| #(CUBIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Cubic", dvec);}
221			\| #(QUARTIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Quartic", dvec);}
222			\| #(POLYNOMIAL dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Polynomial", dvec);}
223			\| #(CHARMM dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Charmm", dvec);}
224			\| #(OPLS dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Opls", dvec);}
225			\| #(TRAPPE dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Trappe", dvec);}
226			\| #(HARMONIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Harmonic", dvec);}
227
228	tim	770	;
229
230	cli2	1275	inversionblock : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
231			(inversionstatement)*
232			ENDBLOCK ) {
233			blockStack.top()->validate();
234			blockStack.pop();
235			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
236			currMoleculeStamp->addInversionStamp(currInversionStamp);
237			}
238			;
239
240			inversionstatement
241			{
242			int icent;
243	gezelter	1902	vector<int> ivec;
244	gezelter	2046	vector<RealType> dvec;
245	cli2	1275	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
246	gezelter	2046	}
247			: assignment
248			\| #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
249			\| #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
250			\| #(AMBERIMPROPER dvec=doubleNumberTuple) {currInversionStamp->overrideType("AmberImproper", dvec);}
251			\| #(IMPROPERCOSINE dvec=doubleNumberTuple) {currInversionStamp->overrideType("ImproperCosine", dvec);}
252			\| #(HARMONIC dvec=doubleNumberTuple) {currInversionStamp->overrideType("Harmonic", dvec);}
253			\| #(CENTRALATOMHEIGHT dvec=doubleNumberTuple) {currInversionStamp->overrideType("CentralAtomHeight", dvec);}
254			\| #(DREIDING dvec=doubleNumberTuple) {currInversionStamp->overrideType("Dreiding", dvec);}
255
256	cli2	1275	;
257
258	tim	770	rigidbodyblock
259			{
260			int index;
261			}
262			: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
263			(rigidbodystatement)*
264			ENDBLOCK ) {
265			blockStack.top()->validate();
266			blockStack.pop();
267			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
268			currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
269			}
270			;
271
272			rigidbodystatement
273			{
274			vector<int> ivec;
275			RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
276			}
277			: assignment
278			\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
279			;
280
281			cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
282			(cutoffgroupstatement)*
283			ENDBLOCK ) {
284			blockStack.top()->validate();
285			blockStack.pop();
286			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
287			currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
288			}
289			;
290
291			cutoffgroupstatement
292			{
293			vector<int> ivec;
294			CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
295			}
296			: assignment
297			\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
298			;
299
300			fragmentblock {int ival;}
301			: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
302			(fragmentstatement)*
303			ENDBLOCK) {
304			blockStack.top()->validate();
305			blockStack.pop();
306			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
307			currMoleculeStamp->addFragmentStamp(currFragmentStamp);
308			}
309			;
310
311			fragmentstatement : assignment
312	gezelter	1782	;
313	tim	770
314	gezelter	1979	constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
315			(constraintstatement)*
316			ENDBLOCK ) {
317			blockStack.pop();
318			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
319			currMoleculeStamp->addConstraintStamp(currConstraintStamp);
320			}
321			;
322	tim	770
323	gezelter	1979	constraintstatement
324			{
325			vector<int> ivec;
326			ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
327			}
328			: assignment
329			\| #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
330			;
331
332	tim	770
333	gezelter	1782	doubleNumberTuple returns [vector<RealType> dvec]
334	tim	770	{
335	gezelter	1782	RealType dval;
336			}
337			: (dval=doubleNumber {dvec.push_back(dval);})+
338			;
339
340
341			inttuple returns [vector<int> ivec]
342	tim	770	{
343	gezelter	1782	int ival;
344	tim	770	}
345	gezelter	1782	: (ival=intConst {ivec.push_back(ival);})+
346			;
347	tim	770
348			protected
349			intConst returns [int ival]
350	gezelter	1782	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
351			\| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
352			;
353	tim	770
354			protected
355	gezelter	1782	doubleNumber returns [RealType dval]
356			: ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
357			\| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
358			;
359	tim	770
360			protected
361	tim	963	floatConst returns [RealType dval]
362	gezelter	1782	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
363			\| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
364			;
365