src/mdParser/MDTreeParser.g

header
{
#include <stack>
#include "io/Globals.hpp"
#include "utils/StringUtils.hpp"
using namespace std;
using namespace oopse;
}
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
          ;


assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
            ;
            
constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
{
  int ival;
  RealType dval;
}    
            : 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);
                                 }
            ;
            

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);}
                  ;
  
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
                  ;

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;
AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());

}
              : assignment
              | #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
              | #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
              ;

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

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

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;
  BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
              ;

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;
  TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
}  
              : assignment
              | #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
              ;

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;
  InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
}  
              : assignment
              | #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
              ;

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
              ;


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:	1360
Committed:	Mon Sep 7 16:31:51 2009 UTC (15 years, 8 months ago) by cli2
Original Path:	*trunk/src/mdParser/MDTreeParser.g*
File size:	10802 byte(s)
Log Message:	Added new restraint infrastructure Added MolecularRestraints Added ObjectRestraints Added RestraintStamp Updated thermodynamic integration to use ObjectRestraints Added Quaternion mathematics for twist swing decompositions Significantly updated RestWriter and RestReader to use dump-like files Added selections for x, y, and z coordinates of atoms Removed monolithic Restraints class Fixed a few bugs in gradients of Euler angles in DirectionalAtom and RigidBody Added some rotational capabilities to prinicpalAxisCalculator
#	Content
1	header
2	{
3	#include <stack>
4	#include "io/Globals.hpp"
5	#include "utils/StringUtils.hpp"
6	using namespace std;
7	using namespace oopse;
8	}
9	options
10	{
11	language = "Cpp";
12	}
13
14	class MDTreeParser extends TreeParser;
15
16	options
17	{
18	k = 1;
19	importVocab = MD;
20	}
21	{
22	public:
23	Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
24	{
25	currConf = new Globals;
26	blockStack.push(currConf);
27	mdfile(tree);
28	return currConf;
29	}
30	private:
31	Globals* currConf;
32	stack<DataHolder*> blockStack;
33	}
34	mdfile : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35	;
36
37	statement : assignment
38	\| componentblock
39	\| moleculeblock
40	\| zconstraintblock
41	\| restraintblock
42	;
43
44
45	assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
46	;
47
48	constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
49	{
50	int ival;
51	RealType dval;
52	}
53	: ival=intConst {blockStack.top()->assign(id->getText(), ival);}
54	\| dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
55	\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
56	\| str2:StringLiteral { std::string s = str2->getText();
57	s = s.substr(1, s.length()-2);
58	blockStack.top()->assign(id->getText(),s);
59	}
60	;
61
62
63	componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
64	(assignment)*
65	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
66	;
67
68	zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
69	(assignment)*
70	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
71	;
72
73	restraintblock : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
74	(assignment)*
75	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
76	;
77
78	moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
79	(moleculestatement)*
80	ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
81	;
82
83	moleculestatement : assignment
84	\| atomblock
85	\| bondblock
86	\| bendblock
87	\| torsionblock
88	\| inversionblock
89	\| rigidbodyblock
90	\| cutoffgroupblock
91	\| fragmentblock
92	;
93
94	atomblock
95	{
96	int index;
97	}
98	: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
99	(atomstatement)*
100	ENDBLOCK ) {
101	blockStack.top()->validate();
102	blockStack.pop();
103	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
104	currMoleculeStamp->addAtomStamp(currAtomStamp);
105	}
106	;
107
108	atomstatement
109	{
110	vector<RealType> dvec;
111	AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
112
113	}
114	: assignment
115	\| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
116	\| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
117	;
118
119
120	bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
121	(bondstatement)*
122	ENDBLOCK ) {
123	blockStack.pop();
124	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
125	currMoleculeStamp->addBondStamp(currBondStamp);
126	}
127	;
128
129	bondstatement
130	{
131	vector<int> ivec;
132	BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
133	}
134	: assignment
135	\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
136	;
137
138	bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
139	(bendstatement)*
140	ENDBLOCK) {
141	blockStack.top()->validate();
142	blockStack.pop();
143	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
144	currMoleculeStamp->addBendStamp(currBendStamp);
145	}
146	;
147
148	bendstatement
149	{
150	vector<int> ivec;
151	BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
152	}
153	: assignment
154	\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
155	;
156
157	torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
158	(torsionstatement)*
159	ENDBLOCK ) {
160	blockStack.top()->validate();
161	blockStack.pop();
162	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
163	currMoleculeStamp->addTorsionStamp(currTorsionStamp);
164	}
165	;
166
167	torsionstatement
168	{
169	vector<int> ivec;
170	TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
171	}
172	: assignment
173	\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
174	;
175
176	inversionblock : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
177	(inversionstatement)*
178	ENDBLOCK ) {
179	blockStack.top()->validate();
180	blockStack.pop();
181	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
182	currMoleculeStamp->addInversionStamp(currInversionStamp);
183	}
184	;
185
186	inversionstatement
187	{
188	int icent;
189	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
190	}
191	: assignment
192	\| #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
193	;
194
195	rigidbodyblock
196	{
197	int index;
198	}
199	: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
200	(rigidbodystatement)*
201	ENDBLOCK ) {
202	blockStack.top()->validate();
203	blockStack.pop();
204	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
205	currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
206	}
207	;
208
209	rigidbodystatement
210	{
211	vector<int> ivec;
212	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
213	}
214	: assignment
215	\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
216	;
217
218	cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
219	(cutoffgroupstatement)*
220	ENDBLOCK ) {
221	blockStack.top()->validate();
222	blockStack.pop();
223	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
224	currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
225	}
226	;
227
228	cutoffgroupstatement
229	{
230	vector<int> ivec;
231	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
232	}
233	: assignment
234	\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
235	;
236
237	fragmentblock {int ival;}
238	: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
239	(fragmentstatement)*
240	ENDBLOCK) {
241	blockStack.top()->validate();
242	blockStack.pop();
243	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
244	currMoleculeStamp->addFragmentStamp(currFragmentStamp);
245	}
246	;
247
248	fragmentstatement : assignment
249	;
250
251
252
253	doubleNumberTuple returns [vector<RealType> dvec]
254	{
255	RealType dval;
256	}
257	: (dval=doubleNumber {dvec.push_back(dval);})+
258	;
259
260	inttuple returns [vector<int> ivec]
261	{
262	int ival;
263	}
264	: (ival=intConst {ivec.push_back(ival);})+
265	;
266
267	protected
268	intConst returns [int ival]
269	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
270	\| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
271	;
272
273	protected
274	doubleNumber returns [RealType dval]
275	:
276	ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
277	\| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
278
279	;
280
281	protected
282	floatConst returns [RealType dval]
283	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
284	\| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
285	;
286