ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/mdParser/MDTreeParser.g

Comparing trunk/src/mdParser/MDTreeParser.g (file contents):
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 2062 by gezelter, Tue Mar 3 16:40:39 2015 UTC

#	Line 4 | Line 4 | using namespace std;
4		#include "io/Globals.hpp"
5		#include "utils/StringUtils.hpp"
6		using namespace std;
7	<	using namespace oopse;
7	>	using namespace OpenMD;
8		}
9		options
10	<	{
11	<	language = "Cpp";
12	<	}
13	<
10	>	{
11	>	language = "Cpp";
12	>	}
13	>
14		class MDTreeParser extends TreeParser;
15
16		options
17		{
18	<	k = 3;
19	<	importVocab = MD;
18	>	k = 1;
19	>	importVocab = MD;
20		}
21		{
22	<	public:
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;
25	>	currConf = new Globals;
26	>	blockStack.push(currConf);
27	>	mdfile(tree);
28	>	return currConf;
29		}
30	<	private:
30	>	private:
31		Globals* currConf;
32		stack<DataHolder*> blockStack;
33		}
34		mdfile  : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35	<	;
35	>	;
36
37		statement : assignment
38	<	| componentblock
39	<	| moleculeblock
40	<	| zconstraintblock
41	<	;
38	>	| componentblock
39	>	| moleculeblock
40	>	| zconstraintblock
41	>	| restraintblock
42	>	| flucqblock
43	>	| rnemdblock
44	>	| minimizerblock
45	>	;
46
43	–
47		assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
48	<	;
49	<
48	>	;
49	>
50		constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
51		{
52	<	int ival;
53	<	RealType dval;
52	>	int ival;
53	>	RealType dval;
54	>	std::vector<RealType> dvec;
55		}
56	<	: 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	<	;
64	<
56	>	: 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	>	| #(LPAREN dvec=doubleNumberTuple RPAREN)
64	>	{
65	>	blockStack.top()->assign(id->getText(), dvec);
66	>	}
67	>	;
68
69	+
70		componentblock  : #(COMPONENT  {Component* currComponet = new Component(); blockStack.push(currComponet);}
71	<	(assignment)*
72	<	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
73	<	;
74	<
71	>	(assignment)*
72	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
73	>	;
74	>
75		zconstraintblock  : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
76	<	(assignment)*
77	<	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
78	<	;
79	<
76	>	(assignment)*
77	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
78	>	;
79	>
80	>	restraintblock  : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
81	>	(assignment)*
82	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
83	>	;
84	>
85	>	flucqblock  : #(FLUCQ  {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
86	>	(assignment)*
87	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
88	>	;
89	>
90	>	rnemdblock  : #(RNEMD  {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
91	>	(assignment)*
92	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
93	>	;
94	>
95	>	minimizerblock  : #(MINIMIZER  {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
96	>	(assignment)*
97	>	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
98	>	;
99	>
100	>
101		moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
102	<	(moleculestatement)*
103	<	ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
104	<	;
102	>	(moleculestatement)*
103	>	ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
104	>	;
105
106		moleculestatement : assignment
107	<	| atomblock
108	<	| bondblock
109	<	| bendblock
110	<	| torsionblock
111	<	| rigidbodyblock
112	<	| cutoffgroupblock
113	<	| fragmentblock
114	<	;
107	>	| atomblock
108	>	| bondblock
109	>	| bendblock
110	>	| torsionblock
111	>	| inversionblock
112	>	| rigidbodyblock
113	>	| cutoffgroupblock
114	>	| fragmentblock
115	>	| constraintblock
116	>	;
117
118		atomblock
119		{
120	<	int index;
120	>	int index;
121		}
122	<	: #(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	<	;
122	>	: #(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
132		atomstatement
133		{
134	<	vector<RealType> dvec;
135	<	AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
136	<
134	>	vector<RealType> dvec;
135	>	RealType rval;
136	>	AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
137	>
138		}
139	<	: assignment
140	<	| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
141	<	| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
142	<	;
139	>	: assignment
140	>	| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
141	>	| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
142	>	| #(CHARGE rval=doubleNumber) {currAtomStamp->overrideCharge(rval);}
143	>	;
144
112	–
113	–	bondblock : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
114	–	(bondstatement)*
115	–	ENDBLOCK )  {
116	–	blockStack.pop();
117	–	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
118	–	currMoleculeStamp->addBondStamp(currBondStamp);
119	–	}
120	–	;
145
146	+	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		bondstatement
158		{
159	<	vector<int> ivec;
160	<	BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
159	>	vector<int> ivec;
160	>	RealType rval;
161	>	vector<RealType> dvec;
162	>	BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
163		}
164	<	: assignment
165	<	| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
166	<	;
164	>	: 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
174		bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
175		(bendstatement)*
176		ENDBLOCK)  {
177	<	blockStack.top()->validate();
178	<	blockStack.pop();
179	<	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
180	<	currMoleculeStamp->addBendStamp(currBendStamp);
181	<	}
182	<	;
183	<
177	>	blockStack.top()->validate();
178	>	blockStack.pop();
179	>	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
180	>	currMoleculeStamp->addBendStamp(currBendStamp);
181	>	}
182	>	;
183	>
184		bendstatement
185		{
186	<	vector<int> ivec;
187	<	BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
186	>	vector<int> ivec;
187	>	vector<RealType> dvec;
188	>	BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
189		}
190	<	: assignment
191	<	| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
190	>	: 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		;
200
201		torsionblock  : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
#	Line 160 | Line 211 | torsionstatement
211		torsionstatement
212		{
213		vector<int> ivec;
214	+	vector<RealType> dvec;
215		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
216		}
217		: assignment
218	<	| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
218	>	| #(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		;
229
230	+	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	+	vector<int> ivec;
244	+	vector<RealType> dvec;
245	+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
246	+	}
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	+	;
257	+
258		rigidbodyblock
259		{
260		int index;
#	Line 220 | Line 309 | fragmentstatement : assignment
309		;
310
311		fragmentstatement : assignment
312	<	;
312	>	;
313
314	+	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
323	<
227	<	doubleNumberTuple   returns [vector<RealType> dvec]
323	>	constraintstatement
324		{
325	<	RealType dval;
325	>	vector<int> ivec;
326	>	ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
327		}
328	<	: (dval=doubleNumber {dvec.push_back(dval);})+
328	>	: assignment
329	>	| #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
330		;
331	<
332	<	inttuple  returns [vector<int> ivec]
331	>
332	>
333	>	doubleNumberTuple returns [vector<RealType> dvec]
334		{
335	<	int ival;
335	>	RealType dval;
336	>	}
337	>	: (dval=doubleNumber {dvec.push_back(dval);})+
338	>	;
339	>
340	>
341	>	inttuple returns [vector<int> ivec]
342	>	{
343	>	int ival;
344		}
345	<	: (ival=intConst {ivec.push_back(ival);})+
346	<	;
345	>	: (ival=intConst {ivec.push_back(ival);})+
346	>	;
347
348		protected
349		intConst returns [int ival]
350	<	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
351	<	| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
352	<	;
350	>	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
351	>	| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
352	>	;
353
354		protected
355	<	doubleNumber  returns [RealType dval]
356	<	:
357	<	ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
358	<	| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
252	<
253	<	;
355	>	doubleNumber returns [RealType dval]
356	>	: ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
357	>	| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
358	>	;
359
360		protected
361		floatConst returns [RealType dval]
362	<	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
363	<	| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
364	<	;
365	<
362	>	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
363	>	| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
364	>	;
365	>

Comparing trunk/src/mdParser/MDTreeParser.g (property svn:keywords):
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 2062 by gezelter, Tue Mar 3 16:40:39 2015 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines