ViewVC Help

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

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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20141024): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2		#include "MDTreeParser.hpp"
3		#include <antlr/Token.hpp>
4		#include <antlr/AST.hpp>
#	Line 13 | Line 13 | void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)Re
13		}
14
15		void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
16	<	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
16	>	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
17
18		try {      // for error handling
19		{ // ( ... )*
#	Line 44 | Line 44 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
44		}
45
46		void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
47	<	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
47	>	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
48
49		try {      // for error handling
50		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 74 | Line 74 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
74		_t = _retTree;
75		break;
76		}
77	+	case RESTRAINT:
78	+	{
79	+	restraintblock(_t);
80	+	_t = _retTree;
81	+	break;
82	+	}
83	+	case FLUCQ:
84	+	{
85	+	flucqblock(_t);
86	+	_t = _retTree;
87	+	break;
88	+	}
89	+	case RNEMD:
90	+	{
91	+	rnemdblock(_t);
92	+	_t = _retTree;
93	+	break;
94	+	}
95	+	case MINIMIZER:
96	+	{
97	+	minimizerblock(_t);
98	+	_t = _retTree;
99	+	break;
100	+	}
101		default:
102		{
103		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 89 | Line 113 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl
113		}
114
115		void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
116	<	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
116	>	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
117		ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
118
119		try {      // for error handling
#	Line 114 | Line 138 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
138		}
139
140		void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
141	<	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
141	>	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
142
143		try {      // for error handling
144	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
144	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
145		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146		match(_t,COMPONENT);
147		_t = _t->getFirstChild();
148	<	#line 62 "MDTreeParser.g"
148	>	#line 70 "MDTreeParser.g"
149		Component* currComponet = new Component(); blockStack.push(currComponet);
150	<	#line 127 "MDTreeParser.cpp"
150	>	#line 151 "MDTreeParser.cpp"
151		{ // ( ... )*
152		for (;;) {
153		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 133 | Line 157 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
157		_t = _retTree;
158		}
159		else {
160	<	goto _loop11;
160	>	goto _loop12;
161		}
162
163		}
164	<	_loop11:;
164	>	_loop12:;
165		} // ( ... )*
166		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167		match(_t,ENDBLOCK);
168		_t = _t->getNextSibling();
169	<	_t = __t9;
169	>	_t = __t10;
170		_t = _t->getNextSibling();
171	<	#line 64 "MDTreeParser.g"
171	>	#line 72 "MDTreeParser.g"
172		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173	<	#line 150 "MDTreeParser.cpp"
173	>	#line 174 "MDTreeParser.cpp"
174		}
175		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176		reportError(ex);
#	Line 157 | Line 181 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
181		}
182
183		void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
184	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
184	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
185
186		try {      // for error handling
187	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
187	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
188		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189		match(_t,MOLECULE);
190		_t = _t->getFirstChild();
191	<	#line 72 "MDTreeParser.g"
191	>	#line 101 "MDTreeParser.g"
192		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193	<	#line 170 "MDTreeParser.cpp"
193	>	#line 194 "MDTreeParser.cpp"
194		{ // ( ... )*
195		for (;;) {
196		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 176 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200		_t = _retTree;
201		}
202		else {
203	<	goto _loop19;
203	>	goto _loop36;
204		}
205
206		}
207	<	_loop19:;
207	>	_loop36:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t17;
212	>	_t = __t34;
213		_t = _t->getNextSibling();
214	<	#line 74 "MDTreeParser.g"
214	>	#line 103 "MDTreeParser.g"
215		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216	<	#line 193 "MDTreeParser.cpp"
216	>	#line 217 "MDTreeParser.cpp"
217		}
218		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219		reportError(ex);
#	Line 200 | Line 224 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
224		}
225
226		void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
227	<	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
227	>	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
228
229		try {      // for error handling
230	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
230	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t;
231		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232		match(_t,ZCONSTRAINT);
233		_t = _t->getFirstChild();
234	<	#line 67 "MDTreeParser.g"
234	>	#line 75 "MDTreeParser.g"
235		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236	<	#line 213 "MDTreeParser.cpp"
236	>	#line 237 "MDTreeParser.cpp"
237		{ // ( ... )*
238		for (;;) {
239		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 219 | Line 243 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
243		_t = _retTree;
244		}
245		else {
246	<	goto _loop15;
246	>	goto _loop16;
247		}
248
249		}
250	<	_loop15:;
250	>	_loop16:;
251		} // ( ... )*
252		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253		match(_t,ENDBLOCK);
254		_t = _t->getNextSibling();
255	<	_t = __t13;
255	>	_t = __t14;
256		_t = _t->getNextSibling();
257	<	#line 69 "MDTreeParser.g"
257	>	#line 77 "MDTreeParser.g"
258		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259	<	#line 236 "MDTreeParser.cpp"
259	>	#line 260 "MDTreeParser.cpp"
260		}
261		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262		reportError(ex);
#	Line 242 | Line 266 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
266		_retTree = _t;
267		}
268
269	+	void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
270	+	ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
271	+
272	+	try {      // for error handling
273	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t18 = _t;
274	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275	+	match(_t,RESTRAINT);
276	+	_t = _t->getFirstChild();
277	+	#line 80 "MDTreeParser.g"
278	+	RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279	+	#line 280 "MDTreeParser.cpp"
280	+	{ // ( ... )*
281	+	for (;;) {
282	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
283	+	_t = ASTNULL;
284	+	if ((_t->getType() == ASSIGNEQUAL)) {
285	+	assignment(_t);
286	+	_t = _retTree;
287	+	}
288	+	else {
289	+	goto _loop20;
290	+	}
291	+
292	+	}
293	+	_loop20:;
294	+	} // ( ... )*
295	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296	+	match(_t,ENDBLOCK);
297	+	_t = _t->getNextSibling();
298	+	_t = __t18;
299	+	_t = _t->getNextSibling();
300	+	#line 82 "MDTreeParser.g"
301	+	blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302	+	#line 303 "MDTreeParser.cpp"
303	+	}
304	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305	+	reportError(ex);
306	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
307	+	_t = _t->getNextSibling();
308	+	}
309	+	_retTree = _t;
310	+	}
311	+
312	+	void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
313	+	ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
314	+
315	+	try {      // for error handling
316	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
317	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318	+	match(_t,FLUCQ);
319	+	_t = _t->getFirstChild();
320	+	#line 85 "MDTreeParser.g"
321	+	FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322	+	#line 323 "MDTreeParser.cpp"
323	+	{ // ( ... )*
324	+	for (;;) {
325	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
326	+	_t = ASTNULL;
327	+	if ((_t->getType() == ASSIGNEQUAL)) {
328	+	assignment(_t);
329	+	_t = _retTree;
330	+	}
331	+	else {
332	+	goto _loop24;
333	+	}
334	+
335	+	}
336	+	_loop24:;
337	+	} // ( ... )*
338	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339	+	match(_t,ENDBLOCK);
340	+	_t = _t->getNextSibling();
341	+	_t = __t22;
342	+	_t = _t->getNextSibling();
343	+	#line 87 "MDTreeParser.g"
344	+	blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345	+	#line 346 "MDTreeParser.cpp"
346	+	}
347	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348	+	reportError(ex);
349	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
350	+	_t = _t->getNextSibling();
351	+	}
352	+	_retTree = _t;
353	+	}
354	+
355	+	void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
356	+	ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
357	+
358	+	try {      // for error handling
359	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
360	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361	+	match(_t,RNEMD);
362	+	_t = _t->getFirstChild();
363	+	#line 90 "MDTreeParser.g"
364	+	RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365	+	#line 366 "MDTreeParser.cpp"
366	+	{ // ( ... )*
367	+	for (;;) {
368	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
369	+	_t = ASTNULL;
370	+	if ((_t->getType() == ASSIGNEQUAL)) {
371	+	assignment(_t);
372	+	_t = _retTree;
373	+	}
374	+	else {
375	+	goto _loop28;
376	+	}
377	+
378	+	}
379	+	_loop28:;
380	+	} // ( ... )*
381	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382	+	match(_t,ENDBLOCK);
383	+	_t = _t->getNextSibling();
384	+	_t = __t26;
385	+	_t = _t->getNextSibling();
386	+	#line 92 "MDTreeParser.g"
387	+	blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388	+	#line 389 "MDTreeParser.cpp"
389	+	}
390	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
391	+	reportError(ex);
392	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
393	+	_t = _t->getNextSibling();
394	+	}
395	+	_retTree = _t;
396	+	}
397	+
398	+	void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
399	+	ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
400	+
401	+	try {      // for error handling
402	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
403	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404	+	match(_t,MINIMIZER);
405	+	_t = _t->getFirstChild();
406	+	#line 95 "MDTreeParser.g"
407	+	MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408	+	#line 409 "MDTreeParser.cpp"
409	+	{ // ( ... )*
410	+	for (;;) {
411	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
412	+	_t = ASTNULL;
413	+	if ((_t->getType() == ASSIGNEQUAL)) {
414	+	assignment(_t);
415	+	_t = _retTree;
416	+	}
417	+	else {
418	+	goto _loop32;
419	+	}
420	+
421	+	}
422	+	_loop32:;
423	+	} // ( ... )*
424	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425	+	match(_t,ENDBLOCK);
426	+	_t = _t->getNextSibling();
427	+	_t = __t30;
428	+	_t = _t->getNextSibling();
429	+	#line 97 "MDTreeParser.g"
430	+	blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431	+	#line 432 "MDTreeParser.cpp"
432	+	}
433	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
434	+	reportError(ex);
435	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
436	+	_t = _t->getNextSibling();
437	+	}
438	+	_retTree = _t;
439	+	}
440	+
441		void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
442		ANTLR_USE_NAMESPACE(antlr)RefAST id
443		) {
444	<	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
444	>	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447	<	#line 47 "MDTreeParser.g"
447	>	#line 50 "MDTreeParser.g"
448
449		int ival;
450	<	RealType dval;
450	>	RealType dval, x, y, z;
451	>	std::vector<RealType> dvec;
452
453	<	#line 257 "MDTreeParser.cpp"
453	>	#line 454 "MDTreeParser.cpp"
454
455		try {      // for error handling
456		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 264 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
461		{
462		ival=intConst(_t);
463		_t = _retTree;
464	<	#line 52 "MDTreeParser.g"
464	>	#line 56 "MDTreeParser.g"
465		blockStack.top()->assign(id->getText(), ival);
466	<	#line 270 "MDTreeParser.cpp"
466	>	#line 467 "MDTreeParser.cpp"
467		break;
468		}
469		case NUM_FLOAT:
#	Line 274 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
471		{
472		dval=floatConst(_t);
473		_t = _retTree;
474	<	#line 53 "MDTreeParser.g"
474	>	#line 57 "MDTreeParser.g"
475		blockStack.top()->assign(id->getText(), dval);
476	<	#line 280 "MDTreeParser.cpp"
476	>	#line 477 "MDTreeParser.cpp"
477		break;
478		}
479		case ID:
#	Line 284 | Line 481 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
481		str1 = _t;
482		match(_t,ID);
483		_t = _t->getNextSibling();
484	<	#line 54 "MDTreeParser.g"
484	>	#line 58 "MDTreeParser.g"
485		blockStack.top()->assign(id->getText(), str1->getText());
486	<	#line 290 "MDTreeParser.cpp"
486	>	#line 487 "MDTreeParser.cpp"
487		break;
488		}
489		case StringLiteral:
#	Line 294 | Line 491 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
491		str2 = _t;
492		match(_t,StringLiteral);
493		_t = _t->getNextSibling();
494	<	#line 55 "MDTreeParser.g"
494	>	#line 59 "MDTreeParser.g"
495		std::string s =  str2->getText();
496		s = s.substr(1, s.length()-2);
497		blockStack.top()->assign(id->getText(),s);
498
499	<	#line 303 "MDTreeParser.cpp"
499	>	#line 500 "MDTreeParser.cpp"
500		break;
501		}
502	+	case LPAREN:
503	+	{
504	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
505	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
506	+	match(_t,LPAREN);
507	+	_t = _t->getFirstChild();
508	+	dvec=doubleNumberTuple(_t);
509	+	_t = _retTree;
510	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
511	+	match(_t,RPAREN);
512	+	_t = _t->getNextSibling();
513	+	_t = __t8;
514	+	_t = _t->getNextSibling();
515	+	#line 64 "MDTreeParser.g"
516	+
517	+	blockStack.top()->assign(id->getText(), dvec);
518	+
519	+	#line 520 "MDTreeParser.cpp"
520	+	break;
521	+	}
522		default:
523		{
524		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 317 | Line 534 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
534		}
535
536		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
537	<	#line 242 "MDTreeParser.g"
537	>	#line 312 "MDTreeParser.g"
538		int ival;
539	<	#line 323 "MDTreeParser.cpp"
540	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539	>	#line 540 "MDTreeParser.cpp"
540	>	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
541		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
542		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
543
#	Line 333 | Line 550 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
550		i1 = _t;
551		match(_t,NUM_INT);
552		_t = _t->getNextSibling();
553	<	#line 243 "MDTreeParser.g"
553	>	#line 313 "MDTreeParser.g"
554		ival = lexi_cast<int>(i1->getText());
555	<	#line 339 "MDTreeParser.cpp"
555	>	#line 556 "MDTreeParser.cpp"
556		break;
557		}
558		case NUM_LONG:
#	Line 343 | Line 560 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
560		i2 = _t;
561		match(_t,NUM_LONG);
562		_t = _t->getNextSibling();
563	<	#line 244 "MDTreeParser.g"
563	>	#line 314 "MDTreeParser.g"
564		ival = lexi_cast<int>(i2->getText());
565	<	#line 349 "MDTreeParser.cpp"
565	>	#line 566 "MDTreeParser.cpp"
566		break;
567		}
568		default:
#	Line 364 | Line 581 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
581		}
582
583		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
584	<	#line 256 "MDTreeParser.g"
584	>	#line 324 "MDTreeParser.g"
585		RealType dval;
586	<	#line 370 "MDTreeParser.cpp"
587	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
586	>	#line 587 "MDTreeParser.cpp"
587	>	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
588		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
589		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
590
#	Line 380 | Line 597 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
597		d1 = _t;
598		match(_t,NUM_FLOAT);
599		_t = _t->getNextSibling();
600	<	#line 257 "MDTreeParser.g"
600	>	#line 325 "MDTreeParser.g"
601		dval = lexi_cast<RealType>(d1->getText());
602	<	#line 386 "MDTreeParser.cpp"
602	>	#line 603 "MDTreeParser.cpp"
603		break;
604		}
605		case NUM_DOUBLE:
#	Line 390 | Line 607 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
607		d2 = _t;
608		match(_t,NUM_DOUBLE);
609		_t = _t->getNextSibling();
610	<	#line 258 "MDTreeParser.g"
610	>	#line 326 "MDTreeParser.g"
611		dval = lexi_cast<RealType>(d2->getText());
612	<	#line 396 "MDTreeParser.cpp"
612	>	#line 613 "MDTreeParser.cpp"
613		break;
614		}
615		default:
#	Line 410 | Line 627 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
627		return dval;
628		}
629
630	+	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
631	+	#line 296 "MDTreeParser.g"
632	+	vector<RealType> dvec;
633	+	#line 634 "MDTreeParser.cpp"
634	+	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
635	+	#line 296 "MDTreeParser.g"
636	+
637	+	RealType dval;
638	+
639	+	#line 640 "MDTreeParser.cpp"
640	+
641	+	try {      // for error handling
642	+	{ // ( ... )+
643	+	int _cnt95=0;
644	+	for (;;) {
645	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
646	+	_t = ASTNULL;
647	+	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
648	+	dval=doubleNumber(_t);
649	+	_t = _retTree;
650	+	#line 300 "MDTreeParser.g"
651	+	dvec.push_back(dval);
652	+	#line 653 "MDTreeParser.cpp"
653	+	}
654	+	else {
655	+	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
656	+	}
657	+
658	+	_cnt95++;
659	+	}
660	+	_loop95:;
661	+	}  // ( ... )+
662	+	}
663	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
664	+	reportError(ex);
665	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
666	+	_t = _t->getNextSibling();
667	+	}
668	+	_retTree = _t;
669	+	return dvec;
670	+	}
671	+
672		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
673	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
673	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
674
675		try {      // for error handling
676		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 447 | Line 706 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
706		_t = _retTree;
707		break;
708		}
709	+	case INVERSION:
710	+	{
711	+	inversionblock(_t);
712	+	_t = _retTree;
713	+	break;
714	+	}
715		case RIGIDBODY:
716		{
717		rigidbodyblock(_t);
#	Line 465 | Line 730 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
730		_t = _retTree;
731		break;
732		}
733	+	case CONSTRAINT:
734	+	{
735	+	constraintblock(_t);
736	+	_t = _retTree;
737	+	break;
738	+	}
739		default:
740		{
741		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 480 | Line 751 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
751		}
752
753		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
754	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
755	<	#line 87 "MDTreeParser.g"
754	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
755	>	#line 118 "MDTreeParser.g"
756
757		int index;
758
759	<	#line 489 "MDTreeParser.cpp"
759	>	#line 760 "MDTreeParser.cpp"
760
761		try {      // for error handling
762	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
763	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
762	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
763	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
764		match(_t,ATOM);
765		_t = _t->getFirstChild();
766		index=intConst(_t);
767		_t = _retTree;
768	<	#line 91 "MDTreeParser.g"
768	>	#line 122 "MDTreeParser.g"
769		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
770	<	#line 500 "MDTreeParser.cpp"
770	>	#line 771 "MDTreeParser.cpp"
771		{ // ( ... )*
772		for (;;) {
773		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 506 | Line 777 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
777		_t = _retTree;
778		}
779		else {
780	<	goto _loop24;
780	>	goto _loop41;
781		}
782
783		}
784	<	_loop24:;
784	>	_loop41:;
785		} // ( ... )*
786	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
786	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
787		match(_t,ENDBLOCK);
788		_t = _t->getNextSibling();
789	<	_t = __t22;
789	>	_t = __t39;
790		_t = _t->getNextSibling();
791	<	#line 93 "MDTreeParser.g"
791	>	#line 124 "MDTreeParser.g"
792
793		blockStack.top()->validate();
794		blockStack.pop();
795		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
796		currMoleculeStamp->addAtomStamp(currAtomStamp);
797
798	<	#line 528 "MDTreeParser.cpp"
798	>	#line 799 "MDTreeParser.cpp"
799		}
800		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
801		reportError(ex);
#	Line 535 | Line 806 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
806		}
807
808		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
809	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
809	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
810
811		try {      // for error handling
812	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
813	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
812	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
813	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
814		match(_t,BOND);
815		_t = _t->getFirstChild();
816	<	#line 113 "MDTreeParser.g"
816	>	#line 144 "MDTreeParser.g"
817		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
818	<	#line 548 "MDTreeParser.cpp"
818	>	#line 819 "MDTreeParser.cpp"
819		{ // ( ... )*
820		for (;;) {
821		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 554 | Line 825 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
825		_t = _retTree;
826		}
827		else {
828	<	goto _loop31;
828	>	goto _loop48;
829		}
830
831		}
832	<	_loop31:;
832	>	_loop48:;
833		} // ( ... )*
834	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
834	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
835		match(_t,ENDBLOCK);
836		_t = _t->getNextSibling();
837	<	_t = __t29;
837	>	_t = __t46;
838		_t = _t->getNextSibling();
839	<	#line 115 "MDTreeParser.g"
839	>	#line 146 "MDTreeParser.g"
840
841		blockStack.pop();
842		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
843		currMoleculeStamp->addBondStamp(currBondStamp);
844
845	<	#line 575 "MDTreeParser.cpp"
845	>	#line 846 "MDTreeParser.cpp"
846		}
847		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
848		reportError(ex);
#	Line 582 | Line 853 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
853		}
854
855		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
856	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
856	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
857
858		try {      // for error handling
859	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
859	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
860	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
861		match(_t,BEND);
862		_t = _t->getFirstChild();
863	<	#line 131 "MDTreeParser.g"
863	>	#line 162 "MDTreeParser.g"
864		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
865	<	#line 595 "MDTreeParser.cpp"
865	>	#line 866 "MDTreeParser.cpp"
866		{ // ( ... )*
867		for (;;) {
868		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 601 | Line 872 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
872		_t = _retTree;
873		}
874		else {
875	<	goto _loop37;
875	>	goto _loop54;
876		}
877
878		}
879	<	_loop37:;
879	>	_loop54:;
880		} // ( ... )*
881	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
881	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
882		match(_t,ENDBLOCK);
883		_t = _t->getNextSibling();
884	<	_t = __t35;
884	>	_t = __t52;
885		_t = _t->getNextSibling();
886	<	#line 133 "MDTreeParser.g"
886	>	#line 164 "MDTreeParser.g"
887
888		blockStack.top()->validate();
889		blockStack.pop();
890		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
891		currMoleculeStamp->addBendStamp(currBendStamp);
892
893	<	#line 623 "MDTreeParser.cpp"
893	>	#line 894 "MDTreeParser.cpp"
894		}
895		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
896		reportError(ex);
#	Line 630 | Line 901 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
901		}
902
903		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
904	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
904	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
905
906		try {      // for error handling
907	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
908	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
907	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
908	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
909		match(_t,TORSION);
910		_t = _t->getFirstChild();
911	<	#line 150 "MDTreeParser.g"
911	>	#line 181 "MDTreeParser.g"
912		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
913	<	#line 643 "MDTreeParser.cpp"
913	>	#line 914 "MDTreeParser.cpp"
914		{ // ( ... )*
915		for (;;) {
916		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 649 | Line 920 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
920		_t = _retTree;
921		}
922		else {
923	<	goto _loop43;
923	>	goto _loop60;
924		}
925
926		}
927	<	_loop43:;
927	>	_loop60:;
928		} // ( ... )*
929	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
929	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
930		match(_t,ENDBLOCK);
931		_t = _t->getNextSibling();
932	<	_t = __t41;
932	>	_t = __t58;
933		_t = _t->getNextSibling();
934	<	#line 152 "MDTreeParser.g"
934	>	#line 183 "MDTreeParser.g"
935
936		blockStack.top()->validate();
937		blockStack.pop();
938		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
939		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
940
941	<	#line 671 "MDTreeParser.cpp"
941	>	#line 942 "MDTreeParser.cpp"
942	>	}
943	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944	>	reportError(ex);
945	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
946	>	_t = _t->getNextSibling();
947	>	}
948	>	_retTree = _t;
949	>	}
950	>
951	>	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
952	>	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
953	>
954	>	try {      // for error handling
955	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
956	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
957	>	match(_t,INVERSION);
958	>	_t = _t->getFirstChild();
959	>	#line 200 "MDTreeParser.g"
960	>	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
961	>	#line 962 "MDTreeParser.cpp"
962	>	{ // ( ... )*
963	>	for (;;) {
964	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
965	>	_t = ASTNULL;
966	>	if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
967	>	inversionstatement(_t);
968	>	_t = _retTree;
969	>	}
970	>	else {
971	>	goto _loop66;
972	>	}
973	>
974	>	}
975	>	_loop66:;
976	>	} // ( ... )*
977	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978	>	match(_t,ENDBLOCK);
979	>	_t = _t->getNextSibling();
980	>	_t = __t64;
981	>	_t = _t->getNextSibling();
982	>	#line 202 "MDTreeParser.g"
983	>
984	>	blockStack.top()->validate();
985	>	blockStack.pop();
986	>	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
987	>	currMoleculeStamp->addInversionStamp(currInversionStamp);
988	>
989	>	#line 990 "MDTreeParser.cpp"
990		}
991		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
992		reportError(ex);
#	Line 678 | Line 997 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
997		}
998
999		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1000	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1001	<	#line 169 "MDTreeParser.g"
1000	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1001	>	#line 221 "MDTreeParser.g"
1002
1003		int index;
1004
1005	<	#line 687 "MDTreeParser.cpp"
1005	>	#line 1006 "MDTreeParser.cpp"
1006
1007		try {      // for error handling
1008	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
1009	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
1008	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1009	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1010		match(_t,RIGIDBODY);
1011		_t = _t->getFirstChild();
1012		index=intConst(_t);
1013		_t = _retTree;
1014	<	#line 173 "MDTreeParser.g"
1014	>	#line 225 "MDTreeParser.g"
1015		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1016	<	#line 698 "MDTreeParser.cpp"
1016	>	#line 1017 "MDTreeParser.cpp"
1017		{ // ( ... )*
1018		for (;;) {
1019		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 704 | Line 1023 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1023		_t = _retTree;
1024		}
1025		else {
1026	<	goto _loop49;
1026	>	goto _loop73;
1027		}
1028
1029		}
1030	<	_loop49:;
1030	>	_loop73:;
1031		} // ( ... )*
1032	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
1032	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1033		match(_t,ENDBLOCK);
1034		_t = _t->getNextSibling();
1035	<	_t = __t47;
1035	>	_t = __t71;
1036		_t = _t->getNextSibling();
1037	<	#line 175 "MDTreeParser.g"
1037	>	#line 227 "MDTreeParser.g"
1038
1039		blockStack.top()->validate();
1040		blockStack.pop();
1041		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1042		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1043
1044	<	#line 726 "MDTreeParser.cpp"
1044	>	#line 1045 "MDTreeParser.cpp"
1045		}
1046		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047		reportError(ex);
#	Line 733 | Line 1052 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1052		}
1053
1054		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1055	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1055	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1056
1057		try {      // for error handling
1058	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
1059	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1058	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1059	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1060		match(_t,CUTOFFGROUP);
1061		_t = _t->getFirstChild();
1062	<	#line 192 "MDTreeParser.g"
1062	>	#line 244 "MDTreeParser.g"
1063		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1064	<	#line 746 "MDTreeParser.cpp"
1064	>	#line 1065 "MDTreeParser.cpp"
1065		{ // ( ... )*
1066		for (;;) {
1067		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 752 | Line 1071 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1071		_t = _retTree;
1072		}
1073		else {
1074	<	goto _loop55;
1074	>	goto _loop79;
1075		}
1076
1077		}
1078	<	_loop55:;
1078	>	_loop79:;
1079		} // ( ... )*
1080	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1080	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1081		match(_t,ENDBLOCK);
1082		_t = _t->getNextSibling();
1083	<	_t = __t53;
1083	>	_t = __t77;
1084		_t = _t->getNextSibling();
1085	<	#line 194 "MDTreeParser.g"
1085	>	#line 246 "MDTreeParser.g"
1086
1087		blockStack.top()->validate();
1088		blockStack.pop();
1089		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1090		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1091
1092	<	#line 774 "MDTreeParser.cpp"
1092	>	#line 1093 "MDTreeParser.cpp"
1093		}
1094		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1095		reportError(ex);
#	Line 781 | Line 1100 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1100		}
1101
1102		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1103	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1104	<	#line 211 "MDTreeParser.g"
1103	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1104	>	#line 263 "MDTreeParser.g"
1105		int ival;
1106	<	#line 788 "MDTreeParser.cpp"
1106	>	#line 1107 "MDTreeParser.cpp"
1107
1108		try {      // for error handling
1109	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
1110	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1109	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1110	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1111		match(_t,FRAGMENT);
1112		_t = _t->getFirstChild();
1113		ival=intConst(_t);
1114		_t = _retTree;
1115	<	#line 212 "MDTreeParser.g"
1115	>	#line 264 "MDTreeParser.g"
1116		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1117	<	#line 799 "MDTreeParser.cpp"
1117	>	#line 1118 "MDTreeParser.cpp"
1118		{ // ( ... )*
1119		for (;;) {
1120		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 805 | Line 1124 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1124		_t = _retTree;
1125		}
1126		else {
1127	<	goto _loop61;
1127	>	goto _loop85;
1128		}
1129
1130		}
1131	<	_loop61:;
1131	>	_loop85:;
1132		} // ( ... )*
1133	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1133	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1134		match(_t,ENDBLOCK);
1135		_t = _t->getNextSibling();
1136	<	_t = __t59;
1136	>	_t = __t83;
1137		_t = _t->getNextSibling();
1138	<	#line 214 "MDTreeParser.g"
1138	>	#line 266 "MDTreeParser.g"
1139
1140		blockStack.top()->validate();
1141		blockStack.pop();
1142		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1143		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1144
1145	<	#line 827 "MDTreeParser.cpp"
1145	>	#line 1146 "MDTreeParser.cpp"
1146	>	}
1147	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1148	>	reportError(ex);
1149	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1150	>	_t = _t->getNextSibling();
1151	>	}
1152	>	_retTree = _t;
1153	>	}
1154	>
1155	>	void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1156	>	ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1157	>
1158	>	try {      // for error handling
1159	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1160	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1161	>	match(_t,CONSTRAINT);
1162	>	_t = _t->getFirstChild();
1163	>	#line 277 "MDTreeParser.g"
1164	>	ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1165	>	#line 1166 "MDTreeParser.cpp"
1166	>	{ // ( ... )*
1167	>	for (;;) {
1168	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1169	>	_t = ASTNULL;
1170	>	if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1171	>	constraintstatement(_t);
1172	>	_t = _retTree;
1173	>	}
1174	>	else {
1175	>	goto _loop90;
1176	>	}
1177	>
1178	>	}
1179	>	_loop90:;
1180	>	} // ( ... )*
1181	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1182	>	match(_t,ENDBLOCK);
1183	>	_t = _t->getNextSibling();
1184	>	_t = __t88;
1185	>	_t = _t->getNextSibling();
1186	>	#line 279 "MDTreeParser.g"
1187	>
1188	>	blockStack.pop();
1189	>	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1190	>	currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1191	>
1192	>	#line 1193 "MDTreeParser.cpp"
1193		}
1194		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1195		reportError(ex);
#	Line 834 | Line 1200 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1200		}
1201
1202		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1203	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1204	<	#line 101 "MDTreeParser.g"
1203	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1204	>	#line 132 "MDTreeParser.g"
1205
1206		vector<RealType> dvec;
1207		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1208
1209
1210	<	#line 845 "MDTreeParser.cpp"
1210	>	#line 1211 "MDTreeParser.cpp"
1211
1212		try {      // for error handling
1213		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 855 | Line 1221 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1221		}
1222		case POSITION:
1223		{
1224	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
1225	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1224	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1225	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1226		match(_t,POSITION);
1227		_t = _t->getFirstChild();
1228		dvec=doubleNumberTuple(_t);
1229		_t = _retTree;
1230	<	_t = __t26;
1230	>	_t = __t43;
1231		_t = _t->getNextSibling();
1232	<	#line 108 "MDTreeParser.g"
1232	>	#line 139 "MDTreeParser.g"
1233		currAtomStamp->setPosition(dvec);
1234	<	#line 869 "MDTreeParser.cpp"
1234	>	#line 1235 "MDTreeParser.cpp"
1235		break;
1236		}
1237		case ORIENTATION:
1238		{
1239	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
1240	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1239	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1240	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1241		match(_t,ORIENTATION);
1242		_t = _t->getFirstChild();
1243		dvec=doubleNumberTuple(_t);
1244		_t = _retTree;
1245	<	_t = __t27;
1245	>	_t = __t44;
1246		_t = _t->getNextSibling();
1247	<	#line 109 "MDTreeParser.g"
1247	>	#line 140 "MDTreeParser.g"
1248		currAtomStamp->setOrientation(dvec);
1249	<	#line 884 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250		break;
1251		}
1252		default:
#	Line 897 | Line 1263 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1263		_retTree = _t;
1264		}
1265
900	–	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
901	–	#line 227 "MDTreeParser.g"
902	–	vector<RealType> dvec;
903	–	#line 904 "MDTreeParser.cpp"
904	–	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
905	–	#line 227 "MDTreeParser.g"
906	–
907	–	RealType dval;
908	–
909	–	#line 910 "MDTreeParser.cpp"
910	–
911	–	try {      // for error handling
912	–	{ // ( ... )+
913	–	int _cnt65=0;
914	–	for (;;) {
915	–	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
916	–	_t = ASTNULL;
917	–	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
918	–	dval=doubleNumber(_t);
919	–	_t = _retTree;
920	–	#line 231 "MDTreeParser.g"
921	–	dvec.push_back(dval);
922	–	#line 923 "MDTreeParser.cpp"
923	–	}
924	–	else {
925	–	if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
926	–	}
927	–
928	–	_cnt65++;
929	–	}
930	–	_loop65:;
931	–	}  // ( ... )+
932	–	}
933	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
934	–	reportError(ex);
935	–	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
936	–	_t = _t->getNextSibling();
937	–	}
938	–	_retTree = _t;
939	–	return dvec;
940	–	}
941	–
1266		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1267	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1268	<	#line 122 "MDTreeParser.g"
1267	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1268	>	#line 153 "MDTreeParser.g"
1269
1270		vector<int> ivec;
1271		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1272
1273	<	#line 950 "MDTreeParser.cpp"
1273	>	#line 1274 "MDTreeParser.cpp"
1274
1275		try {      // for error handling
1276		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 960 | Line 1284 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1284		}
1285		case MEMBERS:
1286		{
1287	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1288	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1287	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1288	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1289		match(_t,MEMBERS);
1290		_t = _t->getFirstChild();
1291		ivec=inttuple(_t);
1292		_t = _retTree;
1293	<	_t = __t33;
1293	>	_t = __t50;
1294		_t = _t->getNextSibling();
1295	<	#line 128 "MDTreeParser.g"
1295	>	#line 159 "MDTreeParser.g"
1296		currBondStamp->setMembers(ivec);
1297	<	#line 974 "MDTreeParser.cpp"
1297	>	#line 1298 "MDTreeParser.cpp"
1298		break;
1299		}
1300		default:
#	Line 988 | Line 1312 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1312		}
1313
1314		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1315	<	#line 234 "MDTreeParser.g"
1315	>	#line 304 "MDTreeParser.g"
1316		vector<int> ivec;
1317	<	#line 994 "MDTreeParser.cpp"
1318	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1319	<	#line 234 "MDTreeParser.g"
1317	>	#line 1318 "MDTreeParser.cpp"
1318	>	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1319	>	#line 304 "MDTreeParser.g"
1320
1321		int ival;
1322
1323	<	#line 1000 "MDTreeParser.cpp"
1323	>	#line 1324 "MDTreeParser.cpp"
1324
1325		try {      // for error handling
1326		{ // ( ... )+
1327	<	int _cnt68=0;
1327	>	int _cnt98=0;
1328		for (;;) {
1329		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1330		_t = ASTNULL;
1331		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1332		ival=intConst(_t);
1333		_t = _retTree;
1334	<	#line 238 "MDTreeParser.g"
1334	>	#line 308 "MDTreeParser.g"
1335		ivec.push_back(ival);
1336	<	#line 1013 "MDTreeParser.cpp"
1336	>	#line 1337 "MDTreeParser.cpp"
1337		}
1338		else {
1339	<	if ( _cnt68>=1 ) { goto _loop68; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1339	>	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1340		}
1341
1342	<	_cnt68++;
1342	>	_cnt98++;
1343		}
1344	<	_loop68:;
1344	>	_loop98:;
1345		}  // ( ... )+
1346		}
1347		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1030 | Line 1354 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1354		}
1355
1356		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1357	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1358	<	#line 141 "MDTreeParser.g"
1357	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1358	>	#line 172 "MDTreeParser.g"
1359
1360		vector<int> ivec;
1361		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1362
1363	<	#line 1040 "MDTreeParser.cpp"
1363	>	#line 1364 "MDTreeParser.cpp"
1364
1365		try {      // for error handling
1366		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1050 | Line 1374 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1374		}
1375		case MEMBERS:
1376		{
1377	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1378	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1377	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1378	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1379		match(_t,MEMBERS);
1380		_t = _t->getFirstChild();
1381		ivec=inttuple(_t);
1382		_t = _retTree;
1383	<	_t = __t39;
1383	>	_t = __t56;
1384		_t = _t->getNextSibling();
1385	<	#line 147 "MDTreeParser.g"
1385	>	#line 178 "MDTreeParser.g"
1386		currBendStamp->setMembers(ivec);
1387	<	#line 1064 "MDTreeParser.cpp"
1387	>	#line 1388 "MDTreeParser.cpp"
1388		break;
1389		}
1390		default:
#	Line 1078 | Line 1402 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1402		}
1403
1404		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1405	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406	<	#line 160 "MDTreeParser.g"
1405	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406	>	#line 191 "MDTreeParser.g"
1407
1408		vector<int> ivec;
1409		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1410
1411	<	#line 1088 "MDTreeParser.cpp"
1411	>	#line 1412 "MDTreeParser.cpp"
1412
1413		try {      // for error handling
1414		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1098 | Line 1422 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1422		}
1423		case MEMBERS:
1424		{
1425	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1426	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1425	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1426	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1427		match(_t,MEMBERS);
1428		_t = _t->getFirstChild();
1429		ivec=inttuple(_t);
1430		_t = _retTree;
1431	<	_t = __t45;
1431	>	_t = __t62;
1432		_t = _t->getNextSibling();
1433	<	#line 166 "MDTreeParser.g"
1433	>	#line 197 "MDTreeParser.g"
1434		currTorsionStamp->setMembers(ivec);
1435	<	#line 1112 "MDTreeParser.cpp"
1435	>	#line 1436 "MDTreeParser.cpp"
1436		break;
1437		}
1438		default:
#	Line 1125 | Line 1449 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1449		_retTree = _t;
1450		}
1451
1452	+	void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1453	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1454	+	#line 210 "MDTreeParser.g"
1455	+
1456	+	int icent;
1457	+	vector<int> ivec;
1458	+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1459	+
1460	+	#line 1461 "MDTreeParser.cpp"
1461	+
1462	+	try {      // for error handling
1463	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1464	+	_t = ASTNULL;
1465	+	switch ( _t->getType()) {
1466	+	case ASSIGNEQUAL:
1467	+	{
1468	+	assignment(_t);
1469	+	_t = _retTree;
1470	+	break;
1471	+	}
1472	+	case CENTER:
1473	+	{
1474	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1475	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1476	+	match(_t,CENTER);
1477	+	_t = _t->getFirstChild();
1478	+	icent=intConst(_t);
1479	+	_t = _retTree;
1480	+	_t = __t68;
1481	+	_t = _t->getNextSibling();
1482	+	#line 217 "MDTreeParser.g"
1483	+	currInversionStamp->setCenter(icent);
1484	+	#line 1485 "MDTreeParser.cpp"
1485	+	break;
1486	+	}
1487	+	case SATELLITES:
1488	+	{
1489	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1490	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1491	+	match(_t,SATELLITES);
1492	+	_t = _t->getFirstChild();
1493	+	ivec=inttuple(_t);
1494	+	_t = _retTree;
1495	+	_t = __t69;
1496	+	_t = _t->getNextSibling();
1497	+	#line 218 "MDTreeParser.g"
1498	+	currInversionStamp->setSatellites(ivec);
1499	+	#line 1500 "MDTreeParser.cpp"
1500	+	break;
1501	+	}
1502	+	default:
1503	+	{
1504	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1505	+	}
1506	+	}
1507	+	}
1508	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1509	+	reportError(ex);
1510	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1511	+	_t = _t->getNextSibling();
1512	+	}
1513	+	_retTree = _t;
1514	+	}
1515	+
1516		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1517	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1518	<	#line 183 "MDTreeParser.g"
1517	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1518	>	#line 235 "MDTreeParser.g"
1519
1520		vector<int> ivec;
1521		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1522
1523	<	#line 1136 "MDTreeParser.cpp"
1523	>	#line 1524 "MDTreeParser.cpp"
1524
1525		try {      // for error handling
1526		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1146 | Line 1534 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1534		}
1535		case MEMBERS:
1536		{
1537	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1538	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1537	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1538	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1539		match(_t,MEMBERS);
1540		_t = _t->getFirstChild();
1541		ivec=inttuple(_t);
1542		_t = _retTree;
1543	<	_t = __t51;
1543	>	_t = __t75;
1544		_t = _t->getNextSibling();
1545	<	#line 189 "MDTreeParser.g"
1545	>	#line 241 "MDTreeParser.g"
1546		currRigidBodyStamp->setMembers(ivec);
1547	<	#line 1160 "MDTreeParser.cpp"
1547	>	#line 1548 "MDTreeParser.cpp"
1548		break;
1549		}
1550		default:
#	Line 1174 | Line 1562 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1562		}
1563
1564		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1565	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1566	<	#line 202 "MDTreeParser.g"
1565	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1566	>	#line 254 "MDTreeParser.g"
1567
1568		vector<int> ivec;
1569		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1570
1571	<	#line 1184 "MDTreeParser.cpp"
1571	>	#line 1572 "MDTreeParser.cpp"
1572
1573		try {      // for error handling
1574		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1194 | Line 1582 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1582		}
1583		case MEMBERS:
1584		{
1585	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1586	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1585	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1586	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1587		match(_t,MEMBERS);
1588		_t = _t->getFirstChild();
1589		ivec=inttuple(_t);
1590		_t = _retTree;
1591	<	_t = __t57;
1591	>	_t = __t81;
1592		_t = _t->getNextSibling();
1593	<	#line 208 "MDTreeParser.g"
1593	>	#line 260 "MDTreeParser.g"
1594		currCutoffGroupStamp->setMembers(ivec);
1595	<	#line 1208 "MDTreeParser.cpp"
1595	>	#line 1596 "MDTreeParser.cpp"
1596		break;
1597		}
1598		default:
#	Line 1222 | Line 1610 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1610		}
1611
1612		void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1613	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1613	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1614
1615		try {      // for error handling
1616		assignment(_t);
#	Line 1236 | Line 1624 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1624		_retTree = _t;
1625		}
1626
1627	+	void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1628	+	ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1629	+	#line 286 "MDTreeParser.g"
1630	+
1631	+	vector<int> ivec;
1632	+	ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1633	+
1634	+	#line 1635 "MDTreeParser.cpp"
1635	+
1636	+	try {      // for error handling
1637	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1638	+	_t = ASTNULL;
1639	+	switch ( _t->getType()) {
1640	+	case ASSIGNEQUAL:
1641	+	{
1642	+	assignment(_t);
1643	+	_t = _retTree;
1644	+	break;
1645	+	}
1646	+	case MEMBERS:
1647	+	{
1648	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1649	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1650	+	match(_t,MEMBERS);
1651	+	_t = _t->getFirstChild();
1652	+	ivec=inttuple(_t);
1653	+	_t = _retTree;
1654	+	_t = __t92;
1655	+	_t = _t->getNextSibling();
1656	+	#line 292 "MDTreeParser.g"
1657	+	currConstraintStamp->setMembers(ivec);
1658	+	#line 1659 "MDTreeParser.cpp"
1659	+	break;
1660	+	}
1661	+	default:
1662	+	{
1663	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1664	+	}
1665	+	}
1666	+	}
1667	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1668	+	reportError(ex);
1669	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1670	+	_t = _t->getNextSibling();
1671	+	}
1672	+	_retTree = _t;
1673	+	}
1674	+
1675		RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1676	<	#line 248 "MDTreeParser.g"
1676	>	#line 318 "MDTreeParser.g"
1677		RealType dval;
1678	<	#line 1243 "MDTreeParser.cpp"
1679	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1678	>	#line 1679 "MDTreeParser.cpp"
1679	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1680		ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1681		ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1682
#	Line 1254 | Line 1690 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1690		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1691		intConst(_t);
1692		_t = _retTree;
1693	<	#line 250 "MDTreeParser.g"
1693	>	#line 319 "MDTreeParser.g"
1694		dval = lexi_cast<RealType>(ic->getText());
1695	<	#line 1260 "MDTreeParser.cpp"
1695	>	#line 1696 "MDTreeParser.cpp"
1696		break;
1697		}
1698		case NUM_FLOAT:
#	Line 1265 | Line 1701 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1701		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1702		floatConst(_t);
1703		_t = _retTree;
1704	<	#line 251 "MDTreeParser.g"
1704	>	#line 320 "MDTreeParser.g"
1705		dval = lexi_cast<RealType>(fc->getText());
1706	<	#line 1271 "MDTreeParser.cpp"
1706	>	#line 1707 "MDTreeParser.cpp"
1707		break;
1708		}
1709		default:
#	Line 1296 | Line 1732 | const char* MDTreeParser::tokenNames[] = {
1732		"\"component\"",
1733		"\"molecule\"",
1734		"\"zconstraint\"",
1735	+	"\"restraint\"",
1736		"\"atom\"",
1737		"\"bond\"",
1738		"\"bend\"",
1739		"\"torsion\"",
1740	+	"\"inversion\"",
1741		"\"rigidBody\"",
1742		"\"cutoffGroup\"",
1743	+	"\"constraint\"",
1744	+	"\"distance\"",
1745		"\"fragment\"",
1746		"\"members\"",
1747	+	"\"center\"",
1748	+	"\"satellites\"",
1749		"\"position\"",
1750		"\"orientation\"",
1751	+	"\"flucQ\"",
1752	+	"\"RNEMD\"",
1753	+	"\"minimizer\"",
1754		"ENDBLOCK",
1755		"ID",
1756		"ASSIGNEQUAL",
#	Line 1343 | Line 1788 | const char* MDTreeParser::tokenNames[] = {
1788		0
1789		};
1790
1791	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1792	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1348	<	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1349	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1350	<	// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1791	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1792	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1793		// ASSIGNEQUAL
1794	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1795	+	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1796	+	// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1797	+	// "constraint" "fragment" ASSIGNEQUAL
1798		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1799
1800

Comparing trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords):
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

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

Diff Legend

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