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 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (file contents), Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.7 (20080702): "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 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		default:
96		{
97		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 121 | Line 139 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
139		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
140		match(_t,COMPONENT);
141		_t = _t->getFirstChild();
142	<	#line 62 "MDTreeParser.g"
142	>	#line 64 "MDTreeParser.g"
143		Component* currComponet = new Component(); blockStack.push(currComponet);
144	<	#line 127 "MDTreeParser.cpp"
144	>	#line 145 "MDTreeParser.cpp"
145		{ // ( ... )*
146		for (;;) {
147		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 144 | Line 162 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
162		_t = _t->getNextSibling();
163		_t = __t9;
164		_t = _t->getNextSibling();
165	<	#line 64 "MDTreeParser.g"
165	>	#line 66 "MDTreeParser.g"
166		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
167	<	#line 150 "MDTreeParser.cpp"
167	>	#line 168 "MDTreeParser.cpp"
168		}
169		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
170		reportError(ex);
#	Line 160 | Line 178 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
178		ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
179
180		try {      // for error handling
181	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
181	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
182		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
183		match(_t,MOLECULE);
184		_t = _t->getFirstChild();
185	<	#line 72 "MDTreeParser.g"
185	>	#line 90 "MDTreeParser.g"
186		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
187	<	#line 170 "MDTreeParser.cpp"
187	>	#line 188 "MDTreeParser.cpp"
188		{ // ( ... )*
189		for (;;) {
190		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 176 | Line 194 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
194		_t = _retTree;
195		}
196		else {
197	<	goto _loop19;
197	>	goto _loop31;
198		}
199
200		}
201	<	_loop19:;
201	>	_loop31:;
202		} // ( ... )*
203		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
204		match(_t,ENDBLOCK);
205		_t = _t->getNextSibling();
206	<	_t = __t17;
206	>	_t = __t29;
207		_t = _t->getNextSibling();
208	<	#line 74 "MDTreeParser.g"
208	>	#line 92 "MDTreeParser.g"
209		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
210	<	#line 193 "MDTreeParser.cpp"
210	>	#line 211 "MDTreeParser.cpp"
211		}
212		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
213		reportError(ex);
#	Line 207 | Line 225 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
225		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
226		match(_t,ZCONSTRAINT);
227		_t = _t->getFirstChild();
228	<	#line 67 "MDTreeParser.g"
228	>	#line 69 "MDTreeParser.g"
229		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
230	<	#line 213 "MDTreeParser.cpp"
230	>	#line 231 "MDTreeParser.cpp"
231		{ // ( ... )*
232		for (;;) {
233		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 230 | Line 248 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
248		_t = _t->getNextSibling();
249		_t = __t13;
250		_t = _t->getNextSibling();
251	<	#line 69 "MDTreeParser.g"
251	>	#line 71 "MDTreeParser.g"
252		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
253	<	#line 236 "MDTreeParser.cpp"
253	>	#line 254 "MDTreeParser.cpp"
254		}
255		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
256		reportError(ex);
#	Line 242 | Line 260 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
260		_retTree = _t;
261		}
262
263	+	void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
264	+	ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
265	+
266	+	try {      // for error handling
267	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
268	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
269	+	match(_t,RESTRAINT);
270	+	_t = _t->getFirstChild();
271	+	#line 74 "MDTreeParser.g"
272	+	RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
273	+	#line 274 "MDTreeParser.cpp"
274	+	{ // ( ... )*
275	+	for (;;) {
276	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
277	+	_t = ASTNULL;
278	+	if ((_t->getType() == ASSIGNEQUAL)) {
279	+	assignment(_t);
280	+	_t = _retTree;
281	+	}
282	+	else {
283	+	goto _loop19;
284	+	}
285	+
286	+	}
287	+	_loop19:;
288	+	} // ( ... )*
289	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
290	+	match(_t,ENDBLOCK);
291	+	_t = _t->getNextSibling();
292	+	_t = __t17;
293	+	_t = _t->getNextSibling();
294	+	#line 76 "MDTreeParser.g"
295	+	blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
296	+	#line 297 "MDTreeParser.cpp"
297	+	}
298	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
299	+	reportError(ex);
300	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
301	+	_t = _t->getNextSibling();
302	+	}
303	+	_retTree = _t;
304	+	}
305	+
306	+	void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
307	+	ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
308	+
309	+	try {      // for error handling
310	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
311	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
312	+	match(_t,FLUCQ);
313	+	_t = _t->getFirstChild();
314	+	#line 79 "MDTreeParser.g"
315	+	FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
316	+	#line 317 "MDTreeParser.cpp"
317	+	{ // ( ... )*
318	+	for (;;) {
319	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
320	+	_t = ASTNULL;
321	+	if ((_t->getType() == ASSIGNEQUAL)) {
322	+	assignment(_t);
323	+	_t = _retTree;
324	+	}
325	+	else {
326	+	goto _loop23;
327	+	}
328	+
329	+	}
330	+	_loop23:;
331	+	} // ( ... )*
332	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
333	+	match(_t,ENDBLOCK);
334	+	_t = _t->getNextSibling();
335	+	_t = __t21;
336	+	_t = _t->getNextSibling();
337	+	#line 81 "MDTreeParser.g"
338	+	blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
339	+	#line 340 "MDTreeParser.cpp"
340	+	}
341	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
342	+	reportError(ex);
343	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
344	+	_t = _t->getNextSibling();
345	+	}
346	+	_retTree = _t;
347	+	}
348	+
349	+	void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
350	+	ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
351	+
352	+	try {      // for error handling
353	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t25 = _t;
354	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
355	+	match(_t,RNEMD);
356	+	_t = _t->getFirstChild();
357	+	#line 84 "MDTreeParser.g"
358	+	RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
359	+	#line 360 "MDTreeParser.cpp"
360	+	{ // ( ... )*
361	+	for (;;) {
362	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
363	+	_t = ASTNULL;
364	+	if ((_t->getType() == ASSIGNEQUAL)) {
365	+	assignment(_t);
366	+	_t = _retTree;
367	+	}
368	+	else {
369	+	goto _loop27;
370	+	}
371	+
372	+	}
373	+	_loop27:;
374	+	} // ( ... )*
375	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
376	+	match(_t,ENDBLOCK);
377	+	_t = _t->getNextSibling();
378	+	_t = __t25;
379	+	_t = _t->getNextSibling();
380	+	#line 86 "MDTreeParser.g"
381	+	blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
382	+	#line 383 "MDTreeParser.cpp"
383	+	}
384	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
385	+	reportError(ex);
386	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
387	+	_t = _t->getNextSibling();
388	+	}
389	+	_retTree = _t;
390	+	}
391	+
392		void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
393		ANTLR_USE_NAMESPACE(antlr)RefAST id
394		) {
395		ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
396		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
397		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
398	<	#line 47 "MDTreeParser.g"
398	>	#line 49 "MDTreeParser.g"
399
400		int ival;
401		RealType dval;
402
403	<	#line 257 "MDTreeParser.cpp"
403	>	#line 404 "MDTreeParser.cpp"
404
405		try {      // for error handling
406		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 264 | Line 411 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
411		{
412		ival=intConst(_t);
413		_t = _retTree;
414	<	#line 52 "MDTreeParser.g"
414	>	#line 54 "MDTreeParser.g"
415		blockStack.top()->assign(id->getText(), ival);
416	<	#line 270 "MDTreeParser.cpp"
416	>	#line 417 "MDTreeParser.cpp"
417		break;
418		}
419		case NUM_FLOAT:
#	Line 274 | Line 421 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
421		{
422		dval=floatConst(_t);
423		_t = _retTree;
424	<	#line 53 "MDTreeParser.g"
424	>	#line 55 "MDTreeParser.g"
425		blockStack.top()->assign(id->getText(), dval);
426	<	#line 280 "MDTreeParser.cpp"
426	>	#line 427 "MDTreeParser.cpp"
427		break;
428		}
429		case ID:
#	Line 284 | Line 431 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
431		str1 = _t;
432		match(_t,ID);
433		_t = _t->getNextSibling();
434	<	#line 54 "MDTreeParser.g"
434	>	#line 56 "MDTreeParser.g"
435		blockStack.top()->assign(id->getText(), str1->getText());
436	<	#line 290 "MDTreeParser.cpp"
436	>	#line 437 "MDTreeParser.cpp"
437		break;
438		}
439		case StringLiteral:
#	Line 294 | Line 441 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
441		str2 = _t;
442		match(_t,StringLiteral);
443		_t = _t->getNextSibling();
444	<	#line 55 "MDTreeParser.g"
444	>	#line 57 "MDTreeParser.g"
445		std::string s =  str2->getText();
446		s = s.substr(1, s.length()-2);
447		blockStack.top()->assign(id->getText(),s);
448
449	<	#line 303 "MDTreeParser.cpp"
449	>	#line 450 "MDTreeParser.cpp"
450		break;
451		}
452		default:
#	Line 317 | Line 464 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
464		}
465
466		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
467	<	#line 262 "MDTreeParser.g"
467	>	#line 280 "MDTreeParser.g"
468		int ival;
469	<	#line 323 "MDTreeParser.cpp"
469	>	#line 470 "MDTreeParser.cpp"
470		ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
471		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
472		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 333 | Line 480 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
480		i1 = _t;
481		match(_t,NUM_INT);
482		_t = _t->getNextSibling();
483	<	#line 263 "MDTreeParser.g"
483	>	#line 281 "MDTreeParser.g"
484		ival = lexi_cast<int>(i1->getText());
485	<	#line 339 "MDTreeParser.cpp"
485	>	#line 486 "MDTreeParser.cpp"
486		break;
487		}
488		case NUM_LONG:
#	Line 343 | Line 490 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
490		i2 = _t;
491		match(_t,NUM_LONG);
492		_t = _t->getNextSibling();
493	<	#line 264 "MDTreeParser.g"
493	>	#line 282 "MDTreeParser.g"
494		ival = lexi_cast<int>(i2->getText());
495	<	#line 349 "MDTreeParser.cpp"
495	>	#line 496 "MDTreeParser.cpp"
496		break;
497		}
498		default:
#	Line 364 | Line 511 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
511		}
512
513		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
514	<	#line 276 "MDTreeParser.g"
514	>	#line 294 "MDTreeParser.g"
515		RealType dval;
516	<	#line 370 "MDTreeParser.cpp"
516	>	#line 517 "MDTreeParser.cpp"
517		ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
518		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
519		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 380 | Line 527 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
527		d1 = _t;
528		match(_t,NUM_FLOAT);
529		_t = _t->getNextSibling();
530	<	#line 277 "MDTreeParser.g"
530	>	#line 295 "MDTreeParser.g"
531		dval = lexi_cast<RealType>(d1->getText());
532	<	#line 386 "MDTreeParser.cpp"
532	>	#line 533 "MDTreeParser.cpp"
533		break;
534		}
535		case NUM_DOUBLE:
#	Line 390 | Line 537 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
537		d2 = _t;
538		match(_t,NUM_DOUBLE);
539		_t = _t->getNextSibling();
540	<	#line 278 "MDTreeParser.g"
540	>	#line 296 "MDTreeParser.g"
541		dval = lexi_cast<RealType>(d2->getText());
542	<	#line 396 "MDTreeParser.cpp"
542	>	#line 543 "MDTreeParser.cpp"
543		break;
544		}
545		default:
#	Line 487 | Line 634 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
634
635		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
636		ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
637	<	#line 88 "MDTreeParser.g"
637	>	#line 106 "MDTreeParser.g"
638
639		int index;
640
641	<	#line 495 "MDTreeParser.cpp"
641	>	#line 642 "MDTreeParser.cpp"
642
643		try {      // for error handling
644	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
645	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
644	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
645	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
646		match(_t,ATOM);
647		_t = _t->getFirstChild();
648		index=intConst(_t);
649		_t = _retTree;
650	<	#line 92 "MDTreeParser.g"
650	>	#line 110 "MDTreeParser.g"
651		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
652	<	#line 506 "MDTreeParser.cpp"
652	>	#line 653 "MDTreeParser.cpp"
653		{ // ( ... )*
654		for (;;) {
655		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 512 | Line 659 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
659		_t = _retTree;
660		}
661		else {
662	<	goto _loop24;
662	>	goto _loop36;
663		}
664
665		}
666	<	_loop24:;
666	>	_loop36:;
667		} // ( ... )*
668	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
668	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
669		match(_t,ENDBLOCK);
670		_t = _t->getNextSibling();
671	<	_t = __t22;
671	>	_t = __t34;
672		_t = _t->getNextSibling();
673	<	#line 94 "MDTreeParser.g"
673	>	#line 112 "MDTreeParser.g"
674
675		blockStack.top()->validate();
676		blockStack.pop();
677		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
678		currMoleculeStamp->addAtomStamp(currAtomStamp);
679
680	<	#line 534 "MDTreeParser.cpp"
680	>	#line 681 "MDTreeParser.cpp"
681		}
682		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683		reportError(ex);
#	Line 544 | Line 691 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
691		ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
692
693		try {      // for error handling
694	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
695	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
694	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
695	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
696		match(_t,BOND);
697		_t = _t->getFirstChild();
698	<	#line 114 "MDTreeParser.g"
698	>	#line 132 "MDTreeParser.g"
699		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
700	<	#line 554 "MDTreeParser.cpp"
700	>	#line 701 "MDTreeParser.cpp"
701		{ // ( ... )*
702		for (;;) {
703		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 560 | Line 707 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
707		_t = _retTree;
708		}
709		else {
710	<	goto _loop31;
710	>	goto _loop43;
711		}
712
713		}
714	<	_loop31:;
714	>	_loop43:;
715		} // ( ... )*
716	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
716	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
717		match(_t,ENDBLOCK);
718		_t = _t->getNextSibling();
719	<	_t = __t29;
719	>	_t = __t41;
720		_t = _t->getNextSibling();
721	<	#line 116 "MDTreeParser.g"
721	>	#line 134 "MDTreeParser.g"
722
723		blockStack.pop();
724		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
725		currMoleculeStamp->addBondStamp(currBondStamp);
726
727	<	#line 581 "MDTreeParser.cpp"
727	>	#line 728 "MDTreeParser.cpp"
728		}
729		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
730		reportError(ex);
#	Line 591 | Line 738 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
738		ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
739
740		try {      // for error handling
741	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
742	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
741	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
742	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
743		match(_t,BEND);
744		_t = _t->getFirstChild();
745	<	#line 132 "MDTreeParser.g"
745	>	#line 150 "MDTreeParser.g"
746		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
747	<	#line 601 "MDTreeParser.cpp"
747	>	#line 748 "MDTreeParser.cpp"
748		{ // ( ... )*
749		for (;;) {
750		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 607 | Line 754 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
754		_t = _retTree;
755		}
756		else {
757	<	goto _loop37;
757	>	goto _loop49;
758		}
759
760		}
761	<	_loop37:;
761	>	_loop49:;
762		} // ( ... )*
763	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
763	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
764		match(_t,ENDBLOCK);
765		_t = _t->getNextSibling();
766	<	_t = __t35;
766	>	_t = __t47;
767		_t = _t->getNextSibling();
768	<	#line 134 "MDTreeParser.g"
768	>	#line 152 "MDTreeParser.g"
769
770		blockStack.top()->validate();
771		blockStack.pop();
772		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
773		currMoleculeStamp->addBendStamp(currBendStamp);
774
775	<	#line 629 "MDTreeParser.cpp"
775	>	#line 776 "MDTreeParser.cpp"
776		}
777		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
778		reportError(ex);
#	Line 639 | Line 786 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
786		ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
787
788		try {      // for error handling
789	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
790	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
789	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
790	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
791		match(_t,TORSION);
792		_t = _t->getFirstChild();
793	<	#line 151 "MDTreeParser.g"
793	>	#line 169 "MDTreeParser.g"
794		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
795	<	#line 649 "MDTreeParser.cpp"
795	>	#line 796 "MDTreeParser.cpp"
796		{ // ( ... )*
797		for (;;) {
798		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 655 | Line 802 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
802		_t = _retTree;
803		}
804		else {
805	<	goto _loop43;
805	>	goto _loop55;
806		}
807
808		}
809	<	_loop43:;
809	>	_loop55:;
810		} // ( ... )*
811	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
811	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
812		match(_t,ENDBLOCK);
813		_t = _t->getNextSibling();
814	<	_t = __t41;
814	>	_t = __t53;
815		_t = _t->getNextSibling();
816	<	#line 153 "MDTreeParser.g"
816	>	#line 171 "MDTreeParser.g"
817
818		blockStack.top()->validate();
819		blockStack.pop();
820		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
821		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
822
823	<	#line 677 "MDTreeParser.cpp"
823	>	#line 824 "MDTreeParser.cpp"
824		}
825		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
826		reportError(ex);
#	Line 687 | Line 834 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
834		ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
835
836		try {      // for error handling
837	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
838	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
837	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
838	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
839		match(_t,INVERSION);
840		_t = _t->getFirstChild();
841	<	#line 170 "MDTreeParser.g"
841	>	#line 188 "MDTreeParser.g"
842		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
843	<	#line 697 "MDTreeParser.cpp"
843	>	#line 844 "MDTreeParser.cpp"
844		{ // ( ... )*
845		for (;;) {
846		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 703 | Line 850 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
850		_t = _retTree;
851		}
852		else {
853	<	goto _loop49;
853	>	goto _loop61;
854		}
855
856		}
857	<	_loop49:;
857	>	_loop61:;
858		} // ( ... )*
859	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
859	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
860		match(_t,ENDBLOCK);
861		_t = _t->getNextSibling();
862	<	_t = __t47;
862	>	_t = __t59;
863		_t = _t->getNextSibling();
864	<	#line 172 "MDTreeParser.g"
864	>	#line 190 "MDTreeParser.g"
865
866		blockStack.top()->validate();
867		blockStack.pop();
868		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
869		currMoleculeStamp->addInversionStamp(currInversionStamp);
870
871	<	#line 725 "MDTreeParser.cpp"
871	>	#line 872 "MDTreeParser.cpp"
872		}
873		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
874		reportError(ex);
#	Line 733 | Line 880 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
880
881		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
882		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
883	<	#line 189 "MDTreeParser.g"
883	>	#line 207 "MDTreeParser.g"
884
885		int index;
886
887	<	#line 741 "MDTreeParser.cpp"
887	>	#line 888 "MDTreeParser.cpp"
888
889		try {      // for error handling
890	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
891	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
890	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
891	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
892		match(_t,RIGIDBODY);
893		_t = _t->getFirstChild();
894		index=intConst(_t);
895		_t = _retTree;
896	<	#line 193 "MDTreeParser.g"
896	>	#line 211 "MDTreeParser.g"
897		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
898	<	#line 752 "MDTreeParser.cpp"
898	>	#line 899 "MDTreeParser.cpp"
899		{ // ( ... )*
900		for (;;) {
901		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 758 | Line 905 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
905		_t = _retTree;
906		}
907		else {
908	<	goto _loop55;
908	>	goto _loop67;
909		}
910
911		}
912	<	_loop55:;
912	>	_loop67:;
913		} // ( ... )*
914	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
914	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
915		match(_t,ENDBLOCK);
916		_t = _t->getNextSibling();
917	<	_t = __t53;
917	>	_t = __t65;
918		_t = _t->getNextSibling();
919	<	#line 195 "MDTreeParser.g"
919	>	#line 213 "MDTreeParser.g"
920
921		blockStack.top()->validate();
922		blockStack.pop();
923		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
924		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
925
926	<	#line 780 "MDTreeParser.cpp"
926	>	#line 927 "MDTreeParser.cpp"
927		}
928		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
929		reportError(ex);
#	Line 790 | Line 937 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
937		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
938
939		try {      // for error handling
940	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
941	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
940	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
941	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
942		match(_t,CUTOFFGROUP);
943		_t = _t->getFirstChild();
944	<	#line 212 "MDTreeParser.g"
944	>	#line 230 "MDTreeParser.g"
945		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
946	<	#line 800 "MDTreeParser.cpp"
946	>	#line 947 "MDTreeParser.cpp"
947		{ // ( ... )*
948		for (;;) {
949		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 806 | Line 953 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
953		_t = _retTree;
954		}
955		else {
956	<	goto _loop61;
956	>	goto _loop73;
957		}
958
959		}
960	<	_loop61:;
960	>	_loop73:;
961		} // ( ... )*
962	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
962	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
963		match(_t,ENDBLOCK);
964		_t = _t->getNextSibling();
965	<	_t = __t59;
965	>	_t = __t71;
966		_t = _t->getNextSibling();
967	<	#line 214 "MDTreeParser.g"
967	>	#line 232 "MDTreeParser.g"
968
969		blockStack.top()->validate();
970		blockStack.pop();
971		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
972		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
973
974	<	#line 828 "MDTreeParser.cpp"
974	>	#line 975 "MDTreeParser.cpp"
975		}
976		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
977		reportError(ex);
#	Line 836 | Line 983 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
983
984		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
985		ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
986	<	#line 231 "MDTreeParser.g"
986	>	#line 249 "MDTreeParser.g"
987		int ival;
988	<	#line 842 "MDTreeParser.cpp"
988	>	#line 989 "MDTreeParser.cpp"
989
990		try {      // for error handling
991	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
992	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
991	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
992	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
993		match(_t,FRAGMENT);
994		_t = _t->getFirstChild();
995		ival=intConst(_t);
996		_t = _retTree;
997	<	#line 232 "MDTreeParser.g"
997	>	#line 250 "MDTreeParser.g"
998		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
999	<	#line 853 "MDTreeParser.cpp"
999	>	#line 1000 "MDTreeParser.cpp"
1000		{ // ( ... )*
1001		for (;;) {
1002		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 859 | Line 1006 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1006		_t = _retTree;
1007		}
1008		else {
1009	<	goto _loop67;
1009	>	goto _loop79;
1010		}
1011
1012		}
1013	<	_loop67:;
1013	>	_loop79:;
1014		} // ( ... )*
1015	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1015	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1016		match(_t,ENDBLOCK);
1017		_t = _t->getNextSibling();
1018	<	_t = __t65;
1018	>	_t = __t77;
1019		_t = _t->getNextSibling();
1020	<	#line 234 "MDTreeParser.g"
1020	>	#line 252 "MDTreeParser.g"
1021
1022		blockStack.top()->validate();
1023		blockStack.pop();
1024		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1025		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1026
1027	<	#line 881 "MDTreeParser.cpp"
1027	>	#line 1028 "MDTreeParser.cpp"
1028		}
1029		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1030		reportError(ex);
#	Line 889 | Line 1036 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1036
1037		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1038		ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1039	<	#line 102 "MDTreeParser.g"
1039	>	#line 120 "MDTreeParser.g"
1040
1041		vector<RealType> dvec;
1042		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1043
1044
1045	<	#line 899 "MDTreeParser.cpp"
1045	>	#line 1046 "MDTreeParser.cpp"
1046
1047		try {      // for error handling
1048		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 909 | Line 1056 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1056		}
1057		case POSITION:
1058		{
1059	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
1060	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1059	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
1060	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1061		match(_t,POSITION);
1062		_t = _t->getFirstChild();
1063		dvec=doubleNumberTuple(_t);
1064		_t = _retTree;
1065	<	_t = __t26;
1065	>	_t = __t38;
1066		_t = _t->getNextSibling();
1067	<	#line 109 "MDTreeParser.g"
1067	>	#line 127 "MDTreeParser.g"
1068		currAtomStamp->setPosition(dvec);
1069	<	#line 923 "MDTreeParser.cpp"
1069	>	#line 1070 "MDTreeParser.cpp"
1070		break;
1071		}
1072		case ORIENTATION:
1073		{
1074	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
1075	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1074	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1075	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1076		match(_t,ORIENTATION);
1077		_t = _t->getFirstChild();
1078		dvec=doubleNumberTuple(_t);
1079		_t = _retTree;
1080	<	_t = __t27;
1080	>	_t = __t39;
1081		_t = _t->getNextSibling();
1082	<	#line 110 "MDTreeParser.g"
1082	>	#line 128 "MDTreeParser.g"
1083		currAtomStamp->setOrientation(dvec);
1084	<	#line 938 "MDTreeParser.cpp"
1084	>	#line 1085 "MDTreeParser.cpp"
1085		break;
1086		}
1087		default:
#	Line 952 | Line 1099 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1099		}
1100
1101		vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1102	<	#line 247 "MDTreeParser.g"
1102	>	#line 265 "MDTreeParser.g"
1103		vector<RealType> dvec;
1104	<	#line 958 "MDTreeParser.cpp"
1104	>	#line 1105 "MDTreeParser.cpp"
1105		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1106	<	#line 247 "MDTreeParser.g"
1106	>	#line 265 "MDTreeParser.g"
1107
1108		RealType dval;
1109
1110	<	#line 964 "MDTreeParser.cpp"
1110	>	#line 1111 "MDTreeParser.cpp"
1111
1112		try {      // for error handling
1113		{ // ( ... )+
1114	<	int _cnt71=0;
1114	>	int _cnt83=0;
1115		for (;;) {
1116		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1117		_t = ASTNULL;
1118		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1119		dval=doubleNumber(_t);
1120		_t = _retTree;
1121	<	#line 251 "MDTreeParser.g"
1121	>	#line 269 "MDTreeParser.g"
1122		dvec.push_back(dval);
1123	<	#line 977 "MDTreeParser.cpp"
1123	>	#line 1124 "MDTreeParser.cpp"
1124		}
1125		else {
1126	<	if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1126	>	if ( _cnt83>=1 ) { goto _loop83; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1127		}
1128
1129	<	_cnt71++;
1129	>	_cnt83++;
1130		}
1131	<	_loop71:;
1131	>	_loop83:;
1132		}  // ( ... )+
1133		}
1134		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 995 | Line 1142 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1142
1143		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1144		ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1145	<	#line 123 "MDTreeParser.g"
1145	>	#line 141 "MDTreeParser.g"
1146
1147		vector<int> ivec;
1148		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1149
1150	<	#line 1004 "MDTreeParser.cpp"
1150	>	#line 1151 "MDTreeParser.cpp"
1151
1152		try {      // for error handling
1153		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1014 | Line 1161 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1161		}
1162		case MEMBERS:
1163		{
1164	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1165	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1164	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1165	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1166		match(_t,MEMBERS);
1167		_t = _t->getFirstChild();
1168		ivec=inttuple(_t);
1169		_t = _retTree;
1170	<	_t = __t33;
1170	>	_t = __t45;
1171		_t = _t->getNextSibling();
1172	<	#line 129 "MDTreeParser.g"
1172	>	#line 147 "MDTreeParser.g"
1173		currBondStamp->setMembers(ivec);
1174	<	#line 1028 "MDTreeParser.cpp"
1174	>	#line 1175 "MDTreeParser.cpp"
1175		break;
1176		}
1177		default:
#	Line 1042 | Line 1189 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1189		}
1190
1191		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1192	<	#line 254 "MDTreeParser.g"
1192	>	#line 272 "MDTreeParser.g"
1193		vector<int> ivec;
1194	<	#line 1048 "MDTreeParser.cpp"
1194	>	#line 1195 "MDTreeParser.cpp"
1195		ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1196	<	#line 254 "MDTreeParser.g"
1196	>	#line 272 "MDTreeParser.g"
1197
1198		int ival;
1199
1200	<	#line 1054 "MDTreeParser.cpp"
1200	>	#line 1201 "MDTreeParser.cpp"
1201
1202		try {      // for error handling
1203		{ // ( ... )+
1204	<	int _cnt74=0;
1204	>	int _cnt86=0;
1205		for (;;) {
1206		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1207		_t = ASTNULL;
1208		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1209		ival=intConst(_t);
1210		_t = _retTree;
1211	<	#line 258 "MDTreeParser.g"
1211	>	#line 276 "MDTreeParser.g"
1212		ivec.push_back(ival);
1213	<	#line 1067 "MDTreeParser.cpp"
1213	>	#line 1214 "MDTreeParser.cpp"
1214		}
1215		else {
1216	<	if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1216	>	if ( _cnt86>=1 ) { goto _loop86; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1217		}
1218
1219	<	_cnt74++;
1219	>	_cnt86++;
1220		}
1221	<	_loop74:;
1221	>	_loop86:;
1222		}  // ( ... )+
1223		}
1224		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1085 | Line 1232 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1232
1233		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1234		ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1235	<	#line 142 "MDTreeParser.g"
1235	>	#line 160 "MDTreeParser.g"
1236
1237		vector<int> ivec;
1238		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1239
1240	<	#line 1094 "MDTreeParser.cpp"
1240	>	#line 1241 "MDTreeParser.cpp"
1241
1242		try {      // for error handling
1243		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1104 | Line 1251 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1251		}
1252		case MEMBERS:
1253		{
1254	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1255	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1254	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1255	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1256		match(_t,MEMBERS);
1257		_t = _t->getFirstChild();
1258		ivec=inttuple(_t);
1259		_t = _retTree;
1260	<	_t = __t39;
1260	>	_t = __t51;
1261		_t = _t->getNextSibling();
1262	<	#line 148 "MDTreeParser.g"
1262	>	#line 166 "MDTreeParser.g"
1263		currBendStamp->setMembers(ivec);
1264	<	#line 1118 "MDTreeParser.cpp"
1264	>	#line 1265 "MDTreeParser.cpp"
1265		break;
1266		}
1267		default:
#	Line 1133 | Line 1280 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1280
1281		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1282		ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1283	<	#line 161 "MDTreeParser.g"
1283	>	#line 179 "MDTreeParser.g"
1284
1285		vector<int> ivec;
1286		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1287
1288	<	#line 1142 "MDTreeParser.cpp"
1288	>	#line 1289 "MDTreeParser.cpp"
1289
1290		try {      // for error handling
1291		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1152 | Line 1299 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1299		}
1300		case MEMBERS:
1301		{
1302	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1303	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1302	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1303	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1304		match(_t,MEMBERS);
1305		_t = _t->getFirstChild();
1306		ivec=inttuple(_t);
1307		_t = _retTree;
1308	<	_t = __t45;
1308	>	_t = __t57;
1309		_t = _t->getNextSibling();
1310	<	#line 167 "MDTreeParser.g"
1310	>	#line 185 "MDTreeParser.g"
1311		currTorsionStamp->setMembers(ivec);
1312	<	#line 1166 "MDTreeParser.cpp"
1312	>	#line 1313 "MDTreeParser.cpp"
1313		break;
1314		}
1315		default:
#	Line 1181 | Line 1328 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1328
1329		void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1330		ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1331	<	#line 180 "MDTreeParser.g"
1331	>	#line 198 "MDTreeParser.g"
1332
1333		int icent;
1334		InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1335
1336	<	#line 1190 "MDTreeParser.cpp"
1336	>	#line 1337 "MDTreeParser.cpp"
1337
1338		try {      // for error handling
1339		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1200 | Line 1347 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1347		}
1348		case CENTER:
1349		{
1350	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1351	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1350	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1351	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1352		match(_t,CENTER);
1353		_t = _t->getFirstChild();
1354		icent=intConst(_t);
1355		_t = _retTree;
1356	<	_t = __t51;
1356	>	_t = __t63;
1357		_t = _t->getNextSibling();
1358	<	#line 186 "MDTreeParser.g"
1358	>	#line 204 "MDTreeParser.g"
1359		currInversionStamp->setCenter(icent);
1360	<	#line 1214 "MDTreeParser.cpp"
1360	>	#line 1361 "MDTreeParser.cpp"
1361		break;
1362		}
1363		default:
#	Line 1229 | Line 1376 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1376
1377		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1378		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1379	<	#line 203 "MDTreeParser.g"
1379	>	#line 221 "MDTreeParser.g"
1380
1381		vector<int> ivec;
1382		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1383
1384	<	#line 1238 "MDTreeParser.cpp"
1384	>	#line 1385 "MDTreeParser.cpp"
1385
1386		try {      // for error handling
1387		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1248 | Line 1395 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1395		}
1396		case MEMBERS:
1397		{
1398	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1399	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1398	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1399	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1400		match(_t,MEMBERS);
1401		_t = _t->getFirstChild();
1402		ivec=inttuple(_t);
1403		_t = _retTree;
1404	<	_t = __t57;
1404	>	_t = __t69;
1405		_t = _t->getNextSibling();
1406	<	#line 209 "MDTreeParser.g"
1406	>	#line 227 "MDTreeParser.g"
1407		currRigidBodyStamp->setMembers(ivec);
1408	<	#line 1262 "MDTreeParser.cpp"
1408	>	#line 1409 "MDTreeParser.cpp"
1409		break;
1410		}
1411		default:
#	Line 1277 | Line 1424 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1424
1425		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1426		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1427	<	#line 222 "MDTreeParser.g"
1427	>	#line 240 "MDTreeParser.g"
1428
1429		vector<int> ivec;
1430		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1431
1432	<	#line 1286 "MDTreeParser.cpp"
1432	>	#line 1433 "MDTreeParser.cpp"
1433
1434		try {      // for error handling
1435		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1296 | Line 1443 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1443		}
1444		case MEMBERS:
1445		{
1446	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1447	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1446	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1447	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1448		match(_t,MEMBERS);
1449		_t = _t->getFirstChild();
1450		ivec=inttuple(_t);
1451		_t = _retTree;
1452	<	_t = __t63;
1452	>	_t = __t75;
1453		_t = _t->getNextSibling();
1454	<	#line 228 "MDTreeParser.g"
1454	>	#line 246 "MDTreeParser.g"
1455		currCutoffGroupStamp->setMembers(ivec);
1456	<	#line 1310 "MDTreeParser.cpp"
1456	>	#line 1457 "MDTreeParser.cpp"
1457		break;
1458		}
1459		default:
#	Line 1339 | Line 1486 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1486		}
1487
1488		RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1489	<	#line 268 "MDTreeParser.g"
1489	>	#line 286 "MDTreeParser.g"
1490		RealType dval;
1491	<	#line 1345 "MDTreeParser.cpp"
1491	>	#line 1492 "MDTreeParser.cpp"
1492		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1493		ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1494		ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 1356 | Line 1503 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1503		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1504		intConst(_t);
1505		_t = _retTree;
1506	<	#line 270 "MDTreeParser.g"
1506	>	#line 288 "MDTreeParser.g"
1507		dval = lexi_cast<RealType>(ic->getText());
1508	<	#line 1362 "MDTreeParser.cpp"
1508	>	#line 1509 "MDTreeParser.cpp"
1509		break;
1510		}
1511		case NUM_FLOAT:
#	Line 1367 | Line 1514 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1514		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515		floatConst(_t);
1516		_t = _retTree;
1517	<	#line 271 "MDTreeParser.g"
1517	>	#line 289 "MDTreeParser.g"
1518		dval = lexi_cast<RealType>(fc->getText());
1519	<	#line 1373 "MDTreeParser.cpp"
1519	>	#line 1520 "MDTreeParser.cpp"
1520		break;
1521		}
1522		default:
#	Line 1398 | Line 1545 | const char* MDTreeParser::tokenNames[] = {
1545		"\"component\"",
1546		"\"molecule\"",
1547		"\"zconstraint\"",
1548	+	"\"restraint\"",
1549		"\"atom\"",
1550		"\"bond\"",
1551		"\"bend\"",
#	Line 1410 | Line 1558 | const char* MDTreeParser::tokenNames[] = {
1558		"\"center\"",
1559		"\"position\"",
1560		"\"orientation\"",
1561	+	"\"flucQ\"",
1562	+	"\"RNEMD\"",
1563		"ENDBLOCK",
1564		"ID",
1565		"ASSIGNEQUAL",
#	Line 1447 | Line 1597 | const char* MDTreeParser::tokenNames[] = {
1597		0
1598		};
1599
1600	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1601	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1600	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 19923184UL, 0UL, 0UL, 0UL };
1601	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ASSIGNEQUAL
1602		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1603	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1603	>	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1604		// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1605		// "fragment" ASSIGNEQUAL
1606		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.
branches/development/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

Diff Legend

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