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 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (file contents), Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20110725): "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 __t9 = _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 65 "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 _loop11;
161		}
162
163		}
164	<	_loop15:;
164	>	_loop11:;
165		} // ( ... )*
166		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167		match(_t,ENDBLOCK);
168		_t = _t->getNextSibling();
169	<	_t = __t13;
169	>	_t = __t9;
170		_t = _t->getNextSibling();
171	<	#line 71 "MDTreeParser.g"
171	>	#line 67 "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 __t33 = _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 96 "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 _loop35;
204		}
205
206		}
207	<	_loop23:;
207	>	_loop35:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t21;
212	>	_t = __t33;
213		_t = _t->getNextSibling();
214	<	#line 81 "MDTreeParser.g"
214	>	#line 98 "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 __t13 = _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 70 "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;
247	+	}
248	+
249	+	}
250	+	_loop15:;
251	+	} // ( ... )*
252	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253	+	match(_t,ENDBLOCK);
254	+	_t = _t->getNextSibling();
255	+	_t = __t13;
256	+	_t = _t->getNextSibling();
257	+	#line 72 "MDTreeParser.g"
258	+	blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259	+	#line 260 "MDTreeParser.cpp"
260	+	}
261	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262	+	reportError(ex);
263	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
264	+	_t = _t->getNextSibling();
265	+	}
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 __t17 = _t;
274	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275	+	match(_t,RESTRAINT);
276	+	_t = _t->getFirstChild();
277	+	#line 75 "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 _loop19;
290		}
291
292		}
293		_loop19:;
294		} // ( ... )*
295	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
295	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296		match(_t,ENDBLOCK);
297		_t = _t->getNextSibling();
298		_t = __t17;
299		_t = _t->getNextSibling();
300	<	#line 76 "MDTreeParser.g"
301	<	blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
302	<	#line 236 "MDTreeParser.cpp"
300	>	#line 77 "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);
#	Line 242 | Line 309 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
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 __t21 = _t;
317	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318	+	match(_t,FLUCQ);
319	+	_t = _t->getFirstChild();
320	+	#line 80 "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 _loop23;
333	+	}
334	+
335	+	}
336	+	_loop23:;
337	+	} // ( ... )*
338	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339	+	match(_t,ENDBLOCK);
340	+	_t = _t->getNextSibling();
341	+	_t = __t21;
342	+	_t = _t->getNextSibling();
343	+	#line 82 "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 __t25 = _t;
360	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361	+	match(_t,RNEMD);
362	+	_t = _t->getFirstChild();
363	+	#line 85 "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 _loop27;
376	+	}
377	+
378	+	}
379	+	_loop27:;
380	+	} // ( ... )*
381	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382	+	match(_t,ENDBLOCK);
383	+	_t = _t->getNextSibling();
384	+	_t = __t25;
385	+	_t = _t->getNextSibling();
386	+	#line 87 "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 __t29 = _t;
403	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404	+	match(_t,MINIMIZER);
405	+	_t = _t->getFirstChild();
406	+	#line 90 "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 _loop31;
419	+	}
420	+
421	+	}
422	+	_loop31:;
423	+	} // ( ... )*
424	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425	+	match(_t,ENDBLOCK);
426	+	_t = _t->getNextSibling();
427	+	_t = __t29;
428	+	_t = _t->getNextSibling();
429	+	#line 92 "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;
451	+
452	+	#line 453 "MDTreeParser.cpp"
453	+
454		try {      // for error handling
455		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
456		_t = ASTNULL;
457		switch ( _t->getType()) {
458	<	case OCTALINT:
459	<	case DECIMALINT:
258	<	case HEXADECIMALINT:
259	<	case FLOATONE:
260	<	case FLOATTWO:
261	<	case MINUS:
458	>	case NUM_INT:
459	>	case NUM_LONG:
460		{
461	<	signedIntOrFloat(_t,id);
461	>	ival=intConst(_t);
462		_t = _retTree;
463	+	#line 55 "MDTreeParser.g"
464	+	blockStack.top()->assign(id->getText(), ival);
465	+	#line 466 "MDTreeParser.cpp"
466		break;
467		}
468	+	case NUM_FLOAT:
469	+	case NUM_DOUBLE:
470	+	{
471	+	dval=floatConst(_t);
472	+	_t = _retTree;
473	+	#line 56 "MDTreeParser.g"
474	+	blockStack.top()->assign(id->getText(), dval);
475	+	#line 476 "MDTreeParser.cpp"
476	+	break;
477	+	}
478		case ID:
479		{
480		str1 = _t;
481		match(_t,ID);
482		_t = _t->getNextSibling();
483	<	#line 49 "MDTreeParser.g"
483	>	#line 57 "MDTreeParser.g"
484		blockStack.top()->assign(id->getText(), str1->getText());
485	<	#line 275 "MDTreeParser.cpp"
485	>	#line 486 "MDTreeParser.cpp"
486		break;
487		}
488		case StringLiteral:
#	Line 279 | Line 490 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
490		str2 = _t;
491		match(_t,StringLiteral);
492		_t = _t->getNextSibling();
493	<	#line 50 "MDTreeParser.g"
493	>	#line 58 "MDTreeParser.g"
494		std::string s =  str2->getText();
495		s = s.substr(1, s.length()-2);
496		blockStack.top()->assign(id->getText(),s);
497
498	<	#line 288 "MDTreeParser.cpp"
498	>	#line 499 "MDTreeParser.cpp"
499		break;
500		}
501		default:
#	Line 301 | Line 512 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
512		_retTree = _t;
513		}
514
515	<	void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
516	<	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	<
515	>	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
516	>	#line 286 "MDTreeParser.g"
517		int ival;
518	<	double dval;
518	>	#line 519 "MDTreeParser.cpp"
519	>	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
520	>	ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
521	>	ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
522
317	–	#line 318 "MDTreeParser.cpp"
318	–
523		try {      // for error handling
524		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
525		_t = ASTNULL;
526		switch ( _t->getType()) {
527	<	case MINUS:
527	>	case NUM_INT:
528		{
529	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
530	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
327	<	match(_t,MINUS);
328	<	_t = _t->getFirstChild();
329	<	{
330	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
331	<	_t = ASTNULL;
332	<	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;
529	>	i1 = _t;
530	>	match(_t,NUM_INT);
531		_t = _t->getNextSibling();
532	+	#line 287 "MDTreeParser.g"
533	+	ival = lexi_cast<int>(i1->getText());
534	+	#line 535 "MDTreeParser.cpp"
535		break;
536		}
537	<	case OCTALINT:
367	<	case DECIMALINT:
368	<	case HEXADECIMALINT:
369	<	case FLOATONE:
370	<	case FLOATTWO:
537	>	case NUM_LONG:
538		{
539	<	{
540	<	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;
383	<	#line 64 "MDTreeParser.g"
384	<	ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);
385	<	#line 386 "MDTreeParser.cpp"
386	<	break;
387	<	}
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	<	}
405	<	break;
406	<	}
407	<	default:
408	<	{
409	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
410	<	}
411	<	}
412	<	}
413	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
414	<	reportError(ex);
415	<	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
539	>	i2 = _t;
540	>	match(_t,NUM_LONG);
541		_t = _t->getNextSibling();
542	<	}
543	<	_retTree = _t;
544	<	}
420	<
421	<	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
422	<	#line 249 "MDTreeParser.g"
423	<	int ival;
424	<	#line 425 "MDTreeParser.cpp"
425	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
426	<	ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
427	<	ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
428	<	ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
429	<
430	<	try {      // for error handling
431	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
432	<	_t = ASTNULL;
433	<	switch ( _t->getType()) {
434	<	case OCTALINT:
435	<	{
436	<	oival = _t;
437	<	match(_t,OCTALINT);
438	<	_t = _t->getNextSibling();
439	<	#line 250 "MDTreeParser.g"
440	<	ival = lexi_cast<int>(oival->getText());
441	<	#line 442 "MDTreeParser.cpp"
542	>	#line 288 "MDTreeParser.g"
543	>	ival = lexi_cast<int>(i2->getText());
544	>	#line 545 "MDTreeParser.cpp"
545		break;
546		}
444	–	case DECIMALINT:
445	–	{
446	–	dival = _t;
447	–	match(_t,DECIMALINT);
448	–	_t = _t->getNextSibling();
449	–	#line 251 "MDTreeParser.g"
450	–	ival = lexi_cast<int>(dival->getText());
451	–	#line 452 "MDTreeParser.cpp"
452	–	break;
453	–	}
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	–	}
547		default:
548		{
549		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 476 | Line 559 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
559		return ival;
560		}
561
562	<	double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
563	<	#line 264 "MDTreeParser.g"
564	<	double dval;
565	<	#line 483 "MDTreeParser.cpp"
566	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
562	>	RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
563	>	#line 300 "MDTreeParser.g"
564	>	RealType dval;
565	>	#line 566 "MDTreeParser.cpp"
566	>	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
567		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
568		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
569
#	Line 488 | Line 571 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
571		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
572		_t = ASTNULL;
573		switch ( _t->getType()) {
574	<	case FLOATONE:
574	>	case NUM_FLOAT:
575		{
576		d1 = _t;
577	<	match(_t,FLOATONE);
577	>	match(_t,NUM_FLOAT);
578		_t = _t->getNextSibling();
579	<	#line 265 "MDTreeParser.g"
580	<	dval = lexi_cast<double>(d1->getText());
581	<	#line 499 "MDTreeParser.cpp"
579	>	#line 301 "MDTreeParser.g"
580	>	dval = lexi_cast<RealType>(d1->getText());
581	>	#line 582 "MDTreeParser.cpp"
582		break;
583		}
584	<	case FLOATTWO:
584	>	case NUM_DOUBLE:
585		{
586		d2 = _t;
587	<	match(_t,FLOATTWO);
587	>	match(_t,NUM_DOUBLE);
588		_t = _t->getNextSibling();
589	<	#line 266 "MDTreeParser.g"
590	<	dval = lexi_cast<double>(d2->getText());
591	<	#line 509 "MDTreeParser.cpp"
589	>	#line 302 "MDTreeParser.g"
590	>	dval = lexi_cast<RealType>(d2->getText());
591	>	#line 592 "MDTreeParser.cpp"
592		break;
593		}
594		default:
#	Line 524 | Line 607 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
607		}
608
609		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
610	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
610	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
611
612		try {      // for error handling
613		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 560 | Line 643 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
643		_t = _retTree;
644		break;
645		}
646	+	case INVERSION:
647	+	{
648	+	inversionblock(_t);
649	+	_t = _retTree;
650	+	break;
651	+	}
652		case RIGIDBODY:
653		{
654		rigidbodyblock(_t);
#	Line 593 | Line 682 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
682		}
683
684		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
685	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
686	<	#line 94 "MDTreeParser.g"
685	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
686	>	#line 112 "MDTreeParser.g"
687
688		int index;
689
690	<	#line 602 "MDTreeParser.cpp"
690	>	#line 691 "MDTreeParser.cpp"
691
692		try {      // for error handling
693	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
694	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
693	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
694	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
695		match(_t,ATOM);
696		_t = _t->getFirstChild();
697		index=intConst(_t);
698		_t = _retTree;
699	<	#line 98 "MDTreeParser.g"
699	>	#line 116 "MDTreeParser.g"
700		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
701	<	#line 613 "MDTreeParser.cpp"
701	>	#line 702 "MDTreeParser.cpp"
702		{ // ( ... )*
703		for (;;) {
704		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 619 | Line 708 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
708		_t = _retTree;
709		}
710		else {
711	<	goto _loop28;
711	>	goto _loop40;
712		}
713
714		}
715	<	_loop28:;
715	>	_loop40:;
716		} // ( ... )*
717	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
717	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
718		match(_t,ENDBLOCK);
719		_t = _t->getNextSibling();
720	<	_t = __t26;
720	>	_t = __t38;
721		_t = _t->getNextSibling();
722	<	#line 100 "MDTreeParser.g"
722	>	#line 118 "MDTreeParser.g"
723
724		blockStack.top()->validate();
725		blockStack.pop();
726		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
727		currMoleculeStamp->addAtomStamp(currAtomStamp);
728
729	<	#line 641 "MDTreeParser.cpp"
729	>	#line 730 "MDTreeParser.cpp"
730		}
731		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
732		reportError(ex);
#	Line 648 | Line 737 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
737		}
738
739		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
740	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
740	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
741
742		try {      // for error handling
743	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
744	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
743	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
744	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745		match(_t,BOND);
746		_t = _t->getFirstChild();
747	<	#line 120 "MDTreeParser.g"
747	>	#line 138 "MDTreeParser.g"
748		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
749	<	#line 661 "MDTreeParser.cpp"
749	>	#line 750 "MDTreeParser.cpp"
750		{ // ( ... )*
751		for (;;) {
752		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 667 | Line 756 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
756		_t = _retTree;
757		}
758		else {
759	<	goto _loop35;
759	>	goto _loop47;
760		}
761
762		}
763	<	_loop35:;
763	>	_loop47:;
764		} // ( ... )*
765	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
765	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
766		match(_t,ENDBLOCK);
767		_t = _t->getNextSibling();
768	<	_t = __t33;
768	>	_t = __t45;
769		_t = _t->getNextSibling();
770	<	#line 122 "MDTreeParser.g"
770	>	#line 140 "MDTreeParser.g"
771
772		blockStack.pop();
773		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
774		currMoleculeStamp->addBondStamp(currBondStamp);
775
776	<	#line 688 "MDTreeParser.cpp"
776	>	#line 777 "MDTreeParser.cpp"
777		}
778		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
779		reportError(ex);
#	Line 695 | Line 784 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
784		}
785
786		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
787	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
787	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
788
789		try {      // for error handling
790	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
791	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
790	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
791	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
792		match(_t,BEND);
793		_t = _t->getFirstChild();
794	<	#line 138 "MDTreeParser.g"
794	>	#line 156 "MDTreeParser.g"
795		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
796	<	#line 708 "MDTreeParser.cpp"
796	>	#line 797 "MDTreeParser.cpp"
797		{ // ( ... )*
798		for (;;) {
799		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 714 | Line 803 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
803		_t = _retTree;
804		}
805		else {
806	<	goto _loop41;
806	>	goto _loop53;
807		}
808
809		}
810	<	_loop41:;
810	>	_loop53:;
811		} // ( ... )*
812	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
812	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
813		match(_t,ENDBLOCK);
814		_t = _t->getNextSibling();
815	<	_t = __t39;
815	>	_t = __t51;
816		_t = _t->getNextSibling();
817	<	#line 140 "MDTreeParser.g"
817	>	#line 158 "MDTreeParser.g"
818
819		blockStack.top()->validate();
820		blockStack.pop();
821		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
822		currMoleculeStamp->addBendStamp(currBendStamp);
823
824	<	#line 736 "MDTreeParser.cpp"
824	>	#line 825 "MDTreeParser.cpp"
825		}
826		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
827		reportError(ex);
#	Line 743 | Line 832 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
832		}
833
834		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
835	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
835	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
836
837		try {      // for error handling
838	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
839	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
838	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
839	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
840		match(_t,TORSION);
841		_t = _t->getFirstChild();
842	<	#line 157 "MDTreeParser.g"
842	>	#line 175 "MDTreeParser.g"
843		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
844	<	#line 756 "MDTreeParser.cpp"
844	>	#line 845 "MDTreeParser.cpp"
845		{ // ( ... )*
846		for (;;) {
847		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 762 | Line 851 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
851		_t = _retTree;
852		}
853		else {
854	<	goto _loop47;
854	>	goto _loop59;
855		}
856
857		}
858	<	_loop47:;
858	>	_loop59:;
859		} // ( ... )*
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
860	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
861		match(_t,ENDBLOCK);
862		_t = _t->getNextSibling();
863	<	_t = __t45;
863	>	_t = __t57;
864		_t = _t->getNextSibling();
865	<	#line 159 "MDTreeParser.g"
865	>	#line 177 "MDTreeParser.g"
866
867		blockStack.top()->validate();
868		blockStack.pop();
869		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
870		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
871
872	<	#line 784 "MDTreeParser.cpp"
872	>	#line 873 "MDTreeParser.cpp"
873		}
874		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
875		reportError(ex);
#	Line 790 | Line 879 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
879		_retTree = _t;
880		}
881
882	+	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
883	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
884	+
885	+	try {      // for error handling
886	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
887	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
888	+	match(_t,INVERSION);
889	+	_t = _t->getFirstChild();
890	+	#line 194 "MDTreeParser.g"
891	+	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
892	+	#line 893 "MDTreeParser.cpp"
893	+	{ // ( ... )*
894	+	for (;;) {
895	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
896	+	_t = ASTNULL;
897	+	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
898	+	inversionstatement(_t);
899	+	_t = _retTree;
900	+	}
901	+	else {
902	+	goto _loop65;
903	+	}
904	+
905	+	}
906	+	_loop65:;
907	+	} // ( ... )*
908	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
909	+	match(_t,ENDBLOCK);
910	+	_t = _t->getNextSibling();
911	+	_t = __t63;
912	+	_t = _t->getNextSibling();
913	+	#line 196 "MDTreeParser.g"
914	+
915	+	blockStack.top()->validate();
916	+	blockStack.pop();
917	+	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
918	+	currMoleculeStamp->addInversionStamp(currInversionStamp);
919	+
920	+	#line 921 "MDTreeParser.cpp"
921	+	}
922	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
923	+	reportError(ex);
924	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
925	+	_t = _t->getNextSibling();
926	+	}
927	+	_retTree = _t;
928	+	}
929	+
930		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
931	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
932	<	#line 176 "MDTreeParser.g"
931	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
932	>	#line 213 "MDTreeParser.g"
933
934		int index;
935
936	<	#line 800 "MDTreeParser.cpp"
936	>	#line 937 "MDTreeParser.cpp"
937
938		try {      // for error handling
939	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
940	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
939	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
940	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
941		match(_t,RIGIDBODY);
942		_t = _t->getFirstChild();
943		index=intConst(_t);
944		_t = _retTree;
945	<	#line 180 "MDTreeParser.g"
945	>	#line 217 "MDTreeParser.g"
946		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
947	<	#line 811 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948		{ // ( ... )*
949		for (;;) {
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 817 | Line 954 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
954		_t = _retTree;
955		}
956		else {
957	<	goto _loop53;
957	>	goto _loop71;
958		}
959
960		}
961	<	_loop53:;
961	>	_loop71:;
962		} // ( ... )*
963	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
963	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
964		match(_t,ENDBLOCK);
965		_t = _t->getNextSibling();
966	<	_t = __t51;
966	>	_t = __t69;
967		_t = _t->getNextSibling();
968	<	#line 182 "MDTreeParser.g"
968	>	#line 219 "MDTreeParser.g"
969
970		blockStack.top()->validate();
971		blockStack.pop();
972		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
973		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
974
975	<	#line 839 "MDTreeParser.cpp"
975	>	#line 976 "MDTreeParser.cpp"
976		}
977		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
978		reportError(ex);
#	Line 846 | Line 983 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
983		}
984
985		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
986	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
986	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
987
988		try {      // for error handling
989	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
990	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
989	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
990	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
991		match(_t,CUTOFFGROUP);
992		_t = _t->getFirstChild();
993	<	#line 199 "MDTreeParser.g"
993	>	#line 236 "MDTreeParser.g"
994		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
995	<	#line 859 "MDTreeParser.cpp"
995	>	#line 996 "MDTreeParser.cpp"
996		{ // ( ... )*
997		for (;;) {
998		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 865 | Line 1002 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1002		_t = _retTree;
1003		}
1004		else {
1005	<	goto _loop59;
1005	>	goto _loop77;
1006		}
1007
1008		}
1009	<	_loop59:;
1009	>	_loop77:;
1010		} // ( ... )*
1011	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1011	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1012		match(_t,ENDBLOCK);
1013		_t = _t->getNextSibling();
1014	<	_t = __t57;
1014	>	_t = __t75;
1015		_t = _t->getNextSibling();
1016	<	#line 201 "MDTreeParser.g"
1016	>	#line 238 "MDTreeParser.g"
1017
1018		blockStack.top()->validate();
1019		blockStack.pop();
1020		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1021		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1022
1023	<	#line 887 "MDTreeParser.cpp"
1023	>	#line 1024 "MDTreeParser.cpp"
1024		}
1025		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1026		reportError(ex);
#	Line 894 | Line 1031 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1031		}
1032
1033		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1034	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1035	<	#line 218 "MDTreeParser.g"
1034	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1035	>	#line 255 "MDTreeParser.g"
1036		int ival;
1037	<	#line 901 "MDTreeParser.cpp"
1037	>	#line 1038 "MDTreeParser.cpp"
1038
1039		try {      // for error handling
1040	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1041	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1040	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1041	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1042		match(_t,FRAGMENT);
1043		_t = _t->getFirstChild();
1044		ival=intConst(_t);
1045		_t = _retTree;
1046	<	#line 219 "MDTreeParser.g"
1046	>	#line 256 "MDTreeParser.g"
1047		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1048	<	#line 912 "MDTreeParser.cpp"
1048	>	#line 1049 "MDTreeParser.cpp"
1049		{ // ( ... )*
1050		for (;;) {
1051		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 918 | Line 1055 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1055		_t = _retTree;
1056		}
1057		else {
1058	<	goto _loop65;
1058	>	goto _loop83;
1059		}
1060
1061		}
1062	<	_loop65:;
1062	>	_loop83:;
1063		} // ( ... )*
1064	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1064	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1065		match(_t,ENDBLOCK);
1066		_t = _t->getNextSibling();
1067	<	_t = __t63;
1067	>	_t = __t81;
1068		_t = _t->getNextSibling();
1069	<	#line 221 "MDTreeParser.g"
1069	>	#line 258 "MDTreeParser.g"
1070
1071		blockStack.top()->validate();
1072		blockStack.pop();
1073		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1074		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1075
1076	<	#line 940 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		}
1078		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1079		reportError(ex);
#	Line 947 | Line 1084 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1084		}
1085
1086		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1087	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088	<	#line 108 "MDTreeParser.g"
1087	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088	>	#line 126 "MDTreeParser.g"
1089
1090	<	vector<double> dvec;
1090	>	vector<RealType> dvec;
1091		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1092
1093
1094	<	#line 958 "MDTreeParser.cpp"
1094	>	#line 1095 "MDTreeParser.cpp"
1095
1096		try {      // for error handling
1097		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 968 | Line 1105 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1105		}
1106		case POSITION:
1107		{
1108	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1109	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1108	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t42 = _t;
1109	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1110		match(_t,POSITION);
1111		_t = _t->getFirstChild();
1112	<	dvec=signedNumberTuple(_t);
1112	>	dvec=doubleNumberTuple(_t);
1113		_t = _retTree;
1114	<	_t = __t30;
1114	>	_t = __t42;
1115		_t = _t->getNextSibling();
1116	<	#line 115 "MDTreeParser.g"
1116	>	#line 133 "MDTreeParser.g"
1117		currAtomStamp->setPosition(dvec);
1118	<	#line 982 "MDTreeParser.cpp"
1118	>	#line 1119 "MDTreeParser.cpp"
1119		break;
1120		}
1121		case ORIENTATION:
1122		{
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1124	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1123	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1124	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1125		match(_t,ORIENTATION);
1126		_t = _t->getFirstChild();
1127	<	dvec=signedNumberTuple(_t);
1127	>	dvec=doubleNumberTuple(_t);
1128		_t = _retTree;
1129	<	_t = __t31;
1129	>	_t = __t43;
1130		_t = _t->getNextSibling();
1131	<	#line 116 "MDTreeParser.g"
1131	>	#line 134 "MDTreeParser.g"
1132		currAtomStamp->setOrientation(dvec);
1133	<	#line 997 "MDTreeParser.cpp"
1133	>	#line 1134 "MDTreeParser.cpp"
1134		break;
1135		}
1136		default:
#	Line 1010 | Line 1147 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1147		_retTree = _t;
1148		}
1149
1150	<	vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151	<	#line 234 "MDTreeParser.g"
1152	<	vector<double> dvec;
1153	<	#line 1017 "MDTreeParser.cpp"
1154	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1155	<	#line 234 "MDTreeParser.g"
1150	>	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151	>	#line 271 "MDTreeParser.g"
1152	>	vector<RealType> dvec;
1153	>	#line 1154 "MDTreeParser.cpp"
1154	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1155	>	#line 271 "MDTreeParser.g"
1156
1157	<	double dval;
1157	>	RealType dval;
1158
1159	<	#line 1023 "MDTreeParser.cpp"
1159	>	#line 1160 "MDTreeParser.cpp"
1160
1161		try {      // for error handling
1162		{ // ( ... )+
1163	<	int _cnt69=0;
1163	>	int _cnt87=0;
1164		for (;;) {
1165		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1166		_t = ASTNULL;
1167	<	if (((_t->getType() >= OCTALINT && _t->getType() <= FLOATTWO))) {
1168	<	dval=signedNumber(_t);
1167	>	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1168	>	dval=doubleNumber(_t);
1169		_t = _retTree;
1170	<	#line 238 "MDTreeParser.g"
1170	>	#line 275 "MDTreeParser.g"
1171		dvec.push_back(dval);
1172	<	#line 1036 "MDTreeParser.cpp"
1172	>	#line 1173 "MDTreeParser.cpp"
1173		}
1174		else {
1175	<	if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1175	>	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1176		}
1177
1178	<	_cnt69++;
1178	>	_cnt87++;
1179		}
1180	<	_loop69:;
1180	>	_loop87:;
1181		}  // ( ... )+
1182		}
1183		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1053 | Line 1190 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1190		}
1191
1192		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1193	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1194	<	#line 129 "MDTreeParser.g"
1193	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1194	>	#line 147 "MDTreeParser.g"
1195
1196		vector<int> ivec;
1197		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1198
1199	<	#line 1063 "MDTreeParser.cpp"
1199	>	#line 1200 "MDTreeParser.cpp"
1200
1201		try {      // for error handling
1202		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1073 | Line 1210 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1210		}
1211		case MEMBERS:
1212		{
1213	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1214	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1213	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1214	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1215		match(_t,MEMBERS);
1216		_t = _t->getFirstChild();
1217		ivec=inttuple(_t);
1218		_t = _retTree;
1219	<	_t = __t37;
1219	>	_t = __t49;
1220		_t = _t->getNextSibling();
1221	<	#line 135 "MDTreeParser.g"
1221	>	#line 153 "MDTreeParser.g"
1222		currBondStamp->setMembers(ivec);
1223	<	#line 1087 "MDTreeParser.cpp"
1223	>	#line 1224 "MDTreeParser.cpp"
1224		break;
1225		}
1226		default:
#	Line 1101 | Line 1238 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1238		}
1239
1240		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1241	<	#line 241 "MDTreeParser.g"
1241	>	#line 278 "MDTreeParser.g"
1242		vector<int> ivec;
1243	<	#line 1107 "MDTreeParser.cpp"
1244	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1245	<	#line 241 "MDTreeParser.g"
1243	>	#line 1244 "MDTreeParser.cpp"
1244	>	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1245	>	#line 278 "MDTreeParser.g"
1246
1247		int ival;
1248
1249	<	#line 1113 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250
1251		try {      // for error handling
1252		{ // ( ... )+
1253	<	int _cnt72=0;
1253	>	int _cnt90=0;
1254		for (;;) {
1255		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1256		_t = ASTNULL;
1257	<	if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1257	>	if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1258		ival=intConst(_t);
1259		_t = _retTree;
1260	<	#line 245 "MDTreeParser.g"
1260	>	#line 282 "MDTreeParser.g"
1261		ivec.push_back(ival);
1262	<	#line 1126 "MDTreeParser.cpp"
1262	>	#line 1263 "MDTreeParser.cpp"
1263		}
1264		else {
1265	<	if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1265	>	if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1266		}
1267
1268	<	_cnt72++;
1268	>	_cnt90++;
1269		}
1270	<	_loop72:;
1270	>	_loop90:;
1271		}  // ( ... )+
1272		}
1273		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1143 | Line 1280 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1280		}
1281
1282		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1283	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1284	<	#line 148 "MDTreeParser.g"
1283	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1284	>	#line 166 "MDTreeParser.g"
1285
1286		vector<int> ivec;
1287		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1288
1289	<	#line 1153 "MDTreeParser.cpp"
1289	>	#line 1290 "MDTreeParser.cpp"
1290
1291		try {      // for error handling
1292		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1163 | Line 1300 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1300		}
1301		case MEMBERS:
1302		{
1303	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1304	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1303	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1304	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1305		match(_t,MEMBERS);
1306		_t = _t->getFirstChild();
1307		ivec=inttuple(_t);
1308		_t = _retTree;
1309	<	_t = __t43;
1309	>	_t = __t55;
1310		_t = _t->getNextSibling();
1311	<	#line 154 "MDTreeParser.g"
1311	>	#line 172 "MDTreeParser.g"
1312		currBendStamp->setMembers(ivec);
1313	<	#line 1177 "MDTreeParser.cpp"
1313	>	#line 1314 "MDTreeParser.cpp"
1314		break;
1315		}
1316		default:
#	Line 1191 | Line 1328 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1328		}
1329
1330		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1331	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1332	<	#line 167 "MDTreeParser.g"
1331	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1332	>	#line 185 "MDTreeParser.g"
1333
1334		vector<int> ivec;
1335		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1336
1337	<	#line 1201 "MDTreeParser.cpp"
1337	>	#line 1338 "MDTreeParser.cpp"
1338
1339		try {      // for error handling
1340		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1211 | Line 1348 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1348		}
1349		case MEMBERS:
1350		{
1351	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1352	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1351	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1352	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1353		match(_t,MEMBERS);
1354		_t = _t->getFirstChild();
1355		ivec=inttuple(_t);
1356		_t = _retTree;
1357	<	_t = __t49;
1357	>	_t = __t61;
1358		_t = _t->getNextSibling();
1359	<	#line 173 "MDTreeParser.g"
1359	>	#line 191 "MDTreeParser.g"
1360		currTorsionStamp->setMembers(ivec);
1361	<	#line 1225 "MDTreeParser.cpp"
1361	>	#line 1362 "MDTreeParser.cpp"
1362		break;
1363		}
1364		default:
#	Line 1238 | Line 1375 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1375		_retTree = _t;
1376		}
1377
1378	+	void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1379	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380	+	#line 204 "MDTreeParser.g"
1381	+
1382	+	int icent;
1383	+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1384	+
1385	+	#line 1386 "MDTreeParser.cpp"
1386	+
1387	+	try {      // for error handling
1388	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1389	+	_t = ASTNULL;
1390	+	switch ( _t->getType()) {
1391	+	case ASSIGNEQUAL:
1392	+	{
1393	+	assignment(_t);
1394	+	_t = _retTree;
1395	+	break;
1396	+	}
1397	+	case CENTER:
1398	+	{
1399	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1400	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1401	+	match(_t,CENTER);
1402	+	_t = _t->getFirstChild();
1403	+	icent=intConst(_t);
1404	+	_t = _retTree;
1405	+	_t = __t67;
1406	+	_t = _t->getNextSibling();
1407	+	#line 210 "MDTreeParser.g"
1408	+	currInversionStamp->setCenter(icent);
1409	+	#line 1410 "MDTreeParser.cpp"
1410	+	break;
1411	+	}
1412	+	default:
1413	+	{
1414	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1415	+	}
1416	+	}
1417	+	}
1418	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1419	+	reportError(ex);
1420	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1421	+	_t = _t->getNextSibling();
1422	+	}
1423	+	_retTree = _t;
1424	+	}
1425	+
1426		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1427	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1428	<	#line 190 "MDTreeParser.g"
1427	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1428	>	#line 227 "MDTreeParser.g"
1429
1430		vector<int> ivec;
1431		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1432
1433	<	#line 1249 "MDTreeParser.cpp"
1433	>	#line 1434 "MDTreeParser.cpp"
1434
1435		try {      // for error handling
1436		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1259 | Line 1444 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1444		}
1445		case MEMBERS:
1446		{
1447	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1448	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1447	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t73 = _t;
1448	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1449		match(_t,MEMBERS);
1450		_t = _t->getFirstChild();
1451		ivec=inttuple(_t);
1452		_t = _retTree;
1453	<	_t = __t55;
1453	>	_t = __t73;
1454		_t = _t->getNextSibling();
1455	<	#line 196 "MDTreeParser.g"
1455	>	#line 233 "MDTreeParser.g"
1456		currRigidBodyStamp->setMembers(ivec);
1457	<	#line 1273 "MDTreeParser.cpp"
1457	>	#line 1458 "MDTreeParser.cpp"
1458		break;
1459		}
1460		default:
#	Line 1287 | Line 1472 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1472		}
1473
1474		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1475	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1476	<	#line 209 "MDTreeParser.g"
1475	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1476	>	#line 246 "MDTreeParser.g"
1477
1478		vector<int> ivec;
1479		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1480
1481	<	#line 1297 "MDTreeParser.cpp"
1481	>	#line 1482 "MDTreeParser.cpp"
1482
1483		try {      // for error handling
1484		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1307 | Line 1492 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1492		}
1493		case MEMBERS:
1494		{
1495	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1496	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1495	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t79 = _t;
1496	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1497		match(_t,MEMBERS);
1498		_t = _t->getFirstChild();
1499		ivec=inttuple(_t);
1500		_t = _retTree;
1501	<	_t = __t61;
1501	>	_t = __t79;
1502		_t = _t->getNextSibling();
1503	<	#line 215 "MDTreeParser.g"
1503	>	#line 252 "MDTreeParser.g"
1504		currCutoffGroupStamp->setMembers(ivec);
1505	<	#line 1321 "MDTreeParser.cpp"
1505	>	#line 1506 "MDTreeParser.cpp"
1506		break;
1507		}
1508		default:
#	Line 1335 | Line 1520 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1520		}
1521
1522		void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1523	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1523	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1524
1525		try {      // for error handling
1526		assignment(_t);
#	Line 1349 | Line 1534 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1534		_retTree = _t;
1535		}
1536
1537	<	double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538	<	#line 256 "MDTreeParser.g"
1539	<	double dval;
1540	<	#line 1356 "MDTreeParser.cpp"
1541	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1537	>	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538	>	#line 292 "MDTreeParser.g"
1539	>	RealType dval;
1540	>	#line 1541 "MDTreeParser.cpp"
1541	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1542		ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1543		ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1544
#	Line 1361 | Line 1546 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1546		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1547		_t = ASTNULL;
1548		switch ( _t->getType()) {
1549	<	case OCTALINT:
1550	<	case DECIMALINT:
1366	<	case HEXADECIMALINT:
1549	>	case NUM_INT:
1550	>	case NUM_LONG:
1551		{
1552		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1553		intConst(_t);
1554		_t = _retTree;
1555	<	#line 258 "MDTreeParser.g"
1556	<	dval = lexi_cast<double>(ic->getText());
1557	<	#line 1374 "MDTreeParser.cpp"
1555	>	#line 294 "MDTreeParser.g"
1556	>	dval = lexi_cast<RealType>(ic->getText());
1557	>	#line 1558 "MDTreeParser.cpp"
1558		break;
1559		}
1560	<	case FLOATONE:
1561	<	case FLOATTWO:
1560	>	case NUM_FLOAT:
1561	>	case NUM_DOUBLE:
1562		{
1563		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1564		floatConst(_t);
1565		_t = _retTree;
1566	<	#line 259 "MDTreeParser.g"
1567	<	dval = lexi_cast<double>(fc->getText());
1568	<	#line 1385 "MDTreeParser.cpp"
1566	>	#line 295 "MDTreeParser.g"
1567	>	dval = lexi_cast<RealType>(fc->getText());
1568	>	#line 1569 "MDTreeParser.cpp"
1569		break;
1570		}
1571		default:
#	Line 1410 | Line 1594 | const char* MDTreeParser::tokenNames[] = {
1594		"\"component\"",
1595		"\"molecule\"",
1596		"\"zconstraint\"",
1597	+	"\"restraint\"",
1598		"\"atom\"",
1599		"\"bond\"",
1600		"\"bend\"",
1601		"\"torsion\"",
1602	+	"\"inversion\"",
1603		"\"rigidBody\"",
1604		"\"cutoffGroup\"",
1605		"\"fragment\"",
1606		"\"members\"",
1607	+	"\"center\"",
1608		"\"position\"",
1609		"\"orientation\"",
1610	+	"\"flucQ\"",
1611	+	"\"RNEMD\"",
1612	+	"\"minimizer\"",
1613		"ENDBLOCK",
1614		"ID",
1615		"ASSIGNEQUAL",
#	Line 1432 | Line 1622 | const char* MDTreeParser::tokenNames[] = {
1622		"LPAREN",
1623		"RPAREN",
1624		"COMMA",
1625	<	"OCTALINT",
1626	<	"DECIMALINT",
1627	<	"HEXADECIMALINT",
1628	<	"FLOATONE",
1439	<	"FLOATTWO",
1625	>	"NUM_INT",
1626	>	"NUM_LONG",
1627	>	"NUM_FLOAT",
1628	>	"NUM_DOUBLE",
1629		"DOT",
1630		"COLON",
1631		"QUESTIONMARK",
#	Line 1449 | Line 1638 | const char* MDTreeParser::tokenNames[] = {
1638		"CharLiteral",
1639		"EndOfLine",
1640		"Escape",
1641	+	"Vocabulary",
1642		"Digit",
1643		"Decimal",
1644	<	"LongSuffix",
1645	<	"UnsignedSuffix",
1646	<	"FloatSuffix",
1457	<	"Exponent",
1458	<	"Vocabulary",
1459	<	"Number",
1460	<	"MINUS",
1644	>	"HEX_DIGIT",
1645	>	"EXPONENT",
1646	>	"FLOAT_SUFFIX",
1647		0
1648		};
1649
1650	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1651	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1466	<	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1467	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1468	<	// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1650	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1651	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1652		// ASSIGNEQUAL
1653	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1654	+	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1655	+	// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1656	+	// "fragment" ASSIGNEQUAL
1657		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1658
1659

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

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

Diff Legend

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