ViewVC Help

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

root/OpenMD/branches/development/src/mdParser/MDTreeParser.cpp

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (file contents), Revision 963 by tim, Wed May 17 21:51:42 2006 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (file contents), Revision 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 __t9 = _t;
145		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146		match(_t,COMPONENT);
147		_t = _t->getFirstChild();
148	<	#line 62 "MDTreeParser.g"
148	>	#line 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 144 | Line 168 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
168		_t = _t->getNextSibling();
169		_t = __t9;
170		_t = _t->getNextSibling();
171	<	#line 64 "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 __t17 = _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 72 "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 _loop19;
203	>	goto _loop35;
204		}
205
206		}
207	<	_loop19:;
207	>	_loop35:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t17;
212	>	_t = __t33;
213		_t = _t->getNextSibling();
214	<	#line 74 "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 __t13 = _t;
231		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232		match(_t,ZCONSTRAINT);
233		_t = _t->getFirstChild();
234	<	#line 67 "MDTreeParser.g"
234	>	#line 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 230 | Line 254 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
254		_t = _t->getNextSibling();
255		_t = __t13;
256		_t = _t->getNextSibling();
257	<	#line 69 "MDTreeParser.g"
257	>	#line 72 "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);
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 tmp9_AST_in = _t;
296	>	match(_t,ENDBLOCK);
297	>	_t = _t->getNextSibling();
298	>	_t = __t17;
299	>	_t = _t->getNextSibling();
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);
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 __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);
#	Line 245 | Line 441 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
441		void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
442		ANTLR_USE_NAMESPACE(antlr)RefAST id
443		) {
444	<	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
444	>	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447	<	#line 47 "MDTreeParser.g"
447	>	#line 50 "MDTreeParser.g"
448
449		int ival;
450		RealType dval;
451
452	<	#line 257 "MDTreeParser.cpp"
452	>	#line 453 "MDTreeParser.cpp"
453
454		try {      // for error handling
455		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 264 | Line 460 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
460		{
461		ival=intConst(_t);
462		_t = _retTree;
463	<	#line 52 "MDTreeParser.g"
463	>	#line 55 "MDTreeParser.g"
464		blockStack.top()->assign(id->getText(), ival);
465	<	#line 270 "MDTreeParser.cpp"
465	>	#line 466 "MDTreeParser.cpp"
466		break;
467		}
468		case NUM_FLOAT:
#	Line 274 | Line 470 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
470		{
471		dval=floatConst(_t);
472		_t = _retTree;
473	<	#line 53 "MDTreeParser.g"
473	>	#line 56 "MDTreeParser.g"
474		blockStack.top()->assign(id->getText(), dval);
475	<	#line 280 "MDTreeParser.cpp"
475	>	#line 476 "MDTreeParser.cpp"
476		break;
477		}
478		case ID:
#	Line 284 | Line 480 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
480		str1 = _t;
481		match(_t,ID);
482		_t = _t->getNextSibling();
483	<	#line 54 "MDTreeParser.g"
483	>	#line 57 "MDTreeParser.g"
484		blockStack.top()->assign(id->getText(), str1->getText());
485	<	#line 290 "MDTreeParser.cpp"
485	>	#line 486 "MDTreeParser.cpp"
486		break;
487		}
488		case StringLiteral:
#	Line 294 | Line 490 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
490		str2 = _t;
491		match(_t,StringLiteral);
492		_t = _t->getNextSibling();
493	<	#line 55 "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 303 "MDTreeParser.cpp"
498	>	#line 499 "MDTreeParser.cpp"
499		break;
500		}
501		default:
#	Line 317 | Line 513 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
513		}
514
515		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
516	<	#line 242 "MDTreeParser.g"
516	>	#line 286 "MDTreeParser.g"
517		int ival;
518	<	#line 323 "MDTreeParser.cpp"
519	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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
#	Line 333 | Line 529 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
529		i1 = _t;
530		match(_t,NUM_INT);
531		_t = _t->getNextSibling();
532	<	#line 243 "MDTreeParser.g"
532	>	#line 287 "MDTreeParser.g"
533		ival = lexi_cast<int>(i1->getText());
534	<	#line 339 "MDTreeParser.cpp"
534	>	#line 535 "MDTreeParser.cpp"
535		break;
536		}
537		case NUM_LONG:
#	Line 343 | Line 539 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
539		i2 = _t;
540		match(_t,NUM_LONG);
541		_t = _t->getNextSibling();
542	<	#line 244 "MDTreeParser.g"
542	>	#line 288 "MDTreeParser.g"
543		ival = lexi_cast<int>(i2->getText());
544	<	#line 349 "MDTreeParser.cpp"
544	>	#line 545 "MDTreeParser.cpp"
545		break;
546		}
547		default:
#	Line 364 | Line 560 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
560		}
561
562		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
563	<	#line 256 "MDTreeParser.g"
563	>	#line 300 "MDTreeParser.g"
564		RealType dval;
565	<	#line 370 "MDTreeParser.cpp"
566	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 380 | Line 576 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
576		d1 = _t;
577		match(_t,NUM_FLOAT);
578		_t = _t->getNextSibling();
579	<	#line 257 "MDTreeParser.g"
579	>	#line 301 "MDTreeParser.g"
580		dval = lexi_cast<RealType>(d1->getText());
581	<	#line 386 "MDTreeParser.cpp"
581	>	#line 582 "MDTreeParser.cpp"
582		break;
583		}
584		case NUM_DOUBLE:
#	Line 390 | Line 586 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
586		d2 = _t;
587		match(_t,NUM_DOUBLE);
588		_t = _t->getNextSibling();
589	<	#line 258 "MDTreeParser.g"
589	>	#line 302 "MDTreeParser.g"
590		dval = lexi_cast<RealType>(d2->getText());
591	<	#line 396 "MDTreeParser.cpp"
591	>	#line 592 "MDTreeParser.cpp"
592		break;
593		}
594		default:
#	Line 411 | 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 447 | 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 480 | 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 87 "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 489 "MDTreeParser.cpp"
690	>	#line 691 "MDTreeParser.cpp"
691
692		try {      // for error handling
693	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
694	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_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 91 "MDTreeParser.g"
699	>	#line 116 "MDTreeParser.g"
700		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
701	<	#line 500 "MDTreeParser.cpp"
701	>	#line 702 "MDTreeParser.cpp"
702		{ // ( ... )*
703		for (;;) {
704		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 506 | Line 708 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
708		_t = _retTree;
709		}
710		else {
711	<	goto _loop24;
711	>	goto _loop40;
712		}
713
714		}
715	<	_loop24:;
715	>	_loop40:;
716		} // ( ... )*
717	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
717	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
718		match(_t,ENDBLOCK);
719		_t = _t->getNextSibling();
720	<	_t = __t22;
720	>	_t = __t38;
721		_t = _t->getNextSibling();
722	<	#line 93 "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 528 "MDTreeParser.cpp"
729	>	#line 730 "MDTreeParser.cpp"
730		}
731		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
732		reportError(ex);
#	Line 535 | 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 __t29 = _t;
744	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_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 113 "MDTreeParser.g"
747	>	#line 138 "MDTreeParser.g"
748		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
749	<	#line 548 "MDTreeParser.cpp"
749	>	#line 750 "MDTreeParser.cpp"
750		{ // ( ... )*
751		for (;;) {
752		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 554 | Line 756 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
756		_t = _retTree;
757		}
758		else {
759	<	goto _loop31;
759	>	goto _loop47;
760		}
761
762		}
763	<	_loop31:;
763	>	_loop47:;
764		} // ( ... )*
765	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
765	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
766		match(_t,ENDBLOCK);
767		_t = _t->getNextSibling();
768	<	_t = __t29;
768	>	_t = __t45;
769		_t = _t->getNextSibling();
770	<	#line 115 "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 575 "MDTreeParser.cpp"
776	>	#line 777 "MDTreeParser.cpp"
777		}
778		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
779		reportError(ex);
#	Line 582 | 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 __t35 = _t;
791	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_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 131 "MDTreeParser.g"
794	>	#line 156 "MDTreeParser.g"
795		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
796	<	#line 595 "MDTreeParser.cpp"
796	>	#line 797 "MDTreeParser.cpp"
797		{ // ( ... )*
798		for (;;) {
799		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 601 | Line 803 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
803		_t = _retTree;
804		}
805		else {
806	<	goto _loop37;
806	>	goto _loop53;
807		}
808
809		}
810	<	_loop37:;
810	>	_loop53:;
811		} // ( ... )*
812	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
812	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
813		match(_t,ENDBLOCK);
814		_t = _t->getNextSibling();
815	<	_t = __t35;
815	>	_t = __t51;
816		_t = _t->getNextSibling();
817	<	#line 133 "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 623 "MDTreeParser.cpp"
824	>	#line 825 "MDTreeParser.cpp"
825		}
826		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
827		reportError(ex);
#	Line 630 | 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 __t41 = _t;
839	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_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 150 "MDTreeParser.g"
842	>	#line 175 "MDTreeParser.g"
843		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
844	<	#line 643 "MDTreeParser.cpp"
844	>	#line 845 "MDTreeParser.cpp"
845		{ // ( ... )*
846		for (;;) {
847		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 649 | Line 851 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
851		_t = _retTree;
852		}
853		else {
854	<	goto _loop43;
854	>	goto _loop59;
855		}
856
857		}
858	<	_loop43:;
858	>	_loop59:;
859		} // ( ... )*
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
860	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
861		match(_t,ENDBLOCK);
862		_t = _t->getNextSibling();
863	<	_t = __t41;
863	>	_t = __t57;
864		_t = _t->getNextSibling();
865	<	#line 152 "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 671 "MDTreeParser.cpp"
872	>	#line 873 "MDTreeParser.cpp"
873		}
874		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
875		reportError(ex);
#	Line 677 | 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 169 "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 687 "MDTreeParser.cpp"
936	>	#line 937 "MDTreeParser.cpp"
937
938		try {      // for error handling
939	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
940	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_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 173 "MDTreeParser.g"
945	>	#line 217 "MDTreeParser.g"
946		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
947	<	#line 698 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948		{ // ( ... )*
949		for (;;) {
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 704 | Line 954 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
954		_t = _retTree;
955		}
956		else {
957	<	goto _loop49;
957	>	goto _loop71;
958		}
959
960		}
961	<	_loop49:;
961	>	_loop71:;
962		} // ( ... )*
963	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
963	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
964		match(_t,ENDBLOCK);
965		_t = _t->getNextSibling();
966	<	_t = __t47;
966	>	_t = __t69;
967		_t = _t->getNextSibling();
968	<	#line 175 "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 726 "MDTreeParser.cpp"
975	>	#line 976 "MDTreeParser.cpp"
976		}
977		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
978		reportError(ex);
#	Line 733 | 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 __t53 = _t;
990	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_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 192 "MDTreeParser.g"
993	>	#line 236 "MDTreeParser.g"
994		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
995	<	#line 746 "MDTreeParser.cpp"
995	>	#line 996 "MDTreeParser.cpp"
996		{ // ( ... )*
997		for (;;) {
998		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 752 | Line 1002 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1002		_t = _retTree;
1003		}
1004		else {
1005	<	goto _loop55;
1005	>	goto _loop77;
1006		}
1007
1008		}
1009	<	_loop55:;
1009	>	_loop77:;
1010		} // ( ... )*
1011	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1011	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1012		match(_t,ENDBLOCK);
1013		_t = _t->getNextSibling();
1014	<	_t = __t53;
1014	>	_t = __t75;
1015		_t = _t->getNextSibling();
1016	<	#line 194 "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 774 "MDTreeParser.cpp"
1023	>	#line 1024 "MDTreeParser.cpp"
1024		}
1025		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1026		reportError(ex);
#	Line 781 | 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 211 "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 788 "MDTreeParser.cpp"
1037	>	#line 1038 "MDTreeParser.cpp"
1038
1039		try {      // for error handling
1040	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
1041	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_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 212 "MDTreeParser.g"
1046	>	#line 256 "MDTreeParser.g"
1047		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1048	<	#line 799 "MDTreeParser.cpp"
1048	>	#line 1049 "MDTreeParser.cpp"
1049		{ // ( ... )*
1050		for (;;) {
1051		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 805 | Line 1055 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1055		_t = _retTree;
1056		}
1057		else {
1058	<	goto _loop61;
1058	>	goto _loop83;
1059		}
1060
1061		}
1062	<	_loop61:;
1062	>	_loop83:;
1063		} // ( ... )*
1064	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1064	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1065		match(_t,ENDBLOCK);
1066		_t = _t->getNextSibling();
1067	<	_t = __t59;
1067	>	_t = __t81;
1068		_t = _t->getNextSibling();
1069	<	#line 214 "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 827 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		}
1078		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1079		reportError(ex);
#	Line 834 | 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 101 "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<RealType> dvec;
1091		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1092
1093
1094	<	#line 845 "MDTreeParser.cpp"
1094	>	#line 1095 "MDTreeParser.cpp"
1095
1096		try {      // for error handling
1097		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 855 | Line 1105 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1105		}
1106		case POSITION:
1107		{
1108	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
1109	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_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=doubleNumberTuple(_t);
1113		_t = _retTree;
1114	<	_t = __t26;
1114	>	_t = __t42;
1115		_t = _t->getNextSibling();
1116	<	#line 108 "MDTreeParser.g"
1116	>	#line 133 "MDTreeParser.g"
1117		currAtomStamp->setPosition(dvec);
1118	<	#line 869 "MDTreeParser.cpp"
1118	>	#line 1119 "MDTreeParser.cpp"
1119		break;
1120		}
1121		case ORIENTATION:
1122		{
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
1124	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_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=doubleNumberTuple(_t);
1128		_t = _retTree;
1129	<	_t = __t27;
1129	>	_t = __t43;
1130		_t = _t->getNextSibling();
1131	<	#line 109 "MDTreeParser.g"
1131	>	#line 134 "MDTreeParser.g"
1132		currAtomStamp->setOrientation(dvec);
1133	<	#line 884 "MDTreeParser.cpp"
1133	>	#line 1134 "MDTreeParser.cpp"
1134		break;
1135		}
1136		default:
#	Line 898 | Line 1148 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1148		}
1149
1150		vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151	<	#line 227 "MDTreeParser.g"
1151	>	#line 271 "MDTreeParser.g"
1152		vector<RealType> dvec;
1153	<	#line 904 "MDTreeParser.cpp"
1154	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1155	<	#line 227 "MDTreeParser.g"
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		RealType dval;
1158
1159	<	#line 910 "MDTreeParser.cpp"
1159	>	#line 1160 "MDTreeParser.cpp"
1160
1161		try {      // for error handling
1162		{ // ( ... )+
1163	<	int _cnt65=0;
1163	>	int _cnt87=0;
1164		for (;;) {
1165		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1166		_t = ASTNULL;
1167		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1168		dval=doubleNumber(_t);
1169		_t = _retTree;
1170	<	#line 231 "MDTreeParser.g"
1170	>	#line 275 "MDTreeParser.g"
1171		dvec.push_back(dval);
1172	<	#line 923 "MDTreeParser.cpp"
1172	>	#line 1173 "MDTreeParser.cpp"
1173		}
1174		else {
1175	<	if ( _cnt65>=1 ) { goto _loop65; } 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	<	_cnt65++;
1178	>	_cnt87++;
1179		}
1180	<	_loop65:;
1180	>	_loop87:;
1181		}  // ( ... )+
1182		}
1183		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 940 | 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 122 "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 950 "MDTreeParser.cpp"
1199	>	#line 1200 "MDTreeParser.cpp"
1200
1201		try {      // for error handling
1202		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 960 | Line 1210 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1210		}
1211		case MEMBERS:
1212		{
1213	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1214	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_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 = __t33;
1219	>	_t = __t49;
1220		_t = _t->getNextSibling();
1221	<	#line 128 "MDTreeParser.g"
1221	>	#line 153 "MDTreeParser.g"
1222		currBondStamp->setMembers(ivec);
1223	<	#line 974 "MDTreeParser.cpp"
1223	>	#line 1224 "MDTreeParser.cpp"
1224		break;
1225		}
1226		default:
#	Line 988 | Line 1238 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1238		}
1239
1240		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1241	<	#line 234 "MDTreeParser.g"
1241	>	#line 278 "MDTreeParser.g"
1242		vector<int> ivec;
1243	<	#line 994 "MDTreeParser.cpp"
1244	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1245	<	#line 234 "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 1000 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250
1251		try {      // for error handling
1252		{ // ( ... )+
1253	<	int _cnt68=0;
1253	>	int _cnt90=0;
1254		for (;;) {
1255		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1256		_t = ASTNULL;
1257		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1258		ival=intConst(_t);
1259		_t = _retTree;
1260	<	#line 238 "MDTreeParser.g"
1260	>	#line 282 "MDTreeParser.g"
1261		ivec.push_back(ival);
1262	<	#line 1013 "MDTreeParser.cpp"
1262	>	#line 1263 "MDTreeParser.cpp"
1263		}
1264		else {
1265	<	if ( _cnt68>=1 ) { goto _loop68; } 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	<	_cnt68++;
1268	>	_cnt90++;
1269		}
1270	<	_loop68:;
1270	>	_loop90:;
1271		}  // ( ... )+
1272		}
1273		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1030 | 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 141 "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 1040 "MDTreeParser.cpp"
1289	>	#line 1290 "MDTreeParser.cpp"
1290
1291		try {      // for error handling
1292		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1050 | Line 1300 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1300		}
1301		case MEMBERS:
1302		{
1303	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1304	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_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 = __t39;
1309	>	_t = __t55;
1310		_t = _t->getNextSibling();
1311	<	#line 147 "MDTreeParser.g"
1311	>	#line 172 "MDTreeParser.g"
1312		currBendStamp->setMembers(ivec);
1313	<	#line 1064 "MDTreeParser.cpp"
1313	>	#line 1314 "MDTreeParser.cpp"
1314		break;
1315		}
1316		default:
#	Line 1078 | 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 160 "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 1088 "MDTreeParser.cpp"
1337	>	#line 1338 "MDTreeParser.cpp"
1338
1339		try {      // for error handling
1340		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1098 | Line 1348 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1348		}
1349		case MEMBERS:
1350		{
1351	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1352	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_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 = __t45;
1357	>	_t = __t61;
1358		_t = _t->getNextSibling();
1359	<	#line 166 "MDTreeParser.g"
1359	>	#line 191 "MDTreeParser.g"
1360		currTorsionStamp->setMembers(ivec);
1361	<	#line 1112 "MDTreeParser.cpp"
1361	>	#line 1362 "MDTreeParser.cpp"
1362		break;
1363		}
1364		default:
#	Line 1125 | 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 183 "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 1136 "MDTreeParser.cpp"
1433	>	#line 1434 "MDTreeParser.cpp"
1434
1435		try {      // for error handling
1436		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1146 | Line 1444 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1444		}
1445		case MEMBERS:
1446		{
1447	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1448	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_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 = __t51;
1453	>	_t = __t73;
1454		_t = _t->getNextSibling();
1455	<	#line 189 "MDTreeParser.g"
1455	>	#line 233 "MDTreeParser.g"
1456		currRigidBodyStamp->setMembers(ivec);
1457	<	#line 1160 "MDTreeParser.cpp"
1457	>	#line 1458 "MDTreeParser.cpp"
1458		break;
1459		}
1460		default:
#	Line 1174 | 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 202 "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 1184 "MDTreeParser.cpp"
1481	>	#line 1482 "MDTreeParser.cpp"
1482
1483		try {      // for error handling
1484		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1194 | Line 1492 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1492		}
1493		case MEMBERS:
1494		{
1495	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1496	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 = __t57;
1501	>	_t = __t79;
1502		_t = _t->getNextSibling();
1503	<	#line 208 "MDTreeParser.g"
1503	>	#line 252 "MDTreeParser.g"
1504		currCutoffGroupStamp->setMembers(ivec);
1505	<	#line 1208 "MDTreeParser.cpp"
1505	>	#line 1506 "MDTreeParser.cpp"
1506		break;
1507		}
1508		default:
#	Line 1222 | 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 1237 | Line 1535 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1535		}
1536
1537		RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538	<	#line 248 "MDTreeParser.g"
1538	>	#line 292 "MDTreeParser.g"
1539		RealType dval;
1540	<	#line 1243 "MDTreeParser.cpp"
1541	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 1254 | Line 1552 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1552		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1553		intConst(_t);
1554		_t = _retTree;
1555	<	#line 250 "MDTreeParser.g"
1555	>	#line 294 "MDTreeParser.g"
1556		dval = lexi_cast<RealType>(ic->getText());
1557	<	#line 1260 "MDTreeParser.cpp"
1557	>	#line 1558 "MDTreeParser.cpp"
1558		break;
1559		}
1560		case NUM_FLOAT:
#	Line 1265 | Line 1563 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1563		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1564		floatConst(_t);
1565		_t = _retTree;
1566	<	#line 251 "MDTreeParser.g"
1566	>	#line 295 "MDTreeParser.g"
1567		dval = lexi_cast<RealType>(fc->getText());
1568	<	#line 1271 "MDTreeParser.cpp"
1568	>	#line 1569 "MDTreeParser.cpp"
1569		break;
1570		}
1571		default:
#	Line 1296 | 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 1343 | Line 1647 | const char* MDTreeParser::tokenNames[] = {
1647		0
1648		};
1649
1650	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1651	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1348	<	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1349	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1350	<	// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
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 963 by tim, Wed May 17 21:51:42 2006 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