ViewVC Help

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

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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.7 (20080702): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20121118): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2		#include "MDTreeParser.hpp"
3		#include <antlr/Token.hpp>
4		#include <antlr/AST.hpp>
#	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 117 | Line 141 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
141		ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
142
143		try {      // for error handling
144	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
144	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
145		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146		match(_t,COMPONENT);
147		_t = _t->getFirstChild();
148	<	#line 62 "MDTreeParser.g"
148	>	#line 72 "MDTreeParser.g"
149		Component* currComponet = new Component(); blockStack.push(currComponet);
150	<	#line 127 "MDTreeParser.cpp"
150	>	#line 151 "MDTreeParser.cpp"
151		{ // ( ... )*
152		for (;;) {
153		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 133 | Line 157 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
157		_t = _retTree;
158		}
159		else {
160	<	goto _loop11;
160	>	goto _loop12;
161		}
162
163		}
164	<	_loop11:;
164	>	_loop12:;
165		} // ( ... )*
166		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167		match(_t,ENDBLOCK);
168		_t = _t->getNextSibling();
169	<	_t = __t9;
169	>	_t = __t10;
170		_t = _t->getNextSibling();
171	<	#line 64 "MDTreeParser.g"
171	>	#line 74 "MDTreeParser.g"
172		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173	<	#line 150 "MDTreeParser.cpp"
173	>	#line 174 "MDTreeParser.cpp"
174		}
175		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176		reportError(ex);
#	Line 160 | Line 184 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
184		ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
185
186		try {      // for error handling
187	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
187	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
188		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189		match(_t,MOLECULE);
190		_t = _t->getFirstChild();
191	<	#line 72 "MDTreeParser.g"
191	>	#line 103 "MDTreeParser.g"
192		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193	<	#line 170 "MDTreeParser.cpp"
193	>	#line 194 "MDTreeParser.cpp"
194		{ // ( ... )*
195		for (;;) {
196		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 176 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200		_t = _retTree;
201		}
202		else {
203	<	goto _loop19;
203	>	goto _loop36;
204		}
205
206		}
207	<	_loop19:;
207	>	_loop36:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t17;
212	>	_t = __t34;
213		_t = _t->getNextSibling();
214	<	#line 74 "MDTreeParser.g"
214	>	#line 105 "MDTreeParser.g"
215		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216	<	#line 193 "MDTreeParser.cpp"
216	>	#line 217 "MDTreeParser.cpp"
217		}
218		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219		reportError(ex);
#	Line 203 | Line 227 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
227		ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
228
229		try {      // for error handling
230	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
230	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t;
231		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232		match(_t,ZCONSTRAINT);
233		_t = _t->getFirstChild();
234	<	#line 67 "MDTreeParser.g"
234	>	#line 77 "MDTreeParser.g"
235		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236	<	#line 213 "MDTreeParser.cpp"
236	>	#line 237 "MDTreeParser.cpp"
237		{ // ( ... )*
238		for (;;) {
239		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 219 | Line 243 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
243		_t = _retTree;
244		}
245		else {
246	<	goto _loop15;
246	>	goto _loop16;
247		}
248
249		}
250	<	_loop15:;
250	>	_loop16:;
251		} // ( ... )*
252		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253		match(_t,ENDBLOCK);
254		_t = _t->getNextSibling();
255	<	_t = __t13;
255	>	_t = __t14;
256		_t = _t->getNextSibling();
257	<	#line 69 "MDTreeParser.g"
257	>	#line 79 "MDTreeParser.g"
258		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259	<	#line 236 "MDTreeParser.cpp"
259	>	#line 260 "MDTreeParser.cpp"
260	>	}
261	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262	>	reportError(ex);
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 __t18 = _t;
274	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275	>	match(_t,RESTRAINT);
276	>	_t = _t->getFirstChild();
277	>	#line 82 "MDTreeParser.g"
278	>	RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279	>	#line 280 "MDTreeParser.cpp"
280	>	{ // ( ... )*
281	>	for (;;) {
282	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
283	>	_t = ASTNULL;
284	>	if ((_t->getType() == ASSIGNEQUAL)) {
285	>	assignment(_t);
286	>	_t = _retTree;
287	>	}
288	>	else {
289	>	goto _loop20;
290	>	}
291	>
292	>	}
293	>	_loop20:;
294	>	} // ( ... )*
295	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296	>	match(_t,ENDBLOCK);
297	>	_t = _t->getNextSibling();
298	>	_t = __t18;
299	>	_t = _t->getNextSibling();
300	>	#line 84 "MDTreeParser.g"
301	>	blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302	>	#line 303 "MDTreeParser.cpp"
303	>	}
304	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305	>	reportError(ex);
306	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
307	>	_t = _t->getNextSibling();
308	>	}
309	>	_retTree = _t;
310	>	}
311	>
312	>	void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
313	>	ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
314	>
315	>	try {      // for error handling
316	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
317	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318	>	match(_t,FLUCQ);
319	>	_t = _t->getFirstChild();
320	>	#line 87 "MDTreeParser.g"
321	>	FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322	>	#line 323 "MDTreeParser.cpp"
323	>	{ // ( ... )*
324	>	for (;;) {
325	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
326	>	_t = ASTNULL;
327	>	if ((_t->getType() == ASSIGNEQUAL)) {
328	>	assignment(_t);
329	>	_t = _retTree;
330	>	}
331	>	else {
332	>	goto _loop24;
333	>	}
334	>
335	>	}
336	>	_loop24:;
337	>	} // ( ... )*
338	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339	>	match(_t,ENDBLOCK);
340	>	_t = _t->getNextSibling();
341	>	_t = __t22;
342	>	_t = _t->getNextSibling();
343	>	#line 89 "MDTreeParser.g"
344	>	blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345	>	#line 346 "MDTreeParser.cpp"
346	>	}
347	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348	>	reportError(ex);
349	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
350	>	_t = _t->getNextSibling();
351	>	}
352	>	_retTree = _t;
353	>	}
354	>
355	>	void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
356	>	ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
357	>
358	>	try {      // for error handling
359	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
360	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361	>	match(_t,RNEMD);
362	>	_t = _t->getFirstChild();
363	>	#line 92 "MDTreeParser.g"
364	>	RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365	>	#line 366 "MDTreeParser.cpp"
366	>	{ // ( ... )*
367	>	for (;;) {
368	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
369	>	_t = ASTNULL;
370	>	if ((_t->getType() == ASSIGNEQUAL)) {
371	>	assignment(_t);
372	>	_t = _retTree;
373	>	}
374	>	else {
375	>	goto _loop28;
376	>	}
377	>
378	>	}
379	>	_loop28:;
380	>	} // ( ... )*
381	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382	>	match(_t,ENDBLOCK);
383	>	_t = _t->getNextSibling();
384	>	_t = __t26;
385	>	_t = _t->getNextSibling();
386	>	#line 94 "MDTreeParser.g"
387	>	blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388	>	#line 389 "MDTreeParser.cpp"
389	>	}
390	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
391	>	reportError(ex);
392	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
393	>	_t = _t->getNextSibling();
394	>	}
395	>	_retTree = _t;
396	>	}
397	>
398	>	void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
399	>	ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
400	>
401	>	try {      // for error handling
402	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
403	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404	>	match(_t,MINIMIZER);
405	>	_t = _t->getFirstChild();
406	>	#line 97 "MDTreeParser.g"
407	>	MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408	>	#line 409 "MDTreeParser.cpp"
409	>	{ // ( ... )*
410	>	for (;;) {
411	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
412	>	_t = ASTNULL;
413	>	if ((_t->getType() == ASSIGNEQUAL)) {
414	>	assignment(_t);
415	>	_t = _retTree;
416	>	}
417	>	else {
418	>	goto _loop32;
419	>	}
420	>
421	>	}
422	>	_loop32:;
423	>	} // ( ... )*
424	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425	>	match(_t,ENDBLOCK);
426	>	_t = _t->getNextSibling();
427	>	_t = __t30;
428	>	_t = _t->getNextSibling();
429	>	#line 99 "MDTreeParser.g"
430	>	blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431	>	#line 432 "MDTreeParser.cpp"
432		}
433		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
434		reportError(ex);
#	Line 248 | Line 444 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
444		ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447	<	#line 47 "MDTreeParser.g"
447	>	#line 50 "MDTreeParser.g"
448
449		int ival;
450	<	RealType dval;
450	>	RealType dval, x, y, z;
451	>	Vector3d dvec;
452
453	<	#line 257 "MDTreeParser.cpp"
453	>	#line 454 "MDTreeParser.cpp"
454
455		try {      // for error handling
456		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 264 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
461		{
462		ival=intConst(_t);
463		_t = _retTree;
464	<	#line 52 "MDTreeParser.g"
464	>	#line 56 "MDTreeParser.g"
465		blockStack.top()->assign(id->getText(), ival);
466	<	#line 270 "MDTreeParser.cpp"
466	>	#line 467 "MDTreeParser.cpp"
467		break;
468		}
469		case NUM_FLOAT:
#	Line 274 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
471		{
472		dval=floatConst(_t);
473		_t = _retTree;
474	<	#line 53 "MDTreeParser.g"
474	>	#line 57 "MDTreeParser.g"
475		blockStack.top()->assign(id->getText(), dval);
476	<	#line 280 "MDTreeParser.cpp"
476	>	#line 477 "MDTreeParser.cpp"
477		break;
478		}
479	+	case LPAREN:
480	+	{
481	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
482	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
483	+	match(_t,LPAREN);
484	+	_t = _t->getFirstChild();
485	+	x=doubleNumber(_t);
486	+	_t = _retTree;
487	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
488	+	match(_t,COMMA);
489	+	_t = _t->getNextSibling();
490	+	y=doubleNumber(_t);
491	+	_t = _retTree;
492	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
493	+	match(_t,COMMA);
494	+	_t = _t->getNextSibling();
495	+	z=doubleNumber(_t);
496	+	_t = _retTree;
497	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
498	+	match(_t,RPAREN);
499	+	_t = _t->getNextSibling();
500	+	_t = __t8;
501	+	_t = _t->getNextSibling();
502	+	#line 59 "MDTreeParser.g"
503	+	dvec.x() = x;
504	+	dvec.y() = y;
505	+	dvec.z() = z;
506	+	blockStack.top()->assign(id->getText(), dvec);
507	+
508	+	#line 509 "MDTreeParser.cpp"
509	+	break;
510	+	}
511		case ID:
512		{
513		str1 = _t;
514		match(_t,ID);
515		_t = _t->getNextSibling();
516	<	#line 54 "MDTreeParser.g"
516	>	#line 64 "MDTreeParser.g"
517		blockStack.top()->assign(id->getText(), str1->getText());
518	<	#line 290 "MDTreeParser.cpp"
518	>	#line 519 "MDTreeParser.cpp"
519		break;
520		}
521		case StringLiteral:
#	Line 294 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523		str2 = _t;
524		match(_t,StringLiteral);
525		_t = _t->getNextSibling();
526	<	#line 55 "MDTreeParser.g"
526	>	#line 65 "MDTreeParser.g"
527		std::string s =  str2->getText();
528		s = s.substr(1, s.length()-2);
529		blockStack.top()->assign(id->getText(),s);
530
531	<	#line 303 "MDTreeParser.cpp"
531	>	#line 532 "MDTreeParser.cpp"
532		break;
533		}
534		default:
#	Line 317 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546		}
547
548		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549	<	#line 262 "MDTreeParser.g"
549	>	#line 296 "MDTreeParser.g"
550		int ival;
551	<	#line 323 "MDTreeParser.cpp"
551	>	#line 552 "MDTreeParser.cpp"
552		ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
553		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
554		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 333 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562		i1 = _t;
563		match(_t,NUM_INT);
564		_t = _t->getNextSibling();
565	<	#line 263 "MDTreeParser.g"
565	>	#line 297 "MDTreeParser.g"
566		ival = lexi_cast<int>(i1->getText());
567	<	#line 339 "MDTreeParser.cpp"
567	>	#line 568 "MDTreeParser.cpp"
568		break;
569		}
570		case NUM_LONG:
#	Line 343 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572		i2 = _t;
573		match(_t,NUM_LONG);
574		_t = _t->getNextSibling();
575	<	#line 264 "MDTreeParser.g"
575	>	#line 298 "MDTreeParser.g"
576		ival = lexi_cast<int>(i2->getText());
577	<	#line 349 "MDTreeParser.cpp"
577	>	#line 578 "MDTreeParser.cpp"
578		break;
579		}
580		default:
#	Line 364 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593		}
594
595		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596	<	#line 276 "MDTreeParser.g"
596	>	#line 308 "MDTreeParser.g"
597		RealType dval;
598	<	#line 370 "MDTreeParser.cpp"
598	>	#line 599 "MDTreeParser.cpp"
599		ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
600		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
601		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 380 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609		d1 = _t;
610		match(_t,NUM_FLOAT);
611		_t = _t->getNextSibling();
612	<	#line 277 "MDTreeParser.g"
612	>	#line 309 "MDTreeParser.g"
613		dval = lexi_cast<RealType>(d1->getText());
614	<	#line 386 "MDTreeParser.cpp"
614	>	#line 615 "MDTreeParser.cpp"
615		break;
616		}
617		case NUM_DOUBLE:
#	Line 390 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619		d2 = _t;
620		match(_t,NUM_DOUBLE);
621		_t = _t->getNextSibling();
622	<	#line 278 "MDTreeParser.g"
622	>	#line 310 "MDTreeParser.g"
623		dval = lexi_cast<RealType>(d2->getText());
624	<	#line 396 "MDTreeParser.cpp"
624	>	#line 625 "MDTreeParser.cpp"
625	>	break;
626	>	}
627	>	default:
628	>	{
629	>	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
630	>	}
631	>	}
632	>	}
633	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
634	>	reportError(ex);
635	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
636	>	_t = _t->getNextSibling();
637	>	}
638	>	_retTree = _t;
639	>	return dval;
640	>	}
641	>
642	>	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643	>	#line 302 "MDTreeParser.g"
644	>	RealType dval;
645	>	#line 646 "MDTreeParser.cpp"
646	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647	>	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
648	>	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
649	>
650	>	try {      // for error handling
651	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
652	>	_t = ASTNULL;
653	>	switch ( _t->getType()) {
654	>	case NUM_INT:
655	>	case NUM_LONG:
656	>	{
657	>	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658	>	intConst(_t);
659	>	_t = _retTree;
660	>	#line 303 "MDTreeParser.g"
661	>	dval = lexi_cast<RealType>(ic->getText());
662	>	#line 663 "MDTreeParser.cpp"
663		break;
664		}
665	+	case NUM_FLOAT:
666	+	case NUM_DOUBLE:
667	+	{
668	+	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669	+	floatConst(_t);
670	+	_t = _retTree;
671	+	#line 304 "MDTreeParser.g"
672	+	dval = lexi_cast<RealType>(fc->getText());
673	+	#line 674 "MDTreeParser.cpp"
674	+	break;
675	+	}
676		default:
677		{
678		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 487 | Line 765 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
765
766		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
767		ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768	<	#line 88 "MDTreeParser.g"
768	>	#line 119 "MDTreeParser.g"
769
770		int index;
771
772	<	#line 495 "MDTreeParser.cpp"
772	>	#line 773 "MDTreeParser.cpp"
773
774		try {      // for error handling
775	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
776	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
775	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
776	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
777		match(_t,ATOM);
778		_t = _t->getFirstChild();
779		index=intConst(_t);
780		_t = _retTree;
781	<	#line 92 "MDTreeParser.g"
781	>	#line 123 "MDTreeParser.g"
782		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783	<	#line 506 "MDTreeParser.cpp"
783	>	#line 784 "MDTreeParser.cpp"
784		{ // ( ... )*
785		for (;;) {
786		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 512 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790		_t = _retTree;
791		}
792		else {
793	<	goto _loop24;
793	>	goto _loop41;
794		}
795
796		}
797	<	_loop24:;
797	>	_loop41:;
798		} // ( ... )*
799	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
799	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800		match(_t,ENDBLOCK);
801		_t = _t->getNextSibling();
802	<	_t = __t22;
802	>	_t = __t39;
803		_t = _t->getNextSibling();
804	<	#line 94 "MDTreeParser.g"
804	>	#line 125 "MDTreeParser.g"
805
806		blockStack.top()->validate();
807		blockStack.pop();
808		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
809		currMoleculeStamp->addAtomStamp(currAtomStamp);
810
811	<	#line 534 "MDTreeParser.cpp"
811	>	#line 812 "MDTreeParser.cpp"
812		}
813		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814		reportError(ex);
#	Line 544 | Line 822 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
822		ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
823
824		try {      // for error handling
825	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
826	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
825	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
826	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
827		match(_t,BOND);
828		_t = _t->getFirstChild();
829	<	#line 114 "MDTreeParser.g"
829	>	#line 145 "MDTreeParser.g"
830		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831	<	#line 554 "MDTreeParser.cpp"
831	>	#line 832 "MDTreeParser.cpp"
832		{ // ( ... )*
833		for (;;) {
834		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 560 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838		_t = _retTree;
839		}
840		else {
841	<	goto _loop31;
841	>	goto _loop48;
842		}
843
844		}
845	<	_loop31:;
845	>	_loop48:;
846		} // ( ... )*
847	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
847	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848		match(_t,ENDBLOCK);
849		_t = _t->getNextSibling();
850	<	_t = __t29;
850	>	_t = __t46;
851		_t = _t->getNextSibling();
852	<	#line 116 "MDTreeParser.g"
852	>	#line 147 "MDTreeParser.g"
853
854		blockStack.pop();
855		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
856		currMoleculeStamp->addBondStamp(currBondStamp);
857
858	<	#line 581 "MDTreeParser.cpp"
858	>	#line 859 "MDTreeParser.cpp"
859		}
860		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861		reportError(ex);
#	Line 591 | Line 869 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
869		ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
870
871		try {      // for error handling
872	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
873	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
872	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
873	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
874		match(_t,BEND);
875		_t = _t->getFirstChild();
876	<	#line 132 "MDTreeParser.g"
876	>	#line 163 "MDTreeParser.g"
877		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878	<	#line 601 "MDTreeParser.cpp"
878	>	#line 879 "MDTreeParser.cpp"
879		{ // ( ... )*
880		for (;;) {
881		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 607 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885		_t = _retTree;
886		}
887		else {
888	<	goto _loop37;
888	>	goto _loop54;
889		}
890
891		}
892	<	_loop37:;
892	>	_loop54:;
893		} // ( ... )*
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
894	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895		match(_t,ENDBLOCK);
896		_t = _t->getNextSibling();
897	<	_t = __t35;
897	>	_t = __t52;
898		_t = _t->getNextSibling();
899	<	#line 134 "MDTreeParser.g"
899	>	#line 165 "MDTreeParser.g"
900
901		blockStack.top()->validate();
902		blockStack.pop();
903		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
904		currMoleculeStamp->addBendStamp(currBendStamp);
905
906	<	#line 629 "MDTreeParser.cpp"
906	>	#line 907 "MDTreeParser.cpp"
907		}
908		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909		reportError(ex);
#	Line 639 | Line 917 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
917		ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
918
919		try {      // for error handling
920	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
921	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
920	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
921	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
922		match(_t,TORSION);
923		_t = _t->getFirstChild();
924	<	#line 151 "MDTreeParser.g"
924	>	#line 182 "MDTreeParser.g"
925		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926	<	#line 649 "MDTreeParser.cpp"
926	>	#line 927 "MDTreeParser.cpp"
927		{ // ( ... )*
928		for (;;) {
929		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 655 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933		_t = _retTree;
934		}
935		else {
936	<	goto _loop43;
936	>	goto _loop60;
937		}
938
939		}
940	<	_loop43:;
940	>	_loop60:;
941		} // ( ... )*
942	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
942	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943		match(_t,ENDBLOCK);
944		_t = _t->getNextSibling();
945	<	_t = __t41;
945	>	_t = __t58;
946		_t = _t->getNextSibling();
947	<	#line 153 "MDTreeParser.g"
947	>	#line 184 "MDTreeParser.g"
948
949		blockStack.top()->validate();
950		blockStack.pop();
951		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
952		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
953
954	<	#line 677 "MDTreeParser.cpp"
954	>	#line 955 "MDTreeParser.cpp"
955		}
956		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957		reportError(ex);
#	Line 687 | Line 965 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
965		ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
966
967		try {      // for error handling
968	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
969	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
968	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
969	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
970		match(_t,INVERSION);
971		_t = _t->getFirstChild();
972	<	#line 170 "MDTreeParser.g"
972	>	#line 201 "MDTreeParser.g"
973		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974	<	#line 697 "MDTreeParser.cpp"
974	>	#line 975 "MDTreeParser.cpp"
975		{ // ( ... )*
976		for (;;) {
977		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
978		_t = ASTNULL;
979	<	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
979	>	if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
980		inversionstatement(_t);
981		_t = _retTree;
982		}
983		else {
984	<	goto _loop49;
984	>	goto _loop66;
985		}
986
987		}
988	<	_loop49:;
988	>	_loop66:;
989		} // ( ... )*
990	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
990	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991		match(_t,ENDBLOCK);
992		_t = _t->getNextSibling();
993	<	_t = __t47;
993	>	_t = __t64;
994		_t = _t->getNextSibling();
995	<	#line 172 "MDTreeParser.g"
995	>	#line 203 "MDTreeParser.g"
996
997		blockStack.top()->validate();
998		blockStack.pop();
999		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1000		currMoleculeStamp->addInversionStamp(currInversionStamp);
1001
1002	<	#line 725 "MDTreeParser.cpp"
1002	>	#line 1003 "MDTreeParser.cpp"
1003		}
1004		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005		reportError(ex);
#	Line 733 | Line 1011 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1011
1012		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014	<	#line 189 "MDTreeParser.g"
1014	>	#line 222 "MDTreeParser.g"
1015
1016		int index;
1017
1018	<	#line 741 "MDTreeParser.cpp"
1018	>	#line 1019 "MDTreeParser.cpp"
1019
1020		try {      // for error handling
1021	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
1022	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1021	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1022	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023		match(_t,RIGIDBODY);
1024		_t = _t->getFirstChild();
1025		index=intConst(_t);
1026		_t = _retTree;
1027	<	#line 193 "MDTreeParser.g"
1027	>	#line 226 "MDTreeParser.g"
1028		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029	<	#line 752 "MDTreeParser.cpp"
1029	>	#line 1030 "MDTreeParser.cpp"
1030		{ // ( ... )*
1031		for (;;) {
1032		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 758 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036		_t = _retTree;
1037		}
1038		else {
1039	<	goto _loop55;
1039	>	goto _loop73;
1040		}
1041
1042		}
1043	<	_loop55:;
1043	>	_loop73:;
1044		} // ( ... )*
1045	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1045	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046		match(_t,ENDBLOCK);
1047		_t = _t->getNextSibling();
1048	<	_t = __t53;
1048	>	_t = __t71;
1049		_t = _t->getNextSibling();
1050	<	#line 195 "MDTreeParser.g"
1050	>	#line 228 "MDTreeParser.g"
1051
1052		blockStack.top()->validate();
1053		blockStack.pop();
1054		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1055		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1056
1057	<	#line 780 "MDTreeParser.cpp"
1057	>	#line 1058 "MDTreeParser.cpp"
1058		}
1059		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060		reportError(ex);
#	Line 790 | Line 1068 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1068		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069
1070		try {      // for error handling
1071	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
1072	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1071	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1072	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073		match(_t,CUTOFFGROUP);
1074		_t = _t->getFirstChild();
1075	<	#line 212 "MDTreeParser.g"
1075	>	#line 245 "MDTreeParser.g"
1076		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077	<	#line 800 "MDTreeParser.cpp"
1077	>	#line 1078 "MDTreeParser.cpp"
1078		{ // ( ... )*
1079		for (;;) {
1080		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 806 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084		_t = _retTree;
1085		}
1086		else {
1087	<	goto _loop61;
1087	>	goto _loop79;
1088		}
1089
1090		}
1091	<	_loop61:;
1091	>	_loop79:;
1092		} // ( ... )*
1093	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1093	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094		match(_t,ENDBLOCK);
1095		_t = _t->getNextSibling();
1096	<	_t = __t59;
1096	>	_t = __t77;
1097		_t = _t->getNextSibling();
1098	<	#line 214 "MDTreeParser.g"
1098	>	#line 247 "MDTreeParser.g"
1099
1100		blockStack.top()->validate();
1101		blockStack.pop();
1102		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1103		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1104
1105	<	#line 828 "MDTreeParser.cpp"
1105	>	#line 1106 "MDTreeParser.cpp"
1106		}
1107		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108		reportError(ex);
#	Line 836 | Line 1114 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1114
1115		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116		ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117	<	#line 231 "MDTreeParser.g"
1117	>	#line 264 "MDTreeParser.g"
1118		int ival;
1119	<	#line 842 "MDTreeParser.cpp"
1119	>	#line 1120 "MDTreeParser.cpp"
1120
1121		try {      // for error handling
1122	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1122	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1123	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124		match(_t,FRAGMENT);
1125		_t = _t->getFirstChild();
1126		ival=intConst(_t);
1127		_t = _retTree;
1128	<	#line 232 "MDTreeParser.g"
1128	>	#line 265 "MDTreeParser.g"
1129		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130	<	#line 853 "MDTreeParser.cpp"
1130	>	#line 1131 "MDTreeParser.cpp"
1131		{ // ( ... )*
1132		for (;;) {
1133		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 859 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137		_t = _retTree;
1138		}
1139		else {
1140	<	goto _loop67;
1140	>	goto _loop85;
1141		}
1142
1143		}
1144	<	_loop67:;
1144	>	_loop85:;
1145		} // ( ... )*
1146	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1146	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147		match(_t,ENDBLOCK);
1148		_t = _t->getNextSibling();
1149	<	_t = __t65;
1149	>	_t = __t83;
1150		_t = _t->getNextSibling();
1151	<	#line 234 "MDTreeParser.g"
1151	>	#line 267 "MDTreeParser.g"
1152
1153		blockStack.top()->validate();
1154		blockStack.pop();
1155		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1156		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1157
1158	<	#line 881 "MDTreeParser.cpp"
1158	>	#line 1159 "MDTreeParser.cpp"
1159		}
1160		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161		reportError(ex);
#	Line 889 | Line 1167 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1167
1168		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1169		ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170	<	#line 102 "MDTreeParser.g"
1170	>	#line 133 "MDTreeParser.g"
1171
1172		vector<RealType> dvec;
1173		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174
1175
1176	<	#line 899 "MDTreeParser.cpp"
1176	>	#line 1177 "MDTreeParser.cpp"
1177
1178		try {      // for error handling
1179		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 909 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187		}
1188		case POSITION:
1189		{
1190	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
1191	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1190	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1191	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1192		match(_t,POSITION);
1193		_t = _t->getFirstChild();
1194		dvec=doubleNumberTuple(_t);
1195		_t = _retTree;
1196	<	_t = __t26;
1196	>	_t = __t43;
1197		_t = _t->getNextSibling();
1198	<	#line 109 "MDTreeParser.g"
1198	>	#line 140 "MDTreeParser.g"
1199		currAtomStamp->setPosition(dvec);
1200	<	#line 923 "MDTreeParser.cpp"
1200	>	#line 1201 "MDTreeParser.cpp"
1201		break;
1202		}
1203		case ORIENTATION:
1204		{
1205	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
1206	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1205	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1206	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1207		match(_t,ORIENTATION);
1208		_t = _t->getFirstChild();
1209		dvec=doubleNumberTuple(_t);
1210		_t = _retTree;
1211	<	_t = __t27;
1211	>	_t = __t44;
1212		_t = _t->getNextSibling();
1213	<	#line 110 "MDTreeParser.g"
1213	>	#line 141 "MDTreeParser.g"
1214		currAtomStamp->setOrientation(dvec);
1215	<	#line 938 "MDTreeParser.cpp"
1215	>	#line 1216 "MDTreeParser.cpp"
1216		break;
1217		}
1218		default:
#	Line 952 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230		}
1231
1232		vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233	<	#line 247 "MDTreeParser.g"
1233	>	#line 280 "MDTreeParser.g"
1234		vector<RealType> dvec;
1235	<	#line 958 "MDTreeParser.cpp"
1235	>	#line 1236 "MDTreeParser.cpp"
1236		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237	<	#line 247 "MDTreeParser.g"
1237	>	#line 280 "MDTreeParser.g"
1238
1239		RealType dval;
1240
1241	<	#line 964 "MDTreeParser.cpp"
1241	>	#line 1242 "MDTreeParser.cpp"
1242
1243		try {      // for error handling
1244		{ // ( ... )+
1245	<	int _cnt71=0;
1245	>	int _cnt89=0;
1246		for (;;) {
1247		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248		_t = ASTNULL;
1249		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250		dval=doubleNumber(_t);
1251		_t = _retTree;
1252	<	#line 251 "MDTreeParser.g"
1252	>	#line 284 "MDTreeParser.g"
1253		dvec.push_back(dval);
1254	<	#line 977 "MDTreeParser.cpp"
1254	>	#line 1255 "MDTreeParser.cpp"
1255		}
1256		else {
1257	<	if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1257	>	if ( _cnt89>=1 ) { goto _loop89; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258		}
1259
1260	<	_cnt71++;
1260	>	_cnt89++;
1261		}
1262	<	_loop71:;
1262	>	_loop89:;
1263		}  // ( ... )+
1264		}
1265		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 995 | Line 1273 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1273
1274		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1275		ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276	<	#line 123 "MDTreeParser.g"
1276	>	#line 154 "MDTreeParser.g"
1277
1278		vector<int> ivec;
1279		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280
1281	<	#line 1004 "MDTreeParser.cpp"
1281	>	#line 1282 "MDTreeParser.cpp"
1282
1283		try {      // for error handling
1284		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1014 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292		}
1293		case MEMBERS:
1294		{
1295	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1296	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1295	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1296	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1297		match(_t,MEMBERS);
1298		_t = _t->getFirstChild();
1299		ivec=inttuple(_t);
1300		_t = _retTree;
1301	<	_t = __t33;
1301	>	_t = __t50;
1302		_t = _t->getNextSibling();
1303	<	#line 129 "MDTreeParser.g"
1303	>	#line 160 "MDTreeParser.g"
1304		currBondStamp->setMembers(ivec);
1305	<	#line 1028 "MDTreeParser.cpp"
1305	>	#line 1306 "MDTreeParser.cpp"
1306		break;
1307		}
1308		default:
#	Line 1042 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320		}
1321
1322		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323	<	#line 254 "MDTreeParser.g"
1323	>	#line 288 "MDTreeParser.g"
1324		vector<int> ivec;
1325	<	#line 1048 "MDTreeParser.cpp"
1325	>	#line 1326 "MDTreeParser.cpp"
1326		ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327	<	#line 254 "MDTreeParser.g"
1327	>	#line 288 "MDTreeParser.g"
1328
1329		int ival;
1330
1331	<	#line 1054 "MDTreeParser.cpp"
1331	>	#line 1332 "MDTreeParser.cpp"
1332
1333		try {      // for error handling
1334		{ // ( ... )+
1335	<	int _cnt74=0;
1335	>	int _cnt92=0;
1336		for (;;) {
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338		_t = ASTNULL;
1339		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340		ival=intConst(_t);
1341		_t = _retTree;
1342	<	#line 258 "MDTreeParser.g"
1342	>	#line 292 "MDTreeParser.g"
1343		ivec.push_back(ival);
1344	<	#line 1067 "MDTreeParser.cpp"
1344	>	#line 1345 "MDTreeParser.cpp"
1345		}
1346		else {
1347	<	if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1347	>	if ( _cnt92>=1 ) { goto _loop92; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348		}
1349
1350	<	_cnt74++;
1350	>	_cnt92++;
1351		}
1352	<	_loop74:;
1352	>	_loop92:;
1353		}  // ( ... )+
1354		}
1355		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1085 | Line 1363 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1363
1364		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1365		ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366	<	#line 142 "MDTreeParser.g"
1366	>	#line 173 "MDTreeParser.g"
1367
1368		vector<int> ivec;
1369		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370
1371	<	#line 1094 "MDTreeParser.cpp"
1371	>	#line 1372 "MDTreeParser.cpp"
1372
1373		try {      // for error handling
1374		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1104 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382		}
1383		case MEMBERS:
1384		{
1385	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1386	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1385	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1386	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1387		match(_t,MEMBERS);
1388		_t = _t->getFirstChild();
1389		ivec=inttuple(_t);
1390		_t = _retTree;
1391	<	_t = __t39;
1391	>	_t = __t56;
1392		_t = _t->getNextSibling();
1393	<	#line 148 "MDTreeParser.g"
1393	>	#line 179 "MDTreeParser.g"
1394		currBendStamp->setMembers(ivec);
1395	<	#line 1118 "MDTreeParser.cpp"
1395	>	#line 1396 "MDTreeParser.cpp"
1396		break;
1397		}
1398		default:
#	Line 1133 | Line 1411 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1411
1412		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1413		ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414	<	#line 161 "MDTreeParser.g"
1414	>	#line 192 "MDTreeParser.g"
1415
1416		vector<int> ivec;
1417		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418
1419	<	#line 1142 "MDTreeParser.cpp"
1419	>	#line 1420 "MDTreeParser.cpp"
1420
1421		try {      // for error handling
1422		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1152 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430		}
1431		case MEMBERS:
1432		{
1433	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1434	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1433	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1434	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1435		match(_t,MEMBERS);
1436		_t = _t->getFirstChild();
1437		ivec=inttuple(_t);
1438		_t = _retTree;
1439	<	_t = __t45;
1439	>	_t = __t62;
1440		_t = _t->getNextSibling();
1441	<	#line 167 "MDTreeParser.g"
1441	>	#line 198 "MDTreeParser.g"
1442		currTorsionStamp->setMembers(ivec);
1443	<	#line 1166 "MDTreeParser.cpp"
1443	>	#line 1444 "MDTreeParser.cpp"
1444		break;
1445		}
1446		default:
#	Line 1181 | Line 1459 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1459
1460		void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461		ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462	<	#line 180 "MDTreeParser.g"
1462	>	#line 211 "MDTreeParser.g"
1463
1464		int icent;
1465	+	vector<int> ivec;
1466		InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1467
1468	<	#line 1190 "MDTreeParser.cpp"
1468	>	#line 1469 "MDTreeParser.cpp"
1469
1470		try {      // for error handling
1471		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1200 | Line 1479 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1479		}
1480		case CENTER:
1481		{
1482	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1483	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1482	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1483	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1484		match(_t,CENTER);
1485		_t = _t->getFirstChild();
1486		icent=intConst(_t);
1487		_t = _retTree;
1488	<	_t = __t51;
1488	>	_t = __t68;
1489		_t = _t->getNextSibling();
1490	<	#line 186 "MDTreeParser.g"
1490	>	#line 218 "MDTreeParser.g"
1491		currInversionStamp->setCenter(icent);
1492	<	#line 1214 "MDTreeParser.cpp"
1492	>	#line 1493 "MDTreeParser.cpp"
1493		break;
1494		}
1495	+	case SATELLITES:
1496	+	{
1497	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1498	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1499	+	match(_t,SATELLITES);
1500	+	_t = _t->getFirstChild();
1501	+	ivec=inttuple(_t);
1502	+	_t = _retTree;
1503	+	_t = __t69;
1504	+	_t = _t->getNextSibling();
1505	+	#line 219 "MDTreeParser.g"
1506	+	currInversionStamp->setSatellites(ivec);
1507	+	#line 1508 "MDTreeParser.cpp"
1508	+	break;
1509	+	}
1510		default:
1511		{
1512		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 1229 | Line 1523 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1523
1524		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1525		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1526	<	#line 203 "MDTreeParser.g"
1526	>	#line 236 "MDTreeParser.g"
1527
1528		vector<int> ivec;
1529		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1530
1531	<	#line 1238 "MDTreeParser.cpp"
1531	>	#line 1532 "MDTreeParser.cpp"
1532
1533		try {      // for error handling
1534		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1248 | Line 1542 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1542		}
1543		case MEMBERS:
1544		{
1545	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1546	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1545	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1546	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1547		match(_t,MEMBERS);
1548		_t = _t->getFirstChild();
1549		ivec=inttuple(_t);
1550		_t = _retTree;
1551	<	_t = __t57;
1551	>	_t = __t75;
1552		_t = _t->getNextSibling();
1553	<	#line 209 "MDTreeParser.g"
1553	>	#line 242 "MDTreeParser.g"
1554		currRigidBodyStamp->setMembers(ivec);
1555	<	#line 1262 "MDTreeParser.cpp"
1555	>	#line 1556 "MDTreeParser.cpp"
1556		break;
1557		}
1558		default:
#	Line 1277 | Line 1571 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1571
1572		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1573		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1574	<	#line 222 "MDTreeParser.g"
1574	>	#line 255 "MDTreeParser.g"
1575
1576		vector<int> ivec;
1577		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1578
1579	<	#line 1286 "MDTreeParser.cpp"
1579	>	#line 1580 "MDTreeParser.cpp"
1580
1581		try {      // for error handling
1582		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1296 | Line 1590 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1590		}
1591		case MEMBERS:
1592		{
1593	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1594	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1593	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1594	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1595		match(_t,MEMBERS);
1596		_t = _t->getFirstChild();
1597		ivec=inttuple(_t);
1598		_t = _retTree;
1599	<	_t = __t63;
1599	>	_t = __t81;
1600		_t = _t->getNextSibling();
1601	<	#line 228 "MDTreeParser.g"
1601	>	#line 261 "MDTreeParser.g"
1602		currCutoffGroupStamp->setMembers(ivec);
1603	<	#line 1310 "MDTreeParser.cpp"
1603	>	#line 1604 "MDTreeParser.cpp"
1604		break;
1605		}
1606		default:
#	Line 1338 | Line 1632 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1632		_retTree = _t;
1633		}
1634
1341	–	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342	–	#line 268 "MDTreeParser.g"
1343	–	RealType dval;
1344	–	#line 1345 "MDTreeParser.cpp"
1345	–	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1346	–	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1347	–	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1348	–
1349	–	try {      // for error handling
1350	–	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1351	–	_t = ASTNULL;
1352	–	switch ( _t->getType()) {
1353	–	case NUM_INT:
1354	–	case NUM_LONG:
1355	–	{
1356	–	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357	–	intConst(_t);
1358	–	_t = _retTree;
1359	–	#line 270 "MDTreeParser.g"
1360	–	dval = lexi_cast<RealType>(ic->getText());
1361	–	#line 1362 "MDTreeParser.cpp"
1362	–	break;
1363	–	}
1364	–	case NUM_FLOAT:
1365	–	case NUM_DOUBLE:
1366	–	{
1367	–	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1368	–	floatConst(_t);
1369	–	_t = _retTree;
1370	–	#line 271 "MDTreeParser.g"
1371	–	dval = lexi_cast<RealType>(fc->getText());
1372	–	#line 1373 "MDTreeParser.cpp"
1373	–	break;
1374	–	}
1375	–	default:
1376	–	{
1377	–	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1378	–	}
1379	–	}
1380	–	}
1381	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1382	–	reportError(ex);
1383	–	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1384	–	_t = _t->getNextSibling();
1385	–	}
1386	–	_retTree = _t;
1387	–	return dval;
1388	–	}
1389	–
1635		void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1636		{
1637		}
#	Line 1398 | Line 1643 | const char* MDTreeParser::tokenNames[] = {
1643		"\"component\"",
1644		"\"molecule\"",
1645		"\"zconstraint\"",
1646	+	"\"restraint\"",
1647		"\"atom\"",
1648		"\"bond\"",
1649		"\"bend\"",
#	Line 1408 | Line 1654 | const char* MDTreeParser::tokenNames[] = {
1654		"\"fragment\"",
1655		"\"members\"",
1656		"\"center\"",
1657	+	"\"satellites\"",
1658		"\"position\"",
1659		"\"orientation\"",
1660	+	"\"flucQ\"",
1661	+	"\"RNEMD\"",
1662	+	"\"minimizer\"",
1663		"ENDBLOCK",
1664		"ID",
1665		"ASSIGNEQUAL",
#	Line 1447 | Line 1697 | const char* MDTreeParser::tokenNames[] = {
1697		0
1698		};
1699
1700	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1701	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1700	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 81789168UL, 0UL, 0UL, 0UL };
1701	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1702	>	// ASSIGNEQUAL
1703		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1704	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1704	>	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 67174144UL, 0UL, 0UL, 0UL };
1705		// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1706		// "fragment" ASSIGNEQUAL
1707		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Comparing trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords):
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

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

Diff Legend

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