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 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.7 (20080702): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20090623): "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		default:
84		{
85		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 121 | Line 127 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
127		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
128		match(_t,COMPONENT);
129		_t = _t->getFirstChild();
130	<	#line 62 "MDTreeParser.g"
130	>	#line 63 "MDTreeParser.g"
131		Component* currComponet = new Component(); blockStack.push(currComponet);
132	<	#line 127 "MDTreeParser.cpp"
132	>	#line 133 "MDTreeParser.cpp"
133		{ // ( ... )*
134		for (;;) {
135		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 144 | Line 150 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
150		_t = _t->getNextSibling();
151		_t = __t9;
152		_t = _t->getNextSibling();
153	<	#line 64 "MDTreeParser.g"
153	>	#line 65 "MDTreeParser.g"
154		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
155	<	#line 150 "MDTreeParser.cpp"
155	>	#line 156 "MDTreeParser.cpp"
156		}
157		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
158		reportError(ex);
#	Line 160 | Line 166 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
166		ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
167
168		try {      // for error handling
169	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
169	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
170		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
171		match(_t,MOLECULE);
172		_t = _t->getFirstChild();
173	<	#line 72 "MDTreeParser.g"
173	>	#line 78 "MDTreeParser.g"
174		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
175	<	#line 170 "MDTreeParser.cpp"
175	>	#line 176 "MDTreeParser.cpp"
176		{ // ( ... )*
177		for (;;) {
178		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 176 | Line 182 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
182		_t = _retTree;
183		}
184		else {
185	<	goto _loop19;
185	>	goto _loop23;
186		}
187
188		}
189	<	_loop19:;
189	>	_loop23:;
190		} // ( ... )*
191		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
192		match(_t,ENDBLOCK);
193		_t = _t->getNextSibling();
194	<	_t = __t17;
194	>	_t = __t21;
195		_t = _t->getNextSibling();
196	<	#line 74 "MDTreeParser.g"
196	>	#line 80 "MDTreeParser.g"
197		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
198	<	#line 193 "MDTreeParser.cpp"
198	>	#line 199 "MDTreeParser.cpp"
199		}
200		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
201		reportError(ex);
#	Line 207 | Line 213 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
213		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
214		match(_t,ZCONSTRAINT);
215		_t = _t->getFirstChild();
216	<	#line 67 "MDTreeParser.g"
216	>	#line 68 "MDTreeParser.g"
217		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
218	<	#line 213 "MDTreeParser.cpp"
218	>	#line 219 "MDTreeParser.cpp"
219		{ // ( ... )*
220		for (;;) {
221		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 230 | Line 236 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
236		_t = _t->getNextSibling();
237		_t = __t13;
238		_t = _t->getNextSibling();
239	<	#line 69 "MDTreeParser.g"
239	>	#line 70 "MDTreeParser.g"
240		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
241	<	#line 236 "MDTreeParser.cpp"
241	>	#line 242 "MDTreeParser.cpp"
242		}
243		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
244		reportError(ex);
#	Line 242 | Line 248 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
248		_retTree = _t;
249		}
250
251	+	void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
252	+	ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
253	+
254	+	try {      // for error handling
255	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
256	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
257	+	match(_t,RESTRAINT);
258	+	_t = _t->getFirstChild();
259	+	#line 73 "MDTreeParser.g"
260	+	RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
261	+	#line 262 "MDTreeParser.cpp"
262	+	{ // ( ... )*
263	+	for (;;) {
264	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
265	+	_t = ASTNULL;
266	+	if ((_t->getType() == ASSIGNEQUAL)) {
267	+	assignment(_t);
268	+	_t = _retTree;
269	+	}
270	+	else {
271	+	goto _loop19;
272	+	}
273	+
274	+	}
275	+	_loop19:;
276	+	} // ( ... )*
277	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
278	+	match(_t,ENDBLOCK);
279	+	_t = _t->getNextSibling();
280	+	_t = __t17;
281	+	_t = _t->getNextSibling();
282	+	#line 75 "MDTreeParser.g"
283	+	blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
284	+	#line 285 "MDTreeParser.cpp"
285	+	}
286	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
287	+	reportError(ex);
288	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
289	+	_t = _t->getNextSibling();
290	+	}
291	+	_retTree = _t;
292	+	}
293	+
294		void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
295		ANTLR_USE_NAMESPACE(antlr)RefAST id
296		) {
297		ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
298		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
299		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
300	<	#line 47 "MDTreeParser.g"
300	>	#line 48 "MDTreeParser.g"
301
302		int ival;
303		RealType dval;
304
305	<	#line 257 "MDTreeParser.cpp"
305	>	#line 306 "MDTreeParser.cpp"
306
307		try {      // for error handling
308		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 264 | Line 313 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
313		{
314		ival=intConst(_t);
315		_t = _retTree;
316	<	#line 52 "MDTreeParser.g"
316	>	#line 53 "MDTreeParser.g"
317		blockStack.top()->assign(id->getText(), ival);
318	<	#line 270 "MDTreeParser.cpp"
318	>	#line 319 "MDTreeParser.cpp"
319		break;
320		}
321		case NUM_FLOAT:
#	Line 274 | Line 323 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
323		{
324		dval=floatConst(_t);
325		_t = _retTree;
326	<	#line 53 "MDTreeParser.g"
326	>	#line 54 "MDTreeParser.g"
327		blockStack.top()->assign(id->getText(), dval);
328	<	#line 280 "MDTreeParser.cpp"
328	>	#line 329 "MDTreeParser.cpp"
329		break;
330		}
331		case ID:
#	Line 284 | Line 333 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
333		str1 = _t;
334		match(_t,ID);
335		_t = _t->getNextSibling();
336	<	#line 54 "MDTreeParser.g"
336	>	#line 55 "MDTreeParser.g"
337		blockStack.top()->assign(id->getText(), str1->getText());
338	<	#line 290 "MDTreeParser.cpp"
338	>	#line 339 "MDTreeParser.cpp"
339		break;
340		}
341		case StringLiteral:
#	Line 294 | Line 343 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
343		str2 = _t;
344		match(_t,StringLiteral);
345		_t = _t->getNextSibling();
346	<	#line 55 "MDTreeParser.g"
346	>	#line 56 "MDTreeParser.g"
347		std::string s =  str2->getText();
348		s = s.substr(1, s.length()-2);
349		blockStack.top()->assign(id->getText(),s);
350
351	<	#line 303 "MDTreeParser.cpp"
351	>	#line 352 "MDTreeParser.cpp"
352		break;
353		}
354		default:
#	Line 317 | Line 366 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
366		}
367
368		int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
369	<	#line 262 "MDTreeParser.g"
369	>	#line 268 "MDTreeParser.g"
370		int ival;
371	<	#line 323 "MDTreeParser.cpp"
371	>	#line 372 "MDTreeParser.cpp"
372		ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
373		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
374		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 333 | Line 382 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
382		i1 = _t;
383		match(_t,NUM_INT);
384		_t = _t->getNextSibling();
385	<	#line 263 "MDTreeParser.g"
385	>	#line 269 "MDTreeParser.g"
386		ival = lexi_cast<int>(i1->getText());
387	<	#line 339 "MDTreeParser.cpp"
387	>	#line 388 "MDTreeParser.cpp"
388		break;
389		}
390		case NUM_LONG:
#	Line 343 | Line 392 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
392		i2 = _t;
393		match(_t,NUM_LONG);
394		_t = _t->getNextSibling();
395	<	#line 264 "MDTreeParser.g"
395	>	#line 270 "MDTreeParser.g"
396		ival = lexi_cast<int>(i2->getText());
397	<	#line 349 "MDTreeParser.cpp"
397	>	#line 398 "MDTreeParser.cpp"
398		break;
399		}
400		default:
#	Line 364 | Line 413 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
413		}
414
415		RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416	<	#line 276 "MDTreeParser.g"
416	>	#line 282 "MDTreeParser.g"
417		RealType dval;
418	<	#line 370 "MDTreeParser.cpp"
418	>	#line 419 "MDTreeParser.cpp"
419		ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
420		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
421		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 380 | Line 429 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
429		d1 = _t;
430		match(_t,NUM_FLOAT);
431		_t = _t->getNextSibling();
432	<	#line 277 "MDTreeParser.g"
432	>	#line 283 "MDTreeParser.g"
433		dval = lexi_cast<RealType>(d1->getText());
434	<	#line 386 "MDTreeParser.cpp"
434	>	#line 435 "MDTreeParser.cpp"
435		break;
436		}
437		case NUM_DOUBLE:
#	Line 390 | Line 439 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
439		d2 = _t;
440		match(_t,NUM_DOUBLE);
441		_t = _t->getNextSibling();
442	<	#line 278 "MDTreeParser.g"
442	>	#line 284 "MDTreeParser.g"
443		dval = lexi_cast<RealType>(d2->getText());
444	<	#line 396 "MDTreeParser.cpp"
444	>	#line 445 "MDTreeParser.cpp"
445		break;
446		}
447		default:
#	Line 487 | Line 536 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
536
537		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
538		ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539	<	#line 88 "MDTreeParser.g"
539	>	#line 94 "MDTreeParser.g"
540
541		int index;
542
543	<	#line 495 "MDTreeParser.cpp"
543	>	#line 544 "MDTreeParser.cpp"
544
545		try {      // for error handling
546	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
547	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
546	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
547	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
548		match(_t,ATOM);
549		_t = _t->getFirstChild();
550		index=intConst(_t);
551		_t = _retTree;
552	<	#line 92 "MDTreeParser.g"
552	>	#line 98 "MDTreeParser.g"
553		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554	<	#line 506 "MDTreeParser.cpp"
554	>	#line 555 "MDTreeParser.cpp"
555		{ // ( ... )*
556		for (;;) {
557		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 512 | Line 561 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
561		_t = _retTree;
562		}
563		else {
564	<	goto _loop24;
564	>	goto _loop28;
565		}
566
567		}
568	<	_loop24:;
568	>	_loop28:;
569		} // ( ... )*
570	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
570	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
571		match(_t,ENDBLOCK);
572		_t = _t->getNextSibling();
573	<	_t = __t22;
573	>	_t = __t26;
574		_t = _t->getNextSibling();
575	<	#line 94 "MDTreeParser.g"
575	>	#line 100 "MDTreeParser.g"
576
577		blockStack.top()->validate();
578		blockStack.pop();
579		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
580		currMoleculeStamp->addAtomStamp(currAtomStamp);
581
582	<	#line 534 "MDTreeParser.cpp"
582	>	#line 583 "MDTreeParser.cpp"
583		}
584		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
585		reportError(ex);
#	Line 544 | Line 593 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
593		ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
594
595		try {      // for error handling
596	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
597	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
596	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
597	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
598		match(_t,BOND);
599		_t = _t->getFirstChild();
600	<	#line 114 "MDTreeParser.g"
600	>	#line 120 "MDTreeParser.g"
601		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602	<	#line 554 "MDTreeParser.cpp"
602	>	#line 603 "MDTreeParser.cpp"
603		{ // ( ... )*
604		for (;;) {
605		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 560 | Line 609 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
609		_t = _retTree;
610		}
611		else {
612	<	goto _loop31;
612	>	goto _loop35;
613		}
614
615		}
616	<	_loop31:;
616	>	_loop35:;
617		} // ( ... )*
618	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
618	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
619		match(_t,ENDBLOCK);
620		_t = _t->getNextSibling();
621	<	_t = __t29;
621	>	_t = __t33;
622		_t = _t->getNextSibling();
623	<	#line 116 "MDTreeParser.g"
623	>	#line 122 "MDTreeParser.g"
624
625		blockStack.pop();
626		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
627		currMoleculeStamp->addBondStamp(currBondStamp);
628
629	<	#line 581 "MDTreeParser.cpp"
629	>	#line 630 "MDTreeParser.cpp"
630		}
631		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
632		reportError(ex);
#	Line 591 | Line 640 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
640		ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
641
642		try {      // for error handling
643	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
644	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
643	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
644	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
645		match(_t,BEND);
646		_t = _t->getFirstChild();
647	<	#line 132 "MDTreeParser.g"
647	>	#line 138 "MDTreeParser.g"
648		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649	<	#line 601 "MDTreeParser.cpp"
649	>	#line 650 "MDTreeParser.cpp"
650		{ // ( ... )*
651		for (;;) {
652		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 607 | Line 656 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
656		_t = _retTree;
657		}
658		else {
659	<	goto _loop37;
659	>	goto _loop41;
660		}
661
662		}
663	<	_loop37:;
663	>	_loop41:;
664		} // ( ... )*
665	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
665	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
666		match(_t,ENDBLOCK);
667		_t = _t->getNextSibling();
668	<	_t = __t35;
668	>	_t = __t39;
669		_t = _t->getNextSibling();
670	<	#line 134 "MDTreeParser.g"
670	>	#line 140 "MDTreeParser.g"
671
672		blockStack.top()->validate();
673		blockStack.pop();
674		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
675		currMoleculeStamp->addBendStamp(currBendStamp);
676
677	<	#line 629 "MDTreeParser.cpp"
677	>	#line 678 "MDTreeParser.cpp"
678		}
679		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
680		reportError(ex);
#	Line 639 | Line 688 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
688		ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
689
690		try {      // for error handling
691	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
692	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
691	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
692	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
693		match(_t,TORSION);
694		_t = _t->getFirstChild();
695	<	#line 151 "MDTreeParser.g"
695	>	#line 157 "MDTreeParser.g"
696		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697	<	#line 649 "MDTreeParser.cpp"
697	>	#line 698 "MDTreeParser.cpp"
698		{ // ( ... )*
699		for (;;) {
700		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 655 | Line 704 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
704		_t = _retTree;
705		}
706		else {
707	<	goto _loop43;
707	>	goto _loop47;
708		}
709
710		}
711	<	_loop43:;
711	>	_loop47:;
712		} // ( ... )*
713	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
713	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714		match(_t,ENDBLOCK);
715		_t = _t->getNextSibling();
716	<	_t = __t41;
716	>	_t = __t45;
717		_t = _t->getNextSibling();
718	<	#line 153 "MDTreeParser.g"
718	>	#line 159 "MDTreeParser.g"
719
720		blockStack.top()->validate();
721		blockStack.pop();
722		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
724
725	<	#line 677 "MDTreeParser.cpp"
725	>	#line 726 "MDTreeParser.cpp"
726		}
727		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728		reportError(ex);
#	Line 687 | Line 736 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
736		ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
737
738		try {      // for error handling
739	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
740	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
739	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
740	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741		match(_t,INVERSION);
742		_t = _t->getFirstChild();
743	<	#line 170 "MDTreeParser.g"
743	>	#line 176 "MDTreeParser.g"
744		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
745	<	#line 697 "MDTreeParser.cpp"
745	>	#line 746 "MDTreeParser.cpp"
746		{ // ( ... )*
747		for (;;) {
748		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 703 | Line 752 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
752		_t = _retTree;
753		}
754		else {
755	<	goto _loop49;
755	>	goto _loop53;
756		}
757
758		}
759	<	_loop49:;
759	>	_loop53:;
760		} // ( ... )*
761	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
761	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
762		match(_t,ENDBLOCK);
763		_t = _t->getNextSibling();
764	<	_t = __t47;
764	>	_t = __t51;
765		_t = _t->getNextSibling();
766	<	#line 172 "MDTreeParser.g"
766	>	#line 178 "MDTreeParser.g"
767
768		blockStack.top()->validate();
769		blockStack.pop();
770		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771		currMoleculeStamp->addInversionStamp(currInversionStamp);
772
773	<	#line 725 "MDTreeParser.cpp"
773	>	#line 774 "MDTreeParser.cpp"
774		}
775		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776		reportError(ex);
#	Line 733 | Line 782 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
782
783		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785	<	#line 189 "MDTreeParser.g"
785	>	#line 195 "MDTreeParser.g"
786
787		int index;
788
789	<	#line 741 "MDTreeParser.cpp"
789	>	#line 790 "MDTreeParser.cpp"
790
791		try {      // for error handling
792	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
793	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
792	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
793	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
794		match(_t,RIGIDBODY);
795		_t = _t->getFirstChild();
796		index=intConst(_t);
797		_t = _retTree;
798	<	#line 193 "MDTreeParser.g"
798	>	#line 199 "MDTreeParser.g"
799		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800	<	#line 752 "MDTreeParser.cpp"
800	>	#line 801 "MDTreeParser.cpp"
801		{ // ( ... )*
802		for (;;) {
803		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 758 | Line 807 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
807		_t = _retTree;
808		}
809		else {
810	<	goto _loop55;
810	>	goto _loop59;
811		}
812
813		}
814	<	_loop55:;
814	>	_loop59:;
815		} // ( ... )*
816	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
816	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817		match(_t,ENDBLOCK);
818		_t = _t->getNextSibling();
819	<	_t = __t53;
819	>	_t = __t57;
820		_t = _t->getNextSibling();
821	<	#line 195 "MDTreeParser.g"
821	>	#line 201 "MDTreeParser.g"
822
823		blockStack.top()->validate();
824		blockStack.pop();
825		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
826		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
827
828	<	#line 780 "MDTreeParser.cpp"
828	>	#line 829 "MDTreeParser.cpp"
829		}
830		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
831		reportError(ex);
#	Line 790 | Line 839 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
839		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
840
841		try {      // for error handling
842	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
843	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
842	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
843	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
844		match(_t,CUTOFFGROUP);
845		_t = _t->getFirstChild();
846	<	#line 212 "MDTreeParser.g"
846	>	#line 218 "MDTreeParser.g"
847		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848	<	#line 800 "MDTreeParser.cpp"
848	>	#line 849 "MDTreeParser.cpp"
849		{ // ( ... )*
850		for (;;) {
851		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 806 | Line 855 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
855		_t = _retTree;
856		}
857		else {
858	<	goto _loop61;
858	>	goto _loop65;
859		}
860
861		}
862	<	_loop61:;
862	>	_loop65:;
863		} // ( ... )*
864	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
864	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865		match(_t,ENDBLOCK);
866		_t = _t->getNextSibling();
867	<	_t = __t59;
867	>	_t = __t63;
868		_t = _t->getNextSibling();
869	<	#line 214 "MDTreeParser.g"
869	>	#line 220 "MDTreeParser.g"
870
871		blockStack.top()->validate();
872		blockStack.pop();
873		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
874		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
875
876	<	#line 828 "MDTreeParser.cpp"
876	>	#line 877 "MDTreeParser.cpp"
877		}
878		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
879		reportError(ex);
#	Line 836 | Line 885 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
885
886		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
887		ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888	<	#line 231 "MDTreeParser.g"
888	>	#line 237 "MDTreeParser.g"
889		int ival;
890	<	#line 842 "MDTreeParser.cpp"
890	>	#line 891 "MDTreeParser.cpp"
891
892		try {      // for error handling
893	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
893	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
894	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
895		match(_t,FRAGMENT);
896		_t = _t->getFirstChild();
897		ival=intConst(_t);
898		_t = _retTree;
899	<	#line 232 "MDTreeParser.g"
899	>	#line 238 "MDTreeParser.g"
900		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901	<	#line 853 "MDTreeParser.cpp"
901	>	#line 902 "MDTreeParser.cpp"
902		{ // ( ... )*
903		for (;;) {
904		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 859 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
908		_t = _retTree;
909		}
910		else {
911	<	goto _loop67;
911	>	goto _loop71;
912		}
913
914		}
915	<	_loop67:;
915	>	_loop71:;
916		} // ( ... )*
917	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
917	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918		match(_t,ENDBLOCK);
919		_t = _t->getNextSibling();
920	<	_t = __t65;
920	>	_t = __t69;
921		_t = _t->getNextSibling();
922	<	#line 234 "MDTreeParser.g"
922	>	#line 240 "MDTreeParser.g"
923
924		blockStack.top()->validate();
925		blockStack.pop();
926		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
927		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
928
929	<	#line 881 "MDTreeParser.cpp"
929	>	#line 930 "MDTreeParser.cpp"
930		}
931		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
932		reportError(ex);
#	Line 889 | Line 938 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
938
939		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
940		ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941	<	#line 102 "MDTreeParser.g"
941	>	#line 108 "MDTreeParser.g"
942
943		vector<RealType> dvec;
944		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
945
946
947	<	#line 899 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948
949		try {      // for error handling
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 909 | Line 958 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
958		}
959		case POSITION:
960		{
961	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
962	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
961	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
962	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
963		match(_t,POSITION);
964		_t = _t->getFirstChild();
965		dvec=doubleNumberTuple(_t);
966		_t = _retTree;
967	<	_t = __t26;
967	>	_t = __t30;
968		_t = _t->getNextSibling();
969	<	#line 109 "MDTreeParser.g"
969	>	#line 115 "MDTreeParser.g"
970		currAtomStamp->setPosition(dvec);
971	<	#line 923 "MDTreeParser.cpp"
971	>	#line 972 "MDTreeParser.cpp"
972		break;
973		}
974		case ORIENTATION:
975		{
976	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
977	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
976	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
977	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978		match(_t,ORIENTATION);
979		_t = _t->getFirstChild();
980		dvec=doubleNumberTuple(_t);
981		_t = _retTree;
982	<	_t = __t27;
982	>	_t = __t31;
983		_t = _t->getNextSibling();
984	<	#line 110 "MDTreeParser.g"
984	>	#line 116 "MDTreeParser.g"
985		currAtomStamp->setOrientation(dvec);
986	<	#line 938 "MDTreeParser.cpp"
986	>	#line 987 "MDTreeParser.cpp"
987		break;
988		}
989		default:
#	Line 952 | Line 1001 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1001		}
1002
1003		vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004	<	#line 247 "MDTreeParser.g"
1004	>	#line 253 "MDTreeParser.g"
1005		vector<RealType> dvec;
1006	<	#line 958 "MDTreeParser.cpp"
1006	>	#line 1007 "MDTreeParser.cpp"
1007		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008	<	#line 247 "MDTreeParser.g"
1008	>	#line 253 "MDTreeParser.g"
1009
1010		RealType dval;
1011
1012	<	#line 964 "MDTreeParser.cpp"
1012	>	#line 1013 "MDTreeParser.cpp"
1013
1014		try {      // for error handling
1015		{ // ( ... )+
1016	<	int _cnt71=0;
1016	>	int _cnt75=0;
1017		for (;;) {
1018		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1019		_t = ASTNULL;
1020		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1021		dval=doubleNumber(_t);
1022		_t = _retTree;
1023	<	#line 251 "MDTreeParser.g"
1023	>	#line 257 "MDTreeParser.g"
1024		dvec.push_back(dval);
1025	<	#line 977 "MDTreeParser.cpp"
1025	>	#line 1026 "MDTreeParser.cpp"
1026		}
1027		else {
1028	<	if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1028	>	if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1029		}
1030
1031	<	_cnt71++;
1031	>	_cnt75++;
1032		}
1033	<	_loop71:;
1033	>	_loop75:;
1034		}  // ( ... )+
1035		}
1036		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 995 | Line 1044 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1044
1045		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1046		ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047	<	#line 123 "MDTreeParser.g"
1047	>	#line 129 "MDTreeParser.g"
1048
1049		vector<int> ivec;
1050		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1051
1052	<	#line 1004 "MDTreeParser.cpp"
1052	>	#line 1053 "MDTreeParser.cpp"
1053
1054		try {      // for error handling
1055		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1014 | Line 1063 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1063		}
1064		case MEMBERS:
1065		{
1066	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1067	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1066	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1067	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1068		match(_t,MEMBERS);
1069		_t = _t->getFirstChild();
1070		ivec=inttuple(_t);
1071		_t = _retTree;
1072	<	_t = __t33;
1072	>	_t = __t37;
1073		_t = _t->getNextSibling();
1074	<	#line 129 "MDTreeParser.g"
1074	>	#line 135 "MDTreeParser.g"
1075		currBondStamp->setMembers(ivec);
1076	<	#line 1028 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		break;
1078		}
1079		default:
#	Line 1042 | Line 1091 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1091		}
1092
1093		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1094	<	#line 254 "MDTreeParser.g"
1094	>	#line 260 "MDTreeParser.g"
1095		vector<int> ivec;
1096	<	#line 1048 "MDTreeParser.cpp"
1096	>	#line 1097 "MDTreeParser.cpp"
1097		ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098	<	#line 254 "MDTreeParser.g"
1098	>	#line 260 "MDTreeParser.g"
1099
1100		int ival;
1101
1102	<	#line 1054 "MDTreeParser.cpp"
1102	>	#line 1103 "MDTreeParser.cpp"
1103
1104		try {      // for error handling
1105		{ // ( ... )+
1106	<	int _cnt74=0;
1106	>	int _cnt78=0;
1107		for (;;) {
1108		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1109		_t = ASTNULL;
1110		if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1111		ival=intConst(_t);
1112		_t = _retTree;
1113	<	#line 258 "MDTreeParser.g"
1113	>	#line 264 "MDTreeParser.g"
1114		ivec.push_back(ival);
1115	<	#line 1067 "MDTreeParser.cpp"
1115	>	#line 1116 "MDTreeParser.cpp"
1116		}
1117		else {
1118	<	if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1118	>	if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1119		}
1120
1121	<	_cnt74++;
1121	>	_cnt78++;
1122		}
1123	<	_loop74:;
1123	>	_loop78:;
1124		}  // ( ... )+
1125		}
1126		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1085 | Line 1134 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1134
1135		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1136		ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137	<	#line 142 "MDTreeParser.g"
1137	>	#line 148 "MDTreeParser.g"
1138
1139		vector<int> ivec;
1140		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1141
1142	<	#line 1094 "MDTreeParser.cpp"
1142	>	#line 1143 "MDTreeParser.cpp"
1143
1144		try {      // for error handling
1145		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1104 | Line 1153 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1153		}
1154		case MEMBERS:
1155		{
1156	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1157	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1156	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1157	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1158		match(_t,MEMBERS);
1159		_t = _t->getFirstChild();
1160		ivec=inttuple(_t);
1161		_t = _retTree;
1162	<	_t = __t39;
1162	>	_t = __t43;
1163		_t = _t->getNextSibling();
1164	<	#line 148 "MDTreeParser.g"
1164	>	#line 154 "MDTreeParser.g"
1165		currBendStamp->setMembers(ivec);
1166	<	#line 1118 "MDTreeParser.cpp"
1166	>	#line 1167 "MDTreeParser.cpp"
1167		break;
1168		}
1169		default:
#	Line 1133 | Line 1182 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1182
1183		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1184		ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185	<	#line 161 "MDTreeParser.g"
1185	>	#line 167 "MDTreeParser.g"
1186
1187		vector<int> ivec;
1188		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1189
1190	<	#line 1142 "MDTreeParser.cpp"
1190	>	#line 1191 "MDTreeParser.cpp"
1191
1192		try {      // for error handling
1193		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1152 | Line 1201 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1201		}
1202		case MEMBERS:
1203		{
1204	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1205	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1204	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1205	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1206		match(_t,MEMBERS);
1207		_t = _t->getFirstChild();
1208		ivec=inttuple(_t);
1209		_t = _retTree;
1210	<	_t = __t45;
1210	>	_t = __t49;
1211		_t = _t->getNextSibling();
1212	<	#line 167 "MDTreeParser.g"
1212	>	#line 173 "MDTreeParser.g"
1213		currTorsionStamp->setMembers(ivec);
1214	<	#line 1166 "MDTreeParser.cpp"
1214	>	#line 1215 "MDTreeParser.cpp"
1215		break;
1216		}
1217		default:
#	Line 1181 | Line 1230 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1230
1231		void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1232		ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1233	<	#line 180 "MDTreeParser.g"
1233	>	#line 186 "MDTreeParser.g"
1234
1235		int icent;
1236		InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1237
1238	<	#line 1190 "MDTreeParser.cpp"
1238	>	#line 1239 "MDTreeParser.cpp"
1239
1240		try {      // for error handling
1241		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1200 | Line 1249 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1249		}
1250		case CENTER:
1251		{
1252	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1253	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1252	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1253	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1254		match(_t,CENTER);
1255		_t = _t->getFirstChild();
1256		icent=intConst(_t);
1257		_t = _retTree;
1258	<	_t = __t51;
1258	>	_t = __t55;
1259		_t = _t->getNextSibling();
1260	<	#line 186 "MDTreeParser.g"
1260	>	#line 192 "MDTreeParser.g"
1261		currInversionStamp->setCenter(icent);
1262	<	#line 1214 "MDTreeParser.cpp"
1262	>	#line 1263 "MDTreeParser.cpp"
1263		break;
1264		}
1265		default:
#	Line 1229 | Line 1278 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1278
1279		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281	<	#line 203 "MDTreeParser.g"
1281	>	#line 209 "MDTreeParser.g"
1282
1283		vector<int> ivec;
1284		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1285
1286	<	#line 1238 "MDTreeParser.cpp"
1286	>	#line 1287 "MDTreeParser.cpp"
1287
1288		try {      // for error handling
1289		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1248 | Line 1297 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1297		}
1298		case MEMBERS:
1299		{
1300	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1301	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1300	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1301	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1302		match(_t,MEMBERS);
1303		_t = _t->getFirstChild();
1304		ivec=inttuple(_t);
1305		_t = _retTree;
1306	<	_t = __t57;
1306	>	_t = __t61;
1307		_t = _t->getNextSibling();
1308	<	#line 209 "MDTreeParser.g"
1308	>	#line 215 "MDTreeParser.g"
1309		currRigidBodyStamp->setMembers(ivec);
1310	<	#line 1262 "MDTreeParser.cpp"
1310	>	#line 1311 "MDTreeParser.cpp"
1311		break;
1312		}
1313		default:
#	Line 1277 | Line 1326 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1326
1327		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	<	#line 222 "MDTreeParser.g"
1329	>	#line 228 "MDTreeParser.g"
1330
1331		vector<int> ivec;
1332		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1333
1334	<	#line 1286 "MDTreeParser.cpp"
1334	>	#line 1335 "MDTreeParser.cpp"
1335
1336		try {      // for error handling
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1296 | Line 1345 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1345		}
1346		case MEMBERS:
1347		{
1348	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1349	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1348	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1349	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1350		match(_t,MEMBERS);
1351		_t = _t->getFirstChild();
1352		ivec=inttuple(_t);
1353		_t = _retTree;
1354	<	_t = __t63;
1354	>	_t = __t67;
1355		_t = _t->getNextSibling();
1356	<	#line 228 "MDTreeParser.g"
1356	>	#line 234 "MDTreeParser.g"
1357		currCutoffGroupStamp->setMembers(ivec);
1358	<	#line 1310 "MDTreeParser.cpp"
1358	>	#line 1359 "MDTreeParser.cpp"
1359		break;
1360		}
1361		default:
#	Line 1339 | Line 1388 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1388		}
1389
1390		RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391	<	#line 268 "MDTreeParser.g"
1391	>	#line 274 "MDTreeParser.g"
1392		RealType dval;
1393	<	#line 1345 "MDTreeParser.cpp"
1393	>	#line 1394 "MDTreeParser.cpp"
1394		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1395		ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1396		ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 1356 | Line 1405 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1405		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406		intConst(_t);
1407		_t = _retTree;
1408	<	#line 270 "MDTreeParser.g"
1408	>	#line 276 "MDTreeParser.g"
1409		dval = lexi_cast<RealType>(ic->getText());
1410	<	#line 1362 "MDTreeParser.cpp"
1410	>	#line 1411 "MDTreeParser.cpp"
1411		break;
1412		}
1413		case NUM_FLOAT:
#	Line 1367 | Line 1416 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1416		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417		floatConst(_t);
1418		_t = _retTree;
1419	<	#line 271 "MDTreeParser.g"
1419	>	#line 277 "MDTreeParser.g"
1420		dval = lexi_cast<RealType>(fc->getText());
1421	<	#line 1373 "MDTreeParser.cpp"
1421	>	#line 1422 "MDTreeParser.cpp"
1422		break;
1423		}
1424		default:
#	Line 1398 | Line 1447 | const char* MDTreeParser::tokenNames[] = {
1447		"\"component\"",
1448		"\"molecule\"",
1449		"\"zconstraint\"",
1450	+	"\"restraint\"",
1451		"\"atom\"",
1452		"\"bond\"",
1453		"\"bend\"",
#	Line 1447 | Line 1497 | const char* MDTreeParser::tokenNames[] = {
1497		0
1498		};
1499
1500	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1501	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1500	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1501	>	// "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL
1502		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1503	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1503	>	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
1504		// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1505		// "fragment" ASSIGNEQUAL
1506		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 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

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

Diff Legend

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