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 770 by tim, Fri Dec 2 15:38:03 2005 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 __t13 = _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 69 "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 _loop15;
160	>	goto _loop12;
161		}
162
163		}
164	<	_loop15:;
164	>	_loop12:;
165		} // ( ... )*
166		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167		match(_t,ENDBLOCK);
168		_t = _t->getNextSibling();
169	<	_t = __t13;
169	>	_t = __t10;
170		_t = _t->getNextSibling();
171	<	#line 71 "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 __t21 = _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 79 "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 _loop23;
203	>	goto _loop36;
204		}
205
206		}
207	<	_loop23:;
207	>	_loop36:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t21;
212	>	_t = __t34;
213		_t = _t->getNextSibling();
214	<	#line 81 "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 __t17 = _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 74 "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 _loop19;
246	>	goto _loop16;
247		}
248
249		}
250	<	_loop19:;
250	>	_loop16:;
251		} // ( ... )*
252		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253		match(_t,ENDBLOCK);
254		_t = _t->getNextSibling();
255	<	_t = __t17;
255	>	_t = __t14;
256		_t = _t->getNextSibling();
257	<	#line 76 "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 50 "MDTreeParser.g"
448
449	+	int ival;
450	+	RealType dval, x, y, z;
451	+	std::vector<RealType> dvec;
452	+
453	+	#line 454 "MDTreeParser.cpp"
454	+
455		try {      // for error handling
456		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
457		_t = ASTNULL;
458		switch ( _t->getType()) {
459	<	case OCTALINT:
460	<	case DECIMALINT:
258	<	case HEXADECIMALINT:
259	<	case MINUS:
260	<	case FLOATONE:
261	<	case FLOATTWO:
459	>	case NUM_INT:
460	>	case NUM_LONG:
461		{
462	<	signedIntOrFloat(_t,id);
462	>	ival=intConst(_t);
463		_t = _retTree;
464	+	#line 56 "MDTreeParser.g"
465	+	blockStack.top()->assign(id->getText(), ival);
466	+	#line 467 "MDTreeParser.cpp"
467		break;
468		}
469	+	case NUM_FLOAT:
470	+	case NUM_DOUBLE:
471	+	{
472	+	dval=floatConst(_t);
473	+	_t = _retTree;
474	+	#line 57 "MDTreeParser.g"
475	+	blockStack.top()->assign(id->getText(), dval);
476	+	#line 477 "MDTreeParser.cpp"
477	+	break;
478	+	}
479		case ID:
480		{
481		str1 = _t;
482		match(_t,ID);
483		_t = _t->getNextSibling();
484	<	#line 49 "MDTreeParser.g"
484	>	#line 58 "MDTreeParser.g"
485		blockStack.top()->assign(id->getText(), str1->getText());
486	<	#line 275 "MDTreeParser.cpp"
486	>	#line 487 "MDTreeParser.cpp"
487		break;
488		}
489		case StringLiteral:
#	Line 279 | Line 491 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
491		str2 = _t;
492		match(_t,StringLiteral);
493		_t = _t->getNextSibling();
494	<	#line 50 "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 288 "MDTreeParser.cpp"
499	>	#line 500 "MDTreeParser.cpp"
500		break;
501		}
502	<	default:
502	>	case LPAREN:
503		{
504	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
505	<	}
506	<	}
295	<	}
296	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
297	<	reportError(ex);
298	<	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
299	<	_t = _t->getNextSibling();
300	<	}
301	<	_retTree = _t;
302	<	}
303	<
304	<	void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
305	<	ANTLR_USE_NAMESPACE(antlr)RefAST id
306	<	) {
307	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedIntOrFloat_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
308	<	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
309	<	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
310	<	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
311	<	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
312	<	#line 56 "MDTreeParser.g"
313	<
314	<	int ival;
315	<	double dval;
316	<
317	<	#line 318 "MDTreeParser.cpp"
318	<
319	<	try {      // for error handling
320	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
321	<	_t = ASTNULL;
322	<	switch ( _t->getType()) {
323	<	case MINUS:
324	<	{
325	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
326	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
327	<	match(_t,MINUS);
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	<	{
509	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
510	<	_t = ASTNULL;
511	<	switch ( _t->getType()) {
333	<	case OCTALINT:
334	<	case DECIMALINT:
335	<	case HEXADECIMALINT:
336	<	{
337	<	icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
338	<	intConst(_t);
339	<	_t = _retTree;
340	<	#line 61 "MDTreeParser.g"
341	<	ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);
342	<	#line 343 "MDTreeParser.cpp"
343	<	break;
344	<	}
345	<	case FLOATONE:
346	<	case FLOATTWO:
347	<	{
348	<	fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
349	<	floatConst(_t);
350	<	_t = _retTree;
351	<	break;
352	<	}
353	<	default:
354	<	{
355	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
356	<	}
357	<	}
358	<	}
359	<	#line 62 "MDTreeParser.g"
360	<	dval = lexi_cast<double>(fcMinus->getText());dval = -dval;  blockStack.top()->assign(id->getText(), dval);
361	<	#line 362 "MDTreeParser.cpp"
362	<	_t = __t9;
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	<	break;
514	<	}
366	<	case OCTALINT:
367	<	case DECIMALINT:
368	<	case HEXADECIMALINT:
369	<	case FLOATONE:
370	<	case FLOATTWO:
371	<	{
372	<	{
373	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
374	<	_t = ASTNULL;
375	<	switch ( _t->getType()) {
376	<	case OCTALINT:
377	<	case DECIMALINT:
378	<	case HEXADECIMALINT:
379	<	{
380	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
381	<	intConst(_t);
382	<	_t = _retTree;
513	>	_t = __t8;
514	>	_t = _t->getNextSibling();
515		#line 64 "MDTreeParser.g"
516	<	ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);
517	<	#line 386 "MDTreeParser.cpp"
518	<	break;
519	<	}
388	<	case FLOATONE:
389	<	case FLOATTWO:
390	<	{
391	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
392	<	floatConst(_t);
393	<	_t = _retTree;
394	<	#line 65 "MDTreeParser.g"
395	<	dval = lexi_cast<double>(fc->getText());  blockStack.top()->assign(id->getText(), dval);
396	<	#line 397 "MDTreeParser.cpp"
397	<	break;
398	<	}
399	<	default:
400	<	{
401	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
402	<	}
403	<	}
404	<	}
516	>
517	>	blockStack.top()->assign(id->getText(), dvec);
518	>
519	>	#line 520 "MDTreeParser.cpp"
520		break;
521		}
522		default:
#	Line 419 | Line 534 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
534		}
535
536		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
537	<	#line 249 "MDTreeParser.g"
537	>	#line 312 "MDTreeParser.g"
538		int ival;
539	<	#line 425 "MDTreeParser.cpp"
540	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
541	<	ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
542	<	ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
428	<	ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
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
544		try {      // for error handling
545		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
546		_t = ASTNULL;
547		switch ( _t->getType()) {
548	<	case OCTALINT:
548	>	case NUM_INT:
549		{
550	<	oival = _t;
551	<	match(_t,OCTALINT);
550	>	i1 = _t;
551	>	match(_t,NUM_INT);
552		_t = _t->getNextSibling();
553	<	#line 250 "MDTreeParser.g"
554	<	ival = lexi_cast<int>(oival->getText());
555	<	#line 442 "MDTreeParser.cpp"
553	>	#line 313 "MDTreeParser.g"
554	>	ival = lexi_cast<int>(i1->getText());
555	>	#line 556 "MDTreeParser.cpp"
556		break;
557		}
558	<	case DECIMALINT:
558	>	case NUM_LONG:
559		{
560	<	dival = _t;
561	<	match(_t,DECIMALINT);
560	>	i2 = _t;
561	>	match(_t,NUM_LONG);
562		_t = _t->getNextSibling();
563	<	#line 251 "MDTreeParser.g"
564	<	ival = lexi_cast<int>(dival->getText());
565	<	#line 452 "MDTreeParser.cpp"
563	>	#line 314 "MDTreeParser.g"
564	>	ival = lexi_cast<int>(i2->getText());
565	>	#line 566 "MDTreeParser.cpp"
566		break;
567		}
454	–	case HEXADECIMALINT:
455	–	{
456	–	hival = _t;
457	–	match(_t,HEXADECIMALINT);
458	–	_t = _t->getNextSibling();
459	–	#line 252 "MDTreeParser.g"
460	–	ival = lexi_cast<int>(hival->getText());
461	–	#line 462 "MDTreeParser.cpp"
462	–	break;
463	–	}
568		default:
569		{
570		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 476 | Line 580 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
580		return ival;
581		}
582
583	<	double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
584	<	#line 266 "MDTreeParser.g"
585	<	double dval;
586	<	#line 483 "MDTreeParser.cpp"
587	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
583	>	RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
584	>	#line 324 "MDTreeParser.g"
585	>	RealType dval;
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 488 | Line 592 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
592		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
593		_t = ASTNULL;
594		switch ( _t->getType()) {
595	<	case FLOATONE:
595	>	case NUM_FLOAT:
596		{
597		d1 = _t;
598	<	match(_t,FLOATONE);
598	>	match(_t,NUM_FLOAT);
599		_t = _t->getNextSibling();
600	<	#line 267 "MDTreeParser.g"
601	<	dval = lexi_cast<double>(d1->getText());
602	<	#line 499 "MDTreeParser.cpp"
600	>	#line 325 "MDTreeParser.g"
601	>	dval = lexi_cast<RealType>(d1->getText());
602	>	#line 603 "MDTreeParser.cpp"
603		break;
604		}
605	<	case FLOATTWO:
605	>	case NUM_DOUBLE:
606		{
607		d2 = _t;
608	<	match(_t,FLOATTWO);
608	>	match(_t,NUM_DOUBLE);
609		_t = _t->getNextSibling();
610	<	#line 268 "MDTreeParser.g"
611	<	dval = lexi_cast<double>(d2->getText());
612	<	#line 509 "MDTreeParser.cpp"
610	>	#line 326 "MDTreeParser.g"
611	>	dval = lexi_cast<RealType>(d2->getText());
612	>	#line 613 "MDTreeParser.cpp"
613		break;
614		}
615		default:
#	Line 521 | Line 625 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
625		}
626		_retTree = _t;
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 560 | 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 578 | 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 593 | 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 94 "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 602 "MDTreeParser.cpp"
759	>	#line 760 "MDTreeParser.cpp"
760
761		try {      // for error handling
762	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
763	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_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 98 "MDTreeParser.g"
768	>	#line 122 "MDTreeParser.g"
769		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
770	<	#line 613 "MDTreeParser.cpp"
770	>	#line 771 "MDTreeParser.cpp"
771		{ // ( ... )*
772		for (;;) {
773		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 619 | Line 777 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
777		_t = _retTree;
778		}
779		else {
780	<	goto _loop28;
780	>	goto _loop41;
781		}
782
783		}
784	<	_loop28:;
784	>	_loop41:;
785		} // ( ... )*
786	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
786	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
787		match(_t,ENDBLOCK);
788		_t = _t->getNextSibling();
789	<	_t = __t26;
789	>	_t = __t39;
790		_t = _t->getNextSibling();
791	<	#line 100 "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 641 "MDTreeParser.cpp"
798	>	#line 799 "MDTreeParser.cpp"
799		}
800		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
801		reportError(ex);
#	Line 648 | 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 __t33 = _t;
813	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_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 120 "MDTreeParser.g"
816	>	#line 144 "MDTreeParser.g"
817		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
818	<	#line 661 "MDTreeParser.cpp"
818	>	#line 819 "MDTreeParser.cpp"
819		{ // ( ... )*
820		for (;;) {
821		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 667 | Line 825 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
825		_t = _retTree;
826		}
827		else {
828	<	goto _loop35;
828	>	goto _loop48;
829		}
830
831		}
832	<	_loop35:;
832	>	_loop48:;
833		} // ( ... )*
834	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
834	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
835		match(_t,ENDBLOCK);
836		_t = _t->getNextSibling();
837	<	_t = __t33;
837	>	_t = __t46;
838		_t = _t->getNextSibling();
839	<	#line 122 "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 688 "MDTreeParser.cpp"
845	>	#line 846 "MDTreeParser.cpp"
846		}
847		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
848		reportError(ex);
#	Line 695 | 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 __t39 = _t;
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_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 138 "MDTreeParser.g"
863	>	#line 162 "MDTreeParser.g"
864		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
865	<	#line 708 "MDTreeParser.cpp"
865	>	#line 866 "MDTreeParser.cpp"
866		{ // ( ... )*
867		for (;;) {
868		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 714 | Line 872 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
872		_t = _retTree;
873		}
874		else {
875	<	goto _loop41;
875	>	goto _loop54;
876		}
877
878		}
879	<	_loop41:;
879	>	_loop54:;
880		} // ( ... )*
881	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
881	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
882		match(_t,ENDBLOCK);
883		_t = _t->getNextSibling();
884	<	_t = __t39;
884	>	_t = __t52;
885		_t = _t->getNextSibling();
886	<	#line 140 "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 736 "MDTreeParser.cpp"
893	>	#line 894 "MDTreeParser.cpp"
894		}
895		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
896		reportError(ex);
#	Line 743 | 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 __t45 = _t;
908	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_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 157 "MDTreeParser.g"
911	>	#line 181 "MDTreeParser.g"
912		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
913	<	#line 756 "MDTreeParser.cpp"
913	>	#line 914 "MDTreeParser.cpp"
914		{ // ( ... )*
915		for (;;) {
916		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 762 | Line 920 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
920		_t = _retTree;
921		}
922		else {
923	<	goto _loop47;
923	>	goto _loop60;
924		}
925
926		}
927	<	_loop47:;
927	>	_loop60:;
928		} // ( ... )*
929	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
929	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
930		match(_t,ENDBLOCK);
931		_t = _t->getNextSibling();
932	<	_t = __t45;
932	>	_t = __t58;
933		_t = _t->getNextSibling();
934	<	#line 159 "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 784 "MDTreeParser.cpp"
941	>	#line 942 "MDTreeParser.cpp"
942		}
943		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944		reportError(ex);
#	Line 790 | Line 948 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
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);
993	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
994	+	_t = _t->getNextSibling();
995	+	}
996	+	_retTree = _t;
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 176 "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 800 "MDTreeParser.cpp"
1005	>	#line 1006 "MDTreeParser.cpp"
1006
1007		try {      // for error handling
1008	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1009	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_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 180 "MDTreeParser.g"
1014	>	#line 225 "MDTreeParser.g"
1015		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1016	<	#line 811 "MDTreeParser.cpp"
1016	>	#line 1017 "MDTreeParser.cpp"
1017		{ // ( ... )*
1018		for (;;) {
1019		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 817 | Line 1023 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1023		_t = _retTree;
1024		}
1025		else {
1026	<	goto _loop53;
1026	>	goto _loop73;
1027		}
1028
1029		}
1030	<	_loop53:;
1030	>	_loop73:;
1031		} // ( ... )*
1032	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1032	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1033		match(_t,ENDBLOCK);
1034		_t = _t->getNextSibling();
1035	<	_t = __t51;
1035	>	_t = __t71;
1036		_t = _t->getNextSibling();
1037	<	#line 182 "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 839 "MDTreeParser.cpp"
1044	>	#line 1045 "MDTreeParser.cpp"
1045		}
1046		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047		reportError(ex);
#	Line 846 | 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 __t57 = _t;
1059	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_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 199 "MDTreeParser.g"
1062	>	#line 244 "MDTreeParser.g"
1063		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1064	<	#line 859 "MDTreeParser.cpp"
1064	>	#line 1065 "MDTreeParser.cpp"
1065		{ // ( ... )*
1066		for (;;) {
1067		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 865 | Line 1071 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1071		_t = _retTree;
1072		}
1073		else {
1074	<	goto _loop59;
1074	>	goto _loop79;
1075		}
1076
1077		}
1078	<	_loop59:;
1078	>	_loop79:;
1079		} // ( ... )*
1080	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1080	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1081		match(_t,ENDBLOCK);
1082		_t = _t->getNextSibling();
1083	<	_t = __t57;
1083	>	_t = __t77;
1084		_t = _t->getNextSibling();
1085	<	#line 201 "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 887 "MDTreeParser.cpp"
1092	>	#line 1093 "MDTreeParser.cpp"
1093		}
1094		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1095		reportError(ex);
#	Line 894 | 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 218 "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 901 "MDTreeParser.cpp"
1106	>	#line 1107 "MDTreeParser.cpp"
1107
1108		try {      // for error handling
1109	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1110	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_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 219 "MDTreeParser.g"
1115	>	#line 264 "MDTreeParser.g"
1116		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1117	<	#line 912 "MDTreeParser.cpp"
1117	>	#line 1118 "MDTreeParser.cpp"
1118		{ // ( ... )*
1119		for (;;) {
1120		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 918 | Line 1124 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1124		_t = _retTree;
1125		}
1126		else {
1127	<	goto _loop65;
1127	>	goto _loop85;
1128		}
1129
1130		}
1131	<	_loop65:;
1131	>	_loop85:;
1132		} // ( ... )*
1133	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1133	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1134		match(_t,ENDBLOCK);
1135		_t = _t->getNextSibling();
1136	<	_t = __t63;
1136	>	_t = __t83;
1137		_t = _t->getNextSibling();
1138	<	#line 221 "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 940 "MDTreeParser.cpp"
1145	>	#line 1146 "MDTreeParser.cpp"
1146		}
1147		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1148		reportError(ex);
#	Line 946 | Line 1152 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
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);
1196	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1197	+	_t = _t->getNextSibling();
1198	+	}
1199	+	_retTree = _t;
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 108 "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<double> dvec;
1206	>	vector<RealType> dvec;
1207		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1208
1209
1210	<	#line 958 "MDTreeParser.cpp"
1210	>	#line 1211 "MDTreeParser.cpp"
1211
1212		try {      // for error handling
1213		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 968 | Line 1221 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1221		}
1222		case POSITION:
1223		{
1224	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1225	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_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=signedNumberTuple(_t);
1228	>	dvec=doubleNumberTuple(_t);
1229		_t = _retTree;
1230	<	_t = __t30;
1230	>	_t = __t43;
1231		_t = _t->getNextSibling();
1232	<	#line 115 "MDTreeParser.g"
1232	>	#line 139 "MDTreeParser.g"
1233		currAtomStamp->setPosition(dvec);
1234	<	#line 982 "MDTreeParser.cpp"
1234	>	#line 1235 "MDTreeParser.cpp"
1235		break;
1236		}
1237		case ORIENTATION:
1238		{
1239	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1240	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_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=signedNumberTuple(_t);
1243	>	dvec=doubleNumberTuple(_t);
1244		_t = _retTree;
1245	<	_t = __t31;
1245	>	_t = __t44;
1246		_t = _t->getNextSibling();
1247	<	#line 116 "MDTreeParser.g"
1247	>	#line 140 "MDTreeParser.g"
1248		currAtomStamp->setOrientation(dvec);
1249	<	#line 997 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250		break;
1251		}
1252		default:
#	Line 1010 | Line 1263 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1263		_retTree = _t;
1264		}
1265
1013	–	vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1014	–	#line 234 "MDTreeParser.g"
1015	–	vector<double> dvec;
1016	–	#line 1017 "MDTreeParser.cpp"
1017	–	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1018	–	#line 234 "MDTreeParser.g"
1019	–
1020	–	double dval;
1021	–
1022	–	#line 1023 "MDTreeParser.cpp"
1023	–
1024	–	try {      // for error handling
1025	–	{ // ( ... )+
1026	–	int _cnt69=0;
1027	–	for (;;) {
1028	–	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1029	–	_t = ASTNULL;
1030	–	if ((_tokenSet_2.member(_t->getType()))) {
1031	–	dval=signedNumber(_t);
1032	–	_t = _retTree;
1033	–	#line 238 "MDTreeParser.g"
1034	–	dvec.push_back(dval);
1035	–	#line 1036 "MDTreeParser.cpp"
1036	–	}
1037	–	else {
1038	–	if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1039	–	}
1040	–
1041	–	_cnt69++;
1042	–	}
1043	–	_loop69:;
1044	–	}  // ( ... )+
1045	–	}
1046	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047	–	reportError(ex);
1048	–	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1049	–	_t = _t->getNextSibling();
1050	–	}
1051	–	_retTree = _t;
1052	–	return dvec;
1053	–	}
1054	–
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 129 "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 1063 "MDTreeParser.cpp"
1273	>	#line 1274 "MDTreeParser.cpp"
1274
1275		try {      // for error handling
1276		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1073 | Line 1284 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1284		}
1285		case MEMBERS:
1286		{
1287	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1288	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_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 = __t37;
1293	>	_t = __t50;
1294		_t = _t->getNextSibling();
1295	<	#line 135 "MDTreeParser.g"
1295	>	#line 159 "MDTreeParser.g"
1296		currBondStamp->setMembers(ivec);
1297	<	#line 1087 "MDTreeParser.cpp"
1297	>	#line 1298 "MDTreeParser.cpp"
1298		break;
1299		}
1300		default:
#	Line 1101 | Line 1312 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1312		}
1313
1314		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1315	<	#line 241 "MDTreeParser.g"
1315	>	#line 304 "MDTreeParser.g"
1316		vector<int> ivec;
1317	<	#line 1107 "MDTreeParser.cpp"
1318	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1319	<	#line 241 "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 1113 "MDTreeParser.cpp"
1323	>	#line 1324 "MDTreeParser.cpp"
1324
1325		try {      // for error handling
1326		{ // ( ... )+
1327	<	int _cnt72=0;
1327	>	int _cnt98=0;
1328		for (;;) {
1329		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1330		_t = ASTNULL;
1331	<	if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1331	>	if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1332		ival=intConst(_t);
1333		_t = _retTree;
1334	<	#line 245 "MDTreeParser.g"
1334	>	#line 308 "MDTreeParser.g"
1335		ivec.push_back(ival);
1336	<	#line 1126 "MDTreeParser.cpp"
1336	>	#line 1337 "MDTreeParser.cpp"
1337		}
1338		else {
1339	<	if ( _cnt72>=1 ) { goto _loop72; } 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	<	_cnt72++;
1342	>	_cnt98++;
1343		}
1344	<	_loop72:;
1344	>	_loop98:;
1345		}  // ( ... )+
1346		}
1347		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1143 | 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 148 "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 1153 "MDTreeParser.cpp"
1363	>	#line 1364 "MDTreeParser.cpp"
1364
1365		try {      // for error handling
1366		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1163 | Line 1374 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1374		}
1375		case MEMBERS:
1376		{
1377	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1378	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_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 = __t43;
1383	>	_t = __t56;
1384		_t = _t->getNextSibling();
1385	<	#line 154 "MDTreeParser.g"
1385	>	#line 178 "MDTreeParser.g"
1386		currBendStamp->setMembers(ivec);
1387	<	#line 1177 "MDTreeParser.cpp"
1387	>	#line 1388 "MDTreeParser.cpp"
1388		break;
1389		}
1390		default:
#	Line 1191 | 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 167 "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 1201 "MDTreeParser.cpp"
1411	>	#line 1412 "MDTreeParser.cpp"
1412
1413		try {      // for error handling
1414		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1211 | Line 1422 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1422		}
1423		case MEMBERS:
1424		{
1425	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1426	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_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 = __t49;
1431	>	_t = __t62;
1432		_t = _t->getNextSibling();
1433	<	#line 173 "MDTreeParser.g"
1433	>	#line 197 "MDTreeParser.g"
1434		currTorsionStamp->setMembers(ivec);
1435	<	#line 1225 "MDTreeParser.cpp"
1435	>	#line 1436 "MDTreeParser.cpp"
1436	>	break;
1437	>	}
1438	>	default:
1439	>	{
1440	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1441	>	}
1442	>	}
1443	>	}
1444	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1445	>	reportError(ex);
1446	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1447	>	_t = _t->getNextSibling();
1448	>	}
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);
#	Line 1239 | Line 1514 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
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 190 "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 1249 "MDTreeParser.cpp"
1523	>	#line 1524 "MDTreeParser.cpp"
1524
1525		try {      // for error handling
1526		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1259 | Line 1534 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1534		}
1535		case MEMBERS:
1536		{
1537	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1538	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 = __t55;
1543	>	_t = __t75;
1544		_t = _t->getNextSibling();
1545	<	#line 196 "MDTreeParser.g"
1545	>	#line 241 "MDTreeParser.g"
1546		currRigidBodyStamp->setMembers(ivec);
1547	<	#line 1273 "MDTreeParser.cpp"
1547	>	#line 1548 "MDTreeParser.cpp"
1548		break;
1549		}
1550		default:
#	Line 1287 | 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 209 "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 1297 "MDTreeParser.cpp"
1571	>	#line 1572 "MDTreeParser.cpp"
1572
1573		try {      // for error handling
1574		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1307 | Line 1582 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1582		}
1583		case MEMBERS:
1584		{
1585	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1586	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_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 = __t61;
1591	>	_t = __t81;
1592		_t = _t->getNextSibling();
1593	<	#line 215 "MDTreeParser.g"
1593	>	#line 260 "MDTreeParser.g"
1594		currCutoffGroupStamp->setMembers(ivec);
1595	<	#line 1321 "MDTreeParser.cpp"
1595	>	#line 1596 "MDTreeParser.cpp"
1596		break;
1597		}
1598		default:
#	Line 1335 | 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 1349 | Line 1624 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1624		_retTree = _t;
1625		}
1626
1627	<	double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1628	<	#line 256 "MDTreeParser.g"
1629	<	double dval;
1355	<	#line 1356 "MDTreeParser.cpp"
1356	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357	<	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
1358	<	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
1359	<	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1360	<	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
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 MINUS:
1640	>	case ASSIGNEQUAL:
1641		{
1642	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1643	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1644	<	match(_t,MINUS);
1645	<	_t = _t->getFirstChild();
1646	<	{
1647	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1648	<	_t = ASTNULL;
1649	<	switch ( _t->getType()) {
1650	<	case OCTALINT:
1651	<	case DECIMALINT:
1652	<	case HEXADECIMALINT:
1653	<	{
1654	<	icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1381	<	intConst(_t);
1382	<	_t = _retTree;
1383	<	#line 257 "MDTreeParser.g"
1384	<	dval = lexi_cast<double>(icMinus->getText()); dval = -dval;
1385	<	#line 1386 "MDTreeParser.cpp"
1386	<	break;
1387	<	}
1388	<	case FLOATONE:
1389	<	case FLOATTWO:
1390	<	{
1391	<	fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1392	<	floatConst(_t);
1393	<	_t = _retTree;
1394	<	break;
1395	<	}
1396	<	default:
1397	<	{
1398	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1399	<	}
1400	<	}
1401	<	}
1402	<	#line 258 "MDTreeParser.g"
1403	<	dval = lexi_cast<double>(fcMinus->getText());dval = -dval;
1404	<	#line 1405 "MDTreeParser.cpp"
1405	<	_t = __t75;
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	<	case OCTALINT:
1410	<	case DECIMALINT:
1411	<	case HEXADECIMALINT:
1412	<	case FLOATONE:
1413	<	case FLOATTWO:
1661	>	default:
1662		{
1663	<	{
1664	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1665	<	_t = ASTNULL;
1666	<	switch ( _t->getType()) {
1667	<	case OCTALINT:
1668	<	case DECIMALINT:
1669	<	case HEXADECIMALINT:
1670	<	{
1671	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1672	<	intConst(_t);
1673	<	_t = _retTree;
1674	<	#line 260 "MDTreeParser.g"
1675	<	dval = lexi_cast<double>(ic->getText());
1676	<	#line 1429 "MDTreeParser.cpp"
1677	<	break;
1678	<	}
1679	<	case FLOATONE:
1680	<	case FLOATTWO:
1681	<	{
1682	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1683	<	floatConst(_t);
1684	<	_t = _retTree;
1685	<	#line 261 "MDTreeParser.g"
1686	<	dval = lexi_cast<double>(fc->getText());
1687	<	#line 1440 "MDTreeParser.cpp"
1688	<	break;
1689	<	}
1690	<	default:
1691	<	{
1692	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1693	<	}
1694	<	}
1695	<	}
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 318 "MDTreeParser.g"
1677	>	RealType dval;
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	>
1683	>	try {      // for error handling
1684	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1685	>	_t = ASTNULL;
1686	>	switch ( _t->getType()) {
1687	>	case NUM_INT:
1688	>	case NUM_LONG:
1689	>	{
1690	>	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1691	>	intConst(_t);
1692	>	_t = _retTree;
1693	>	#line 319 "MDTreeParser.g"
1694	>	dval = lexi_cast<RealType>(ic->getText());
1695	>	#line 1696 "MDTreeParser.cpp"
1696		break;
1697		}
1698	+	case NUM_FLOAT:
1699	+	case NUM_DOUBLE:
1700	+	{
1701	+	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1702	+	floatConst(_t);
1703	+	_t = _retTree;
1704	+	#line 320 "MDTreeParser.g"
1705	+	dval = lexi_cast<RealType>(fc->getText());
1706	+	#line 1707 "MDTreeParser.cpp"
1707	+	break;
1708	+	}
1709		default:
1710		{
1711		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 1473 | 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 1495 | Line 1763 | const char* MDTreeParser::tokenNames[] = {
1763		"LPAREN",
1764		"RPAREN",
1765		"COMMA",
1766	<	"OCTALINT",
1767	<	"DECIMALINT",
1768	<	"HEXADECIMALINT",
1769	<	"PLUS",
1502	<	"MINUS",
1503	<	"FLOATONE",
1504	<	"FLOATTWO",
1766	>	"NUM_INT",
1767	>	"NUM_LONG",
1768	>	"NUM_FLOAT",
1769	>	"NUM_DOUBLE",
1770		"DOT",
1771		"COLON",
1772		"QUESTIONMARK",
#	Line 1514 | Line 1779 | const char* MDTreeParser::tokenNames[] = {
1779		"CharLiteral",
1780		"EndOfLine",
1781		"Escape",
1782	+	"Vocabulary",
1783		"Digit",
1784		"Decimal",
1785	<	"LongSuffix",
1786	<	"UnsignedSuffix",
1787	<	"FloatSuffix",
1522	<	"Exponent",
1523	<	"Vocabulary",
1524	<	"Number",
1785	>	"HEX_DIGIT",
1786	>	"EXPONENT",
1787	>	"FLOAT_SUFFIX",
1788		0
1789		};
1790
1791	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1792	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1530	<	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1531	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1532	<	// "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);
1535	–	const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 3758096384UL, 14UL, 0UL, 0UL };
1536	–	// OCTALINT DECIMALINT HEXADECIMALINT MINUS FLOATONE FLOATTWO
1537	–	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);
1799
1800

Comparing trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 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