ViewVC Help

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

root/OpenMD/branches/development/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.
branches/development/src/mdParser/MDTreeParser.cpp (file contents), Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20120725): "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 72 "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 74 "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 103 "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 105 "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 77 "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 79 "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 82 "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 84 "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 87 "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 89 "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 92 "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 94 "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 97 "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 99 "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	>	Vector3d 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 LPAREN:
480	+	{
481	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
482	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
483	+	match(_t,LPAREN);
484	+	_t = _t->getFirstChild();
485	+	x=doubleNumber(_t);
486	+	_t = _retTree;
487	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
488	+	match(_t,COMMA);
489	+	_t = _t->getNextSibling();
490	+	y=doubleNumber(_t);
491	+	_t = _retTree;
492	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
493	+	match(_t,COMMA);
494	+	_t = _t->getNextSibling();
495	+	z=doubleNumber(_t);
496	+	_t = _retTree;
497	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
498	+	match(_t,RPAREN);
499	+	_t = _t->getNextSibling();
500	+	_t = __t8;
501	+	_t = _t->getNextSibling();
502	+	#line 59 "MDTreeParser.g"
503	+	dvec.x() = x;
504	+	dvec.y() = y;
505	+	dvec.z() = z;
506	+	blockStack.top()->assign(id->getText(), dvec);
507	+
508	+	#line 509 "MDTreeParser.cpp"
509	+	break;
510	+	}
511		case ID:
512		{
513		str1 = _t;
514		match(_t,ID);
515		_t = _t->getNextSibling();
516	<	#line 54 "MDTreeParser.g"
516	>	#line 64 "MDTreeParser.g"
517		blockStack.top()->assign(id->getText(), str1->getText());
518	<	#line 290 "MDTreeParser.cpp"
518	>	#line 519 "MDTreeParser.cpp"
519		break;
520		}
521		case StringLiteral:
#	Line 294 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523		str2 = _t;
524		match(_t,StringLiteral);
525		_t = _t->getNextSibling();
526	<	#line 55 "MDTreeParser.g"
526	>	#line 65 "MDTreeParser.g"
527		std::string s =  str2->getText();
528		s = s.substr(1, s.length()-2);
529		blockStack.top()->assign(id->getText(),s);
530
531	<	#line 303 "MDTreeParser.cpp"
531	>	#line 532 "MDTreeParser.cpp"
532		break;
533		}
534		default:
#	Line 317 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546		}
547
548		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549	<	#line 242 "MDTreeParser.g"
549	>	#line 294 "MDTreeParser.g"
550		int ival;
551	<	#line 323 "MDTreeParser.cpp"
552	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
551	>	#line 552 "MDTreeParser.cpp"
552	>	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
553		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
554		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
555
#	Line 333 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562		i1 = _t;
563		match(_t,NUM_INT);
564		_t = _t->getNextSibling();
565	<	#line 243 "MDTreeParser.g"
565	>	#line 295 "MDTreeParser.g"
566		ival = lexi_cast<int>(i1->getText());
567	<	#line 339 "MDTreeParser.cpp"
567	>	#line 568 "MDTreeParser.cpp"
568		break;
569		}
570		case NUM_LONG:
#	Line 343 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572		i2 = _t;
573		match(_t,NUM_LONG);
574		_t = _t->getNextSibling();
575	<	#line 244 "MDTreeParser.g"
575	>	#line 296 "MDTreeParser.g"
576		ival = lexi_cast<int>(i2->getText());
577	<	#line 349 "MDTreeParser.cpp"
577	>	#line 578 "MDTreeParser.cpp"
578		break;
579		}
580		default:
#	Line 364 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593		}
594
595		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596	<	#line 256 "MDTreeParser.g"
596	>	#line 306 "MDTreeParser.g"
597		RealType dval;
598	<	#line 370 "MDTreeParser.cpp"
599	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
598	>	#line 599 "MDTreeParser.cpp"
599	>	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
600		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
601		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
602
#	Line 380 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609		d1 = _t;
610		match(_t,NUM_FLOAT);
611		_t = _t->getNextSibling();
612	<	#line 257 "MDTreeParser.g"
612	>	#line 307 "MDTreeParser.g"
613		dval = lexi_cast<RealType>(d1->getText());
614	<	#line 386 "MDTreeParser.cpp"
614	>	#line 615 "MDTreeParser.cpp"
615		break;
616		}
617		case NUM_DOUBLE:
#	Line 390 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619		d2 = _t;
620		match(_t,NUM_DOUBLE);
621		_t = _t->getNextSibling();
622	<	#line 258 "MDTreeParser.g"
622	>	#line 308 "MDTreeParser.g"
623		dval = lexi_cast<RealType>(d2->getText());
624	<	#line 396 "MDTreeParser.cpp"
624	>	#line 625 "MDTreeParser.cpp"
625	>	break;
626	>	}
627	>	default:
628	>	{
629	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
630	>	}
631	>	}
632	>	}
633	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
634	>	reportError(ex);
635	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
636	>	_t = _t->getNextSibling();
637	>	}
638	>	_retTree = _t;
639	>	return dval;
640	>	}
641	>
642	>	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643	>	#line 300 "MDTreeParser.g"
644	>	RealType dval;
645	>	#line 646 "MDTreeParser.cpp"
646	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647	>	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
648	>	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
649	>
650	>	try {      // for error handling
651	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
652	>	_t = ASTNULL;
653	>	switch ( _t->getType()) {
654	>	case NUM_INT:
655	>	case NUM_LONG:
656	>	{
657	>	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658	>	intConst(_t);
659	>	_t = _retTree;
660	>	#line 301 "MDTreeParser.g"
661	>	dval = lexi_cast<RealType>(ic->getText());
662	>	#line 663 "MDTreeParser.cpp"
663		break;
664		}
665	+	case NUM_FLOAT:
666	+	case NUM_DOUBLE:
667	+	{
668	+	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669	+	floatConst(_t);
670	+	_t = _retTree;
671	+	#line 302 "MDTreeParser.g"
672	+	dval = lexi_cast<RealType>(fc->getText());
673	+	#line 674 "MDTreeParser.cpp"
674	+	break;
675	+	}
676		default:
677		{
678		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 411 | Line 689 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
689		}
690
691		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
692	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
692	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
693
694		try {      // for error handling
695		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 447 | Line 725 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
725		_t = _retTree;
726		break;
727		}
728	+	case INVERSION:
729	+	{
730	+	inversionblock(_t);
731	+	_t = _retTree;
732	+	break;
733	+	}
734		case RIGIDBODY:
735		{
736		rigidbodyblock(_t);
#	Line 480 | Line 764 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
764		}
765
766		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
767	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768	<	#line 87 "MDTreeParser.g"
767	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768	>	#line 119 "MDTreeParser.g"
769
770		int index;
771
772	<	#line 489 "MDTreeParser.cpp"
772	>	#line 773 "MDTreeParser.cpp"
773
774		try {      // for error handling
775	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
776	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
775	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
776	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
777		match(_t,ATOM);
778		_t = _t->getFirstChild();
779		index=intConst(_t);
780		_t = _retTree;
781	<	#line 91 "MDTreeParser.g"
781	>	#line 123 "MDTreeParser.g"
782		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783	<	#line 500 "MDTreeParser.cpp"
783	>	#line 784 "MDTreeParser.cpp"
784		{ // ( ... )*
785		for (;;) {
786		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 506 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790		_t = _retTree;
791		}
792		else {
793	<	goto _loop24;
793	>	goto _loop41;
794		}
795
796		}
797	<	_loop24:;
797	>	_loop41:;
798		} // ( ... )*
799	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
799	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800		match(_t,ENDBLOCK);
801		_t = _t->getNextSibling();
802	<	_t = __t22;
802	>	_t = __t39;
803		_t = _t->getNextSibling();
804	<	#line 93 "MDTreeParser.g"
804	>	#line 125 "MDTreeParser.g"
805
806		blockStack.top()->validate();
807		blockStack.pop();
808		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
809		currMoleculeStamp->addAtomStamp(currAtomStamp);
810
811	<	#line 528 "MDTreeParser.cpp"
811	>	#line 812 "MDTreeParser.cpp"
812		}
813		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814		reportError(ex);
#	Line 535 | Line 819 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
819		}
820
821		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
822	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
822	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
823
824		try {      // for error handling
825	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
826	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
825	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
826	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
827		match(_t,BOND);
828		_t = _t->getFirstChild();
829	<	#line 113 "MDTreeParser.g"
829	>	#line 145 "MDTreeParser.g"
830		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831	<	#line 548 "MDTreeParser.cpp"
831	>	#line 832 "MDTreeParser.cpp"
832		{ // ( ... )*
833		for (;;) {
834		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 554 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838		_t = _retTree;
839		}
840		else {
841	<	goto _loop31;
841	>	goto _loop48;
842		}
843
844		}
845	<	_loop31:;
845	>	_loop48:;
846		} // ( ... )*
847	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
847	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848		match(_t,ENDBLOCK);
849		_t = _t->getNextSibling();
850	<	_t = __t29;
850	>	_t = __t46;
851		_t = _t->getNextSibling();
852	<	#line 115 "MDTreeParser.g"
852	>	#line 147 "MDTreeParser.g"
853
854		blockStack.pop();
855		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
856		currMoleculeStamp->addBondStamp(currBondStamp);
857
858	<	#line 575 "MDTreeParser.cpp"
858	>	#line 859 "MDTreeParser.cpp"
859		}
860		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861		reportError(ex);
#	Line 582 | Line 866 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
866		}
867
868		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
869	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
869	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
870
871		try {      // for error handling
872	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
873	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
872	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
873	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
874		match(_t,BEND);
875		_t = _t->getFirstChild();
876	<	#line 131 "MDTreeParser.g"
876	>	#line 163 "MDTreeParser.g"
877		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878	<	#line 595 "MDTreeParser.cpp"
878	>	#line 879 "MDTreeParser.cpp"
879		{ // ( ... )*
880		for (;;) {
881		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 601 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885		_t = _retTree;
886		}
887		else {
888	<	goto _loop37;
888	>	goto _loop54;
889		}
890
891		}
892	<	_loop37:;
892	>	_loop54:;
893		} // ( ... )*
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
894	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895		match(_t,ENDBLOCK);
896		_t = _t->getNextSibling();
897	<	_t = __t35;
897	>	_t = __t52;
898		_t = _t->getNextSibling();
899	<	#line 133 "MDTreeParser.g"
899	>	#line 165 "MDTreeParser.g"
900
901		blockStack.top()->validate();
902		blockStack.pop();
903		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
904		currMoleculeStamp->addBendStamp(currBendStamp);
905
906	<	#line 623 "MDTreeParser.cpp"
906	>	#line 907 "MDTreeParser.cpp"
907		}
908		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909		reportError(ex);
#	Line 630 | Line 914 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
914		}
915
916		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
917	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
917	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
918
919		try {      // for error handling
920	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
921	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
920	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
921	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
922		match(_t,TORSION);
923		_t = _t->getFirstChild();
924	<	#line 150 "MDTreeParser.g"
924	>	#line 182 "MDTreeParser.g"
925		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926	<	#line 643 "MDTreeParser.cpp"
926	>	#line 927 "MDTreeParser.cpp"
927		{ // ( ... )*
928		for (;;) {
929		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 649 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933		_t = _retTree;
934		}
935		else {
936	<	goto _loop43;
936	>	goto _loop60;
937		}
938
939		}
940	<	_loop43:;
940	>	_loop60:;
941		} // ( ... )*
942	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
942	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943		match(_t,ENDBLOCK);
944		_t = _t->getNextSibling();
945	<	_t = __t41;
945	>	_t = __t58;
946		_t = _t->getNextSibling();
947	<	#line 152 "MDTreeParser.g"
947	>	#line 184 "MDTreeParser.g"
948
949		blockStack.top()->validate();
950		blockStack.pop();
951		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
952		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
953
954	<	#line 671 "MDTreeParser.cpp"
954	>	#line 955 "MDTreeParser.cpp"
955		}
956		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957		reportError(ex);
#	Line 677 | Line 961 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
961		_retTree = _t;
962		}
963
964	+	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
965	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
966	+
967	+	try {      // for error handling
968	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
969	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
970	+	match(_t,INVERSION);
971	+	_t = _t->getFirstChild();
972	+	#line 201 "MDTreeParser.g"
973	+	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974	+	#line 975 "MDTreeParser.cpp"
975	+	{ // ( ... )*
976	+	for (;;) {
977	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
978	+	_t = ASTNULL;
979	+	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
980	+	inversionstatement(_t);
981	+	_t = _retTree;
982	+	}
983	+	else {
984	+	goto _loop66;
985	+	}
986	+
987	+	}
988	+	_loop66:;
989	+	} // ( ... )*
990	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991	+	match(_t,ENDBLOCK);
992	+	_t = _t->getNextSibling();
993	+	_t = __t64;
994	+	_t = _t->getNextSibling();
995	+	#line 203 "MDTreeParser.g"
996	+
997	+	blockStack.top()->validate();
998	+	blockStack.pop();
999	+	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1000	+	currMoleculeStamp->addInversionStamp(currInversionStamp);
1001	+
1002	+	#line 1003 "MDTreeParser.cpp"
1003	+	}
1004	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005	+	reportError(ex);
1006	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1007	+	_t = _t->getNextSibling();
1008	+	}
1009	+	_retTree = _t;
1010	+	}
1011	+
1012		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014	<	#line 169 "MDTreeParser.g"
1013	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014	>	#line 220 "MDTreeParser.g"
1015
1016		int index;
1017
1018	<	#line 687 "MDTreeParser.cpp"
1018	>	#line 1019 "MDTreeParser.cpp"
1019
1020		try {      // for error handling
1021	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
1022	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
1021	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1022	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023		match(_t,RIGIDBODY);
1024		_t = _t->getFirstChild();
1025		index=intConst(_t);
1026		_t = _retTree;
1027	<	#line 173 "MDTreeParser.g"
1027	>	#line 224 "MDTreeParser.g"
1028		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029	<	#line 698 "MDTreeParser.cpp"
1029	>	#line 1030 "MDTreeParser.cpp"
1030		{ // ( ... )*
1031		for (;;) {
1032		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 704 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036		_t = _retTree;
1037		}
1038		else {
1039	<	goto _loop49;
1039	>	goto _loop72;
1040		}
1041
1042		}
1043	<	_loop49:;
1043	>	_loop72:;
1044		} // ( ... )*
1045	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
1045	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046		match(_t,ENDBLOCK);
1047		_t = _t->getNextSibling();
1048	<	_t = __t47;
1048	>	_t = __t70;
1049		_t = _t->getNextSibling();
1050	<	#line 175 "MDTreeParser.g"
1050	>	#line 226 "MDTreeParser.g"
1051
1052		blockStack.top()->validate();
1053		blockStack.pop();
1054		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1055		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1056
1057	<	#line 726 "MDTreeParser.cpp"
1057	>	#line 1058 "MDTreeParser.cpp"
1058		}
1059		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060		reportError(ex);
#	Line 733 | Line 1065 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1065		}
1066
1067		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1068	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1068	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069
1070		try {      // for error handling
1071	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
1072	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1071	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1072	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073		match(_t,CUTOFFGROUP);
1074		_t = _t->getFirstChild();
1075	<	#line 192 "MDTreeParser.g"
1075	>	#line 243 "MDTreeParser.g"
1076		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077	<	#line 746 "MDTreeParser.cpp"
1077	>	#line 1078 "MDTreeParser.cpp"
1078		{ // ( ... )*
1079		for (;;) {
1080		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 752 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084		_t = _retTree;
1085		}
1086		else {
1087	<	goto _loop55;
1087	>	goto _loop78;
1088		}
1089
1090		}
1091	<	_loop55:;
1091	>	_loop78:;
1092		} // ( ... )*
1093	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1093	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094		match(_t,ENDBLOCK);
1095		_t = _t->getNextSibling();
1096	<	_t = __t53;
1096	>	_t = __t76;
1097		_t = _t->getNextSibling();
1098	<	#line 194 "MDTreeParser.g"
1098	>	#line 245 "MDTreeParser.g"
1099
1100		blockStack.top()->validate();
1101		blockStack.pop();
1102		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1103		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1104
1105	<	#line 774 "MDTreeParser.cpp"
1105	>	#line 1106 "MDTreeParser.cpp"
1106		}
1107		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108		reportError(ex);
#	Line 781 | Line 1113 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1113		}
1114
1115		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117	<	#line 211 "MDTreeParser.g"
1116	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117	>	#line 262 "MDTreeParser.g"
1118		int ival;
1119	<	#line 788 "MDTreeParser.cpp"
1119	>	#line 1120 "MDTreeParser.cpp"
1120
1121		try {      // for error handling
1122	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1122	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1123	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124		match(_t,FRAGMENT);
1125		_t = _t->getFirstChild();
1126		ival=intConst(_t);
1127		_t = _retTree;
1128	<	#line 212 "MDTreeParser.g"
1128	>	#line 263 "MDTreeParser.g"
1129		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130	<	#line 799 "MDTreeParser.cpp"
1130	>	#line 1131 "MDTreeParser.cpp"
1131		{ // ( ... )*
1132		for (;;) {
1133		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 805 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137		_t = _retTree;
1138		}
1139		else {
1140	<	goto _loop61;
1140	>	goto _loop84;
1141		}
1142
1143		}
1144	<	_loop61:;
1144	>	_loop84:;
1145		} // ( ... )*
1146	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1146	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147		match(_t,ENDBLOCK);
1148		_t = _t->getNextSibling();
1149	<	_t = __t59;
1149	>	_t = __t82;
1150		_t = _t->getNextSibling();
1151	<	#line 214 "MDTreeParser.g"
1151	>	#line 265 "MDTreeParser.g"
1152
1153		blockStack.top()->validate();
1154		blockStack.pop();
1155		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1156		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1157
1158	<	#line 827 "MDTreeParser.cpp"
1158	>	#line 1159 "MDTreeParser.cpp"
1159		}
1160		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161		reportError(ex);
#	Line 834 | Line 1166 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1166		}
1167
1168		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1169	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170	<	#line 101 "MDTreeParser.g"
1169	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170	>	#line 133 "MDTreeParser.g"
1171
1172		vector<RealType> dvec;
1173		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174
1175
1176	<	#line 845 "MDTreeParser.cpp"
1176	>	#line 1177 "MDTreeParser.cpp"
1177
1178		try {      // for error handling
1179		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 855 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187		}
1188		case POSITION:
1189		{
1190	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
1191	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1190	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1191	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1192		match(_t,POSITION);
1193		_t = _t->getFirstChild();
1194		dvec=doubleNumberTuple(_t);
1195		_t = _retTree;
1196	<	_t = __t26;
1196	>	_t = __t43;
1197		_t = _t->getNextSibling();
1198	<	#line 108 "MDTreeParser.g"
1198	>	#line 140 "MDTreeParser.g"
1199		currAtomStamp->setPosition(dvec);
1200	<	#line 869 "MDTreeParser.cpp"
1200	>	#line 1201 "MDTreeParser.cpp"
1201		break;
1202		}
1203		case ORIENTATION:
1204		{
1205	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
1206	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1205	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1206	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1207		match(_t,ORIENTATION);
1208		_t = _t->getFirstChild();
1209		dvec=doubleNumberTuple(_t);
1210		_t = _retTree;
1211	<	_t = __t27;
1211	>	_t = __t44;
1212		_t = _t->getNextSibling();
1213	<	#line 109 "MDTreeParser.g"
1213	>	#line 141 "MDTreeParser.g"
1214		currAtomStamp->setOrientation(dvec);
1215	<	#line 884 "MDTreeParser.cpp"
1215	>	#line 1216 "MDTreeParser.cpp"
1216		break;
1217		}
1218		default:
#	Line 898 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230		}
1231
1232		vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233	<	#line 227 "MDTreeParser.g"
1233	>	#line 278 "MDTreeParser.g"
1234		vector<RealType> dvec;
1235	<	#line 904 "MDTreeParser.cpp"
1236	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237	<	#line 227 "MDTreeParser.g"
1235	>	#line 1236 "MDTreeParser.cpp"
1236	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237	>	#line 278 "MDTreeParser.g"
1238
1239		RealType dval;
1240
1241	<	#line 910 "MDTreeParser.cpp"
1241	>	#line 1242 "MDTreeParser.cpp"
1242
1243		try {      // for error handling
1244		{ // ( ... )+
1245	<	int _cnt65=0;
1245	>	int _cnt88=0;
1246		for (;;) {
1247		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248		_t = ASTNULL;
1249		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250		dval=doubleNumber(_t);
1251		_t = _retTree;
1252	<	#line 231 "MDTreeParser.g"
1252	>	#line 282 "MDTreeParser.g"
1253		dvec.push_back(dval);
1254	<	#line 923 "MDTreeParser.cpp"
1254	>	#line 1255 "MDTreeParser.cpp"
1255		}
1256		else {
1257	<	if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1257	>	if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258		}
1259
1260	<	_cnt65++;
1260	>	_cnt88++;
1261		}
1262	<	_loop65:;
1262	>	_loop88:;
1263		}  // ( ... )+
1264		}
1265		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 940 | Line 1272 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1272		}
1273
1274		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1275	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276	<	#line 122 "MDTreeParser.g"
1275	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276	>	#line 154 "MDTreeParser.g"
1277
1278		vector<int> ivec;
1279		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280
1281	<	#line 950 "MDTreeParser.cpp"
1281	>	#line 1282 "MDTreeParser.cpp"
1282
1283		try {      // for error handling
1284		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 960 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292		}
1293		case MEMBERS:
1294		{
1295	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1296	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1295	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1296	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1297		match(_t,MEMBERS);
1298		_t = _t->getFirstChild();
1299		ivec=inttuple(_t);
1300		_t = _retTree;
1301	<	_t = __t33;
1301	>	_t = __t50;
1302		_t = _t->getNextSibling();
1303	<	#line 128 "MDTreeParser.g"
1303	>	#line 160 "MDTreeParser.g"
1304		currBondStamp->setMembers(ivec);
1305	<	#line 974 "MDTreeParser.cpp"
1305	>	#line 1306 "MDTreeParser.cpp"
1306		break;
1307		}
1308		default:
#	Line 988 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320		}
1321
1322		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323	<	#line 234 "MDTreeParser.g"
1323	>	#line 286 "MDTreeParser.g"
1324		vector<int> ivec;
1325	<	#line 994 "MDTreeParser.cpp"
1326	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327	<	#line 234 "MDTreeParser.g"
1325	>	#line 1326 "MDTreeParser.cpp"
1326	>	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327	>	#line 286 "MDTreeParser.g"
1328
1329		int ival;
1330
1331	<	#line 1000 "MDTreeParser.cpp"
1331	>	#line 1332 "MDTreeParser.cpp"
1332
1333		try {      // for error handling
1334		{ // ( ... )+
1335	<	int _cnt68=0;
1335	>	int _cnt91=0;
1336		for (;;) {
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338		_t = ASTNULL;
1339		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340		ival=intConst(_t);
1341		_t = _retTree;
1342	<	#line 238 "MDTreeParser.g"
1342	>	#line 290 "MDTreeParser.g"
1343		ivec.push_back(ival);
1344	<	#line 1013 "MDTreeParser.cpp"
1344	>	#line 1345 "MDTreeParser.cpp"
1345		}
1346		else {
1347	<	if ( _cnt68>=1 ) { goto _loop68; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1347	>	if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348		}
1349
1350	<	_cnt68++;
1350	>	_cnt91++;
1351		}
1352	<	_loop68:;
1352	>	_loop91:;
1353		}  // ( ... )+
1354		}
1355		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1030 | Line 1362 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1362		}
1363
1364		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1365	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366	<	#line 141 "MDTreeParser.g"
1365	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366	>	#line 173 "MDTreeParser.g"
1367
1368		vector<int> ivec;
1369		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370
1371	<	#line 1040 "MDTreeParser.cpp"
1371	>	#line 1372 "MDTreeParser.cpp"
1372
1373		try {      // for error handling
1374		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1050 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382		}
1383		case MEMBERS:
1384		{
1385	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1386	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1385	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1386	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1387		match(_t,MEMBERS);
1388		_t = _t->getFirstChild();
1389		ivec=inttuple(_t);
1390		_t = _retTree;
1391	<	_t = __t39;
1391	>	_t = __t56;
1392		_t = _t->getNextSibling();
1393	<	#line 147 "MDTreeParser.g"
1393	>	#line 179 "MDTreeParser.g"
1394		currBendStamp->setMembers(ivec);
1395	<	#line 1064 "MDTreeParser.cpp"
1395	>	#line 1396 "MDTreeParser.cpp"
1396		break;
1397		}
1398		default:
#	Line 1078 | Line 1410 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1410		}
1411
1412		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1413	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414	<	#line 160 "MDTreeParser.g"
1413	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414	>	#line 192 "MDTreeParser.g"
1415
1416		vector<int> ivec;
1417		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418
1419	<	#line 1088 "MDTreeParser.cpp"
1419	>	#line 1420 "MDTreeParser.cpp"
1420
1421		try {      // for error handling
1422		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1098 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430		}
1431		case MEMBERS:
1432		{
1433	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1434	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1433	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1434	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1435		match(_t,MEMBERS);
1436		_t = _t->getFirstChild();
1437		ivec=inttuple(_t);
1438		_t = _retTree;
1439	<	_t = __t45;
1439	>	_t = __t62;
1440		_t = _t->getNextSibling();
1441	<	#line 166 "MDTreeParser.g"
1441	>	#line 198 "MDTreeParser.g"
1442		currTorsionStamp->setMembers(ivec);
1443	<	#line 1112 "MDTreeParser.cpp"
1443	>	#line 1444 "MDTreeParser.cpp"
1444		break;
1445		}
1446		default:
#	Line 1125 | Line 1457 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1457		_retTree = _t;
1458		}
1459
1460	<	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462	<	#line 183 "MDTreeParser.g"
1460	>	void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461	>	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462	>	#line 211 "MDTreeParser.g"
1463
1464	<	vector<int> ivec;
1465	<	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1464	>	int icent;
1465	>	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466
1467	<	#line 1136 "MDTreeParser.cpp"
1467	>	#line 1468 "MDTreeParser.cpp"
1468
1469		try {      // for error handling
1470		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1144 | Line 1476 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1476		_t = _retTree;
1477		break;
1478		}
1479	<	case MEMBERS:
1479	>	case CENTER:
1480		{
1481	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1482	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1483	<	match(_t,MEMBERS);
1481	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1482	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1483	>	match(_t,CENTER);
1484		_t = _t->getFirstChild();
1485	<	ivec=inttuple(_t);
1485	>	icent=intConst(_t);
1486		_t = _retTree;
1487	<	_t = __t51;
1487	>	_t = __t68;
1488		_t = _t->getNextSibling();
1489	<	#line 189 "MDTreeParser.g"
1490	<	currRigidBodyStamp->setMembers(ivec);
1491	<	#line 1160 "MDTreeParser.cpp"
1489	>	#line 217 "MDTreeParser.g"
1490	>	currInversionStamp->setCenter(icent);
1491	>	#line 1492 "MDTreeParser.cpp"
1492		break;
1493		}
1494		default:
#	Line 1173 | Line 1505 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1505		_retTree = _t;
1506		}
1507
1508	<	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510	<	#line 202 "MDTreeParser.g"
1508	>	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510	>	#line 234 "MDTreeParser.g"
1511
1512		vector<int> ivec;
1513	<	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1513	>	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514
1515	<	#line 1184 "MDTreeParser.cpp"
1515	>	#line 1516 "MDTreeParser.cpp"
1516
1517		try {      // for error handling
1518		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1194 | Line 1526 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1526		}
1527		case MEMBERS:
1528		{
1529	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1530	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1529	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1530	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1531		match(_t,MEMBERS);
1532		_t = _t->getFirstChild();
1533		ivec=inttuple(_t);
1534		_t = _retTree;
1535	<	_t = __t57;
1535	>	_t = __t74;
1536		_t = _t->getNextSibling();
1537	<	#line 208 "MDTreeParser.g"
1538	<	currCutoffGroupStamp->setMembers(ivec);
1539	<	#line 1208 "MDTreeParser.cpp"
1537	>	#line 240 "MDTreeParser.g"
1538	>	currRigidBodyStamp->setMembers(ivec);
1539	>	#line 1540 "MDTreeParser.cpp"
1540		break;
1541		}
1542		default:
#	Line 1212 | Line 1544 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1544		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1545		}
1546		}
1215	–	}
1216	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1217	–	reportError(ex);
1218	–	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1219	–	_t = _t->getNextSibling();
1547		}
1221	–	_retTree = _t;
1222	–	}
1223	–
1224	–	void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1225	–	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1226	–
1227	–	try {      // for error handling
1228	–	assignment(_t);
1229	–	_t = _retTree;
1230	–	}
1548		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1549		reportError(ex);
1550		if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1236 | Line 1553 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1553		_retTree = _t;
1554		}
1555
1556	<	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557	<	#line 248 "MDTreeParser.g"
1558	<	RealType dval;
1242	<	#line 1243 "MDTreeParser.cpp"
1243	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1244	<	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1245	<	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1556	>	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1558	>	#line 253 "MDTreeParser.g"
1559
1560	+	vector<int> ivec;
1561	+	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562	+
1563	+	#line 1564 "MDTreeParser.cpp"
1564	+
1565		try {      // for error handling
1566		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1567		_t = ASTNULL;
1568		switch ( _t->getType()) {
1569	<	case NUM_INT:
1252	<	case NUM_LONG:
1569	>	case ASSIGNEQUAL:
1570		{
1571	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1255	<	intConst(_t);
1571	>	assignment(_t);
1572		_t = _retTree;
1257	–	#line 250 "MDTreeParser.g"
1258	–	dval = lexi_cast<RealType>(ic->getText());
1259	–	#line 1260 "MDTreeParser.cpp"
1573		break;
1574		}
1575	<	case NUM_FLOAT:
1263	<	case NUM_DOUBLE:
1575	>	case MEMBERS:
1576		{
1577	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1578	<	floatConst(_t);
1577	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1578	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1579	>	match(_t,MEMBERS);
1580	>	_t = _t->getFirstChild();
1581	>	ivec=inttuple(_t);
1582		_t = _retTree;
1583	<	#line 251 "MDTreeParser.g"
1584	<	dval = lexi_cast<RealType>(fc->getText());
1585	<	#line 1271 "MDTreeParser.cpp"
1583	>	_t = __t80;
1584	>	_t = _t->getNextSibling();
1585	>	#line 259 "MDTreeParser.g"
1586	>	currCutoffGroupStamp->setMembers(ivec);
1587	>	#line 1588 "MDTreeParser.cpp"
1588		break;
1589		}
1590		default:
#	Line 1282 | Line 1599 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1599		_t = _t->getNextSibling();
1600		}
1601		_retTree = _t;
1285	–	return dval;
1602		}
1603
1604	+	void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1605	+	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1606	+
1607	+	try {      // for error handling
1608	+	assignment(_t);
1609	+	_t = _retTree;
1610	+	}
1611	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1612	+	reportError(ex);
1613	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1614	+	_t = _t->getNextSibling();
1615	+	}
1616	+	_retTree = _t;
1617	+	}
1618	+
1619		void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620		{
1621		}
#	Line 1296 | Line 1627 | const char* MDTreeParser::tokenNames[] = {
1627		"\"component\"",
1628		"\"molecule\"",
1629		"\"zconstraint\"",
1630	+	"\"restraint\"",
1631		"\"atom\"",
1632		"\"bond\"",
1633		"\"bend\"",
1634		"\"torsion\"",
1635	+	"\"inversion\"",
1636		"\"rigidBody\"",
1637		"\"cutoffGroup\"",
1638		"\"fragment\"",
1639		"\"members\"",
1640	+	"\"center\"",
1641		"\"position\"",
1642		"\"orientation\"",
1643	+	"\"flucQ\"",
1644	+	"\"RNEMD\"",
1645	+	"\"minimizer\"",
1646		"ENDBLOCK",
1647		"ID",
1648		"ASSIGNEQUAL",
#	Line 1343 | Line 1680 | const char* MDTreeParser::tokenNames[] = {
1680		0
1681		};
1682
1683	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1684	<	// "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"
1683	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1684	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1685		// ASSIGNEQUAL
1686	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1687	+	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1688	+	// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1689	+	// "fragment" ASSIGNEQUAL
1690		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1691
1692

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

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

Diff Legend

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