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
    ;

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


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:	1731
Committed:	Thu May 31 12:25:30 2012 UTC (12 years, 11 months ago) by gezelter
File size:	11425 byte(s)
Log Message:	Reorganized source directories, added RNEMD and flucQ blocks for options parsing.
#	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			{
11			language = "Cpp";
12			}
13
14			class MDTreeParser extends TreeParser;
15
16			options
17			{
18	gezelter	1277	k = 1;
19	tim	770	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	gezelter	1731	\| componentblock
39			\| moleculeblock
40			\| zconstraintblock
41			\| restraintblock
42			\| flucqblock
43			\| rnemdblock
44			;
45	tim	770
46			assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
47			;
48
49	tim	814	constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
50			{
51			int ival;
52	tim	963	RealType dval;
53	tim	814	}
54			: ival=intConst {blockStack.top()->assign(id->getText(), ival);}
55			\| dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
56	tim	770	\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
57			\| str2:StringLiteral { std::string s = str2->getText();
58			s = s.substr(1, s.length()-2);
59			blockStack.top()->assign(id->getText(),s);
60			}
61			;
62
63
64			componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
65			(assignment)*
66			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
67			;
68
69			zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
70			(assignment)*
71			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
72			;
73	cli2	1360
74			restraintblock : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
75			(assignment)*
76			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
77			;
78	tim	770
79	gezelter	1731	flucqblock : #(FLUCQ {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
80			(assignment)*
81			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
82			;
83
84			rnemdblock : #(RNEMD {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
85			(assignment)*
86			ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
87			;
88
89
90	tim	770	moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
91			(moleculestatement)*
92			ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
93			;
94
95			moleculestatement : assignment
96			\| atomblock
97			\| bondblock
98			\| bendblock
99			\| torsionblock
100	cli2	1275	\| inversionblock
101	tim	770	\| rigidbodyblock
102			\| cutoffgroupblock
103			\| fragmentblock
104			;
105
106			atomblock
107			{
108			int index;
109			}
110			: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
111			(atomstatement)*
112			ENDBLOCK ) {
113			blockStack.top()->validate();
114			blockStack.pop();
115			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
116			currMoleculeStamp->addAtomStamp(currAtomStamp);
117			}
118			;
119
120			atomstatement
121			{
122	tim	963	vector<RealType> dvec;
123	tim	770	AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
124
125			}
126			: assignment
127	tim	814	\| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
128			\| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
129	tim	770	;
130
131
132			bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
133			(bondstatement)*
134			ENDBLOCK ) {
135			blockStack.pop();
136			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
137			currMoleculeStamp->addBondStamp(currBondStamp);
138			}
139			;
140
141			bondstatement
142			{
143			vector<int> ivec;
144			BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
145			}
146			: assignment
147			\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
148			;
149
150			bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
151			(bendstatement)*
152			ENDBLOCK) {
153			blockStack.top()->validate();
154			blockStack.pop();
155			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
156			currMoleculeStamp->addBendStamp(currBendStamp);
157			}
158			;
159
160			bendstatement
161			{
162			vector<int> ivec;
163			BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
164			}
165			: assignment
166			\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
167			;
168
169			torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
170			(torsionstatement)*
171			ENDBLOCK ) {
172			blockStack.top()->validate();
173			blockStack.pop();
174			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
175			currMoleculeStamp->addTorsionStamp(currTorsionStamp);
176			}
177			;
178
179			torsionstatement
180			{
181			vector<int> ivec;
182			TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
183			}
184			: assignment
185			\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
186			;
187
188	cli2	1275	inversionblock : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
189			(inversionstatement)*
190			ENDBLOCK ) {
191			blockStack.top()->validate();
192			blockStack.pop();
193			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
194			currMoleculeStamp->addInversionStamp(currInversionStamp);
195			}
196			;
197
198			inversionstatement
199			{
200			int icent;
201			InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
202			}
203			: assignment
204			\| #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
205			;
206
207	tim	770	rigidbodyblock
208			{
209			int index;
210			}
211			: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
212			(rigidbodystatement)*
213			ENDBLOCK ) {
214			blockStack.top()->validate();
215			blockStack.pop();
216			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
217			currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
218			}
219			;
220
221			rigidbodystatement
222			{
223			vector<int> ivec;
224			RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
225			}
226			: assignment
227			\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
228			;
229
230			cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
231			(cutoffgroupstatement)*
232			ENDBLOCK ) {
233			blockStack.top()->validate();
234			blockStack.pop();
235			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
236			currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
237			}
238			;
239
240			cutoffgroupstatement
241			{
242			vector<int> ivec;
243			CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
244			}
245			: assignment
246			\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
247			;
248
249			fragmentblock {int ival;}
250			: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
251			(fragmentstatement)*
252			ENDBLOCK) {
253			blockStack.top()->validate();
254			blockStack.pop();
255			MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
256			currMoleculeStamp->addFragmentStamp(currFragmentStamp);
257			}
258			;
259
260			fragmentstatement : assignment
261			;
262
263
264
265	tim	963	doubleNumberTuple returns [vector<RealType> dvec]
266	tim	770	{
267	tim	963	RealType dval;
268	tim	770	}
269	tim	814	: (dval=doubleNumber {dvec.push_back(dval);})+
270	tim	770	;
271
272			inttuple returns [vector<int> ivec]
273			{
274			int ival;
275			}
276			: (ival=intConst {ivec.push_back(ival);})+
277			;
278
279			protected
280			intConst returns [int ival]
281	tim	814	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
282			\| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
283	tim	770	;
284
285			protected
286	tim	963	doubleNumber returns [RealType dval]
287	tim	810	:
288	tim	963	ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
289			\| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
290	tim	810
291	tim	770	;
292
293			protected
294	tim	963	floatConst returns [RealType dval]
295			: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
296			\| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
297	tim	770	;
298	tim	810