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 814 by tim, Fri Dec 16 02:57:00 2005 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.5 (20050406): "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 13 | Line 13 | void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)Re
13		}
14
15		void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
16	<	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
16	>	ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
17
18		try {      // for error handling
19		{ // ( ... )*
#	Line 44 | Line 44 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
44		}
45
46		void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
47	<	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
47	>	ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
48
49		try {      // for error handling
50		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 74 | Line 74 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
74		_t = _retTree;
75		break;
76		}
77	+	case RESTRAINT:
78	+	{
79	+	restraintblock(_t);
80	+	_t = _retTree;
81	+	break;
82	+	}
83		default:
84		{
85		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 89 | Line 95 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl
95		}
96
97		void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
98	<	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
98	>	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
99		ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
100
101		try {      // for error handling
#	Line 114 | Line 120 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
120		}
121
122		void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
123	<	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
123	>	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
124
125		try {      // for error handling
126		ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
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 157 | Line 163 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
163		}
164
165		void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
166	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 200 | Line 206 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
206		}
207
208		void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
209	<	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
209	>	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
210
211		try {      // for error handling
212		ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
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 == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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	<	double dval;
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 242 "MDTreeParser.g"
369	>	#line 268 "MDTreeParser.g"
370		int ival;
371	<	#line 323 "MDTreeParser.cpp"
372	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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;
375
#	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 243 "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 244 "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 363 | Line 412 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
412		return ival;
413		}
414
415	<	double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416	<	#line 256 "MDTreeParser.g"
417	<	double dval;
418	<	#line 370 "MDTreeParser.cpp"
419	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
415	>	RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416	>	#line 282 "MDTreeParser.g"
417	>	RealType dval;
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;
422
#	Line 380 | Line 429 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
429		d1 = _t;
430		match(_t,NUM_FLOAT);
431		_t = _t->getNextSibling();
432	<	#line 257 "MDTreeParser.g"
433	<	dval = lexi_cast<double>(d1->getText());
434	<	#line 386 "MDTreeParser.cpp"
432	>	#line 283 "MDTreeParser.g"
433	>	dval = lexi_cast<RealType>(d1->getText());
434	>	#line 435 "MDTreeParser.cpp"
435		break;
436		}
437		case NUM_DOUBLE:
#	Line 390 | Line 439 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
439		d2 = _t;
440		match(_t,NUM_DOUBLE);
441		_t = _t->getNextSibling();
442	<	#line 258 "MDTreeParser.g"
443	<	dval = lexi_cast<double>(d2->getText());
444	<	#line 396 "MDTreeParser.cpp"
442	>	#line 284 "MDTreeParser.g"
443	>	dval = lexi_cast<RealType>(d2->getText());
444	>	#line 445 "MDTreeParser.cpp"
445		break;
446		}
447		default:
#	Line 411 | Line 460 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
460		}
461
462		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
463	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
463	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
464
465		try {      // for error handling
466		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 447 | Line 496 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
496		_t = _retTree;
497		break;
498		}
499	+	case INVERSION:
500	+	{
501	+	inversionblock(_t);
502	+	_t = _retTree;
503	+	break;
504	+	}
505		case RIGIDBODY:
506		{
507		rigidbodyblock(_t);
#	Line 480 | Line 535 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
535		}
536
537		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
538	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539	<	#line 87 "MDTreeParser.g"
538	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539	>	#line 94 "MDTreeParser.g"
540
541		int index;
542
543	<	#line 489 "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 91 "MDTreeParser.g"
552	>	#line 98 "MDTreeParser.g"
553		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554	<	#line 500 "MDTreeParser.cpp"
554	>	#line 555 "MDTreeParser.cpp"
555		{ // ( ... )*
556		for (;;) {
557		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 506 | 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 93 "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 528 "MDTreeParser.cpp"
582	>	#line 583 "MDTreeParser.cpp"
583		}
584		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
585		reportError(ex);
#	Line 535 | Line 590 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
590		}
591
592		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
593	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 113 "MDTreeParser.g"
600	>	#line 120 "MDTreeParser.g"
601		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602	<	#line 548 "MDTreeParser.cpp"
602	>	#line 603 "MDTreeParser.cpp"
603		{ // ( ... )*
604		for (;;) {
605		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 554 | 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 115 "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 575 "MDTreeParser.cpp"
629	>	#line 630 "MDTreeParser.cpp"
630		}
631		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
632		reportError(ex);
#	Line 582 | Line 637 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
637		}
638
639		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
640	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 131 "MDTreeParser.g"
647	>	#line 138 "MDTreeParser.g"
648		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649	<	#line 595 "MDTreeParser.cpp"
649	>	#line 650 "MDTreeParser.cpp"
650		{ // ( ... )*
651		for (;;) {
652		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 601 | 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 133 "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 623 "MDTreeParser.cpp"
677	>	#line 678 "MDTreeParser.cpp"
678		}
679		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
680		reportError(ex);
#	Line 630 | Line 685 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
685		}
686
687		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
688	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 150 "MDTreeParser.g"
695	>	#line 157 "MDTreeParser.g"
696		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697	<	#line 643 "MDTreeParser.cpp"
697	>	#line 698 "MDTreeParser.cpp"
698		{ // ( ... )*
699		for (;;) {
700		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 649 | 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 152 "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 671 "MDTreeParser.cpp"
725	>	#line 726 "MDTreeParser.cpp"
726		}
727		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728		reportError(ex);
#	Line 677 | Line 732 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
732		_retTree = _t;
733		}
734
735	+	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t51 = _t;
740	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741	+	match(_t,INVERSION);
742	+	_t = _t->getFirstChild();
743	+	#line 176 "MDTreeParser.g"
744	+	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
745	+	#line 746 "MDTreeParser.cpp"
746	+	{ // ( ... )*
747	+	for (;;) {
748	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
749	+	_t = ASTNULL;
750	+	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
751	+	inversionstatement(_t);
752	+	_t = _retTree;
753	+	}
754	+	else {
755	+	goto _loop53;
756	+	}
757	+
758	+	}
759	+	_loop53:;
760	+	} // ( ... )*
761	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
762	+	match(_t,ENDBLOCK);
763	+	_t = _t->getNextSibling();
764	+	_t = __t51;
765	+	_t = _t->getNextSibling();
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 774 "MDTreeParser.cpp"
774	+	}
775	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776	+	reportError(ex);
777	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
778	+	_t = _t->getNextSibling();
779	+	}
780	+	_retTree = _t;
781	+	}
782	+
783		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785	<	#line 169 "MDTreeParser.g"
784	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785	>	#line 195 "MDTreeParser.g"
786
787		int index;
788
789	<	#line 687 "MDTreeParser.cpp"
789	>	#line 790 "MDTreeParser.cpp"
790
791		try {      // for error handling
792	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
793	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_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 173 "MDTreeParser.g"
798	>	#line 199 "MDTreeParser.g"
799		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800	<	#line 698 "MDTreeParser.cpp"
800	>	#line 801 "MDTreeParser.cpp"
801		{ // ( ... )*
802		for (;;) {
803		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 704 | Line 807 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
807		_t = _retTree;
808		}
809		else {
810	<	goto _loop49;
810	>	goto _loop59;
811		}
812
813		}
814	<	_loop49:;
814	>	_loop59:;
815		} // ( ... )*
816	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
816	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817		match(_t,ENDBLOCK);
818		_t = _t->getNextSibling();
819	<	_t = __t47;
819	>	_t = __t57;
820		_t = _t->getNextSibling();
821	<	#line 175 "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 726 "MDTreeParser.cpp"
828	>	#line 829 "MDTreeParser.cpp"
829		}
830		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
831		reportError(ex);
#	Line 733 | Line 836 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
836		}
837
838		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
839	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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 __t53 = _t;
843	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_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 192 "MDTreeParser.g"
846	>	#line 218 "MDTreeParser.g"
847		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848	<	#line 746 "MDTreeParser.cpp"
848	>	#line 849 "MDTreeParser.cpp"
849		{ // ( ... )*
850		for (;;) {
851		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 752 | Line 855 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
855		_t = _retTree;
856		}
857		else {
858	<	goto _loop55;
858	>	goto _loop65;
859		}
860
861		}
862	<	_loop55:;
862	>	_loop65:;
863		} // ( ... )*
864	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
864	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865		match(_t,ENDBLOCK);
866		_t = _t->getNextSibling();
867	<	_t = __t53;
867	>	_t = __t63;
868		_t = _t->getNextSibling();
869	<	#line 194 "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 774 "MDTreeParser.cpp"
876	>	#line 877 "MDTreeParser.cpp"
877		}
878		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
879		reportError(ex);
#	Line 781 | Line 884 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
884		}
885
886		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
887	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888	<	#line 211 "MDTreeParser.g"
887	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888	>	#line 237 "MDTreeParser.g"
889		int ival;
890	<	#line 788 "MDTreeParser.cpp"
890	>	#line 891 "MDTreeParser.cpp"
891
892		try {      // for error handling
893	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_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 212 "MDTreeParser.g"
899	>	#line 238 "MDTreeParser.g"
900		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901	<	#line 799 "MDTreeParser.cpp"
901	>	#line 902 "MDTreeParser.cpp"
902		{ // ( ... )*
903		for (;;) {
904		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 805 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
908		_t = _retTree;
909		}
910		else {
911	<	goto _loop61;
911	>	goto _loop71;
912		}
913
914		}
915	<	_loop61:;
915	>	_loop71:;
916		} // ( ... )*
917	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
917	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918		match(_t,ENDBLOCK);
919		_t = _t->getNextSibling();
920	<	_t = __t59;
920	>	_t = __t69;
921		_t = _t->getNextSibling();
922	<	#line 214 "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 827 "MDTreeParser.cpp"
929	>	#line 930 "MDTreeParser.cpp"
930		}
931		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
932		reportError(ex);
#	Line 834 | Line 937 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
937		}
938
939		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
940	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941	<	#line 101 "MDTreeParser.g"
940	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941	>	#line 108 "MDTreeParser.g"
942
943	<	vector<double> dvec;
943	>	vector<RealType> dvec;
944		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
945
946
947	<	#line 845 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948
949		try {      // for error handling
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 855 | 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 tmp22_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 108 "MDTreeParser.g"
969	>	#line 115 "MDTreeParser.g"
970		currAtomStamp->setPosition(dvec);
971	<	#line 869 "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 tmp23_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 109 "MDTreeParser.g"
984	>	#line 116 "MDTreeParser.g"
985		currAtomStamp->setOrientation(dvec);
986	<	#line 884 "MDTreeParser.cpp"
986	>	#line 987 "MDTreeParser.cpp"
987		break;
988		}
989		default:
#	Line 897 | Line 1000 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1000		_retTree = _t;
1001		}
1002
1003	<	vector<double>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004	<	#line 227 "MDTreeParser.g"
1005	<	vector<double> dvec;
1006	<	#line 904 "MDTreeParser.cpp"
1007	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008	<	#line 227 "MDTreeParser.g"
1003	>	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004	>	#line 253 "MDTreeParser.g"
1005	>	vector<RealType> dvec;
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 253 "MDTreeParser.g"
1009
1010	<	double dval;
1010	>	RealType dval;
1011
1012	<	#line 910 "MDTreeParser.cpp"
1012	>	#line 1013 "MDTreeParser.cpp"
1013
1014		try {      // for error handling
1015		{ // ( ... )+
1016	<	int _cnt65=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 231 "MDTreeParser.g"
1023	>	#line 257 "MDTreeParser.g"
1024		dvec.push_back(dval);
1025	<	#line 923 "MDTreeParser.cpp"
1025	>	#line 1026 "MDTreeParser.cpp"
1026		}
1027		else {
1028	<	if ( _cnt65>=1 ) { goto _loop65; } 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	<	_cnt65++;
1031	>	_cnt75++;
1032		}
1033	<	_loop65:;
1033	>	_loop75:;
1034		}  // ( ... )+
1035		}
1036		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 940 | Line 1043 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1043		}
1044
1045		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1046	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047	<	#line 122 "MDTreeParser.g"
1046	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047	>	#line 129 "MDTreeParser.g"
1048
1049		vector<int> ivec;
1050		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1051
1052	<	#line 950 "MDTreeParser.cpp"
1052	>	#line 1053 "MDTreeParser.cpp"
1053
1054		try {      // for error handling
1055		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 960 | 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 tmp24_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 128 "MDTreeParser.g"
1074	>	#line 135 "MDTreeParser.g"
1075		currBondStamp->setMembers(ivec);
1076	<	#line 974 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		break;
1078		}
1079		default:
#	Line 988 | Line 1091 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1091		}
1092
1093		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1094	<	#line 234 "MDTreeParser.g"
1094	>	#line 260 "MDTreeParser.g"
1095		vector<int> ivec;
1096	<	#line 994 "MDTreeParser.cpp"
1097	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098	<	#line 234 "MDTreeParser.g"
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 260 "MDTreeParser.g"
1099
1100		int ival;
1101
1102	<	#line 1000 "MDTreeParser.cpp"
1102	>	#line 1103 "MDTreeParser.cpp"
1103
1104		try {      // for error handling
1105		{ // ( ... )+
1106	<	int _cnt68=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 238 "MDTreeParser.g"
1113	>	#line 264 "MDTreeParser.g"
1114		ivec.push_back(ival);
1115	<	#line 1013 "MDTreeParser.cpp"
1115	>	#line 1116 "MDTreeParser.cpp"
1116		}
1117		else {
1118	<	if ( _cnt68>=1 ) { goto _loop68; } 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	<	_cnt68++;
1121	>	_cnt78++;
1122		}
1123	<	_loop68:;
1123	>	_loop78:;
1124		}  // ( ... )+
1125		}
1126		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1030 | Line 1133 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1133		}
1134
1135		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1136	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137	<	#line 141 "MDTreeParser.g"
1136	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137	>	#line 148 "MDTreeParser.g"
1138
1139		vector<int> ivec;
1140		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1141
1142	<	#line 1040 "MDTreeParser.cpp"
1142	>	#line 1143 "MDTreeParser.cpp"
1143
1144		try {      // for error handling
1145		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1050 | 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 tmp25_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 147 "MDTreeParser.g"
1164	>	#line 154 "MDTreeParser.g"
1165		currBendStamp->setMembers(ivec);
1166	<	#line 1064 "MDTreeParser.cpp"
1166	>	#line 1167 "MDTreeParser.cpp"
1167		break;
1168		}
1169		default:
#	Line 1078 | Line 1181 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1181		}
1182
1183		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1184	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185	<	#line 160 "MDTreeParser.g"
1184	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185	>	#line 167 "MDTreeParser.g"
1186
1187		vector<int> ivec;
1188		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1189
1190	<	#line 1088 "MDTreeParser.cpp"
1190	>	#line 1191 "MDTreeParser.cpp"
1191
1192		try {      // for error handling
1193		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1098 | 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 tmp26_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 166 "MDTreeParser.g"
1212	>	#line 173 "MDTreeParser.g"
1213		currTorsionStamp->setMembers(ivec);
1214	<	#line 1112 "MDTreeParser.cpp"
1214	>	#line 1215 "MDTreeParser.cpp"
1215		break;
1216		}
1217		default:
#	Line 1125 | Line 1228 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1228		_retTree = _t;
1229		}
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 186 "MDTreeParser.g"
1234	+
1235	+	int icent;
1236	+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1237	+
1238	+	#line 1239 "MDTreeParser.cpp"
1239	+
1240	+	try {      // for error handling
1241	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1242	+	_t = ASTNULL;
1243	+	switch ( _t->getType()) {
1244	+	case ASSIGNEQUAL:
1245	+	{
1246	+	assignment(_t);
1247	+	_t = _retTree;
1248	+	break;
1249	+	}
1250	+	case CENTER:
1251	+	{
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 = __t55;
1259	+	_t = _t->getNextSibling();
1260	+	#line 192 "MDTreeParser.g"
1261	+	currInversionStamp->setCenter(icent);
1262	+	#line 1263 "MDTreeParser.cpp"
1263	+	break;
1264	+	}
1265	+	default:
1266	+	{
1267	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1268	+	}
1269	+	}
1270	+	}
1271	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1272	+	reportError(ex);
1273	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1274	+	_t = _t->getNextSibling();
1275	+	}
1276	+	_retTree = _t;
1277	+	}
1278	+
1279		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281	<	#line 183 "MDTreeParser.g"
1280	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281	>	#line 209 "MDTreeParser.g"
1282
1283		vector<int> ivec;
1284		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1285
1286	<	#line 1136 "MDTreeParser.cpp"
1286	>	#line 1287 "MDTreeParser.cpp"
1287
1288		try {      // for error handling
1289		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1146 | Line 1297 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1297		}
1298		case MEMBERS:
1299		{
1300	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1301	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_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 = __t51;
1306	>	_t = __t61;
1307		_t = _t->getNextSibling();
1308	<	#line 189 "MDTreeParser.g"
1308	>	#line 215 "MDTreeParser.g"
1309		currRigidBodyStamp->setMembers(ivec);
1310	<	#line 1160 "MDTreeParser.cpp"
1310	>	#line 1311 "MDTreeParser.cpp"
1311		break;
1312		}
1313		default:
#	Line 1174 | Line 1325 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1325		}
1326
1327		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	<	#line 202 "MDTreeParser.g"
1328	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	>	#line 228 "MDTreeParser.g"
1330
1331		vector<int> ivec;
1332		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1333
1334	<	#line 1184 "MDTreeParser.cpp"
1334	>	#line 1335 "MDTreeParser.cpp"
1335
1336		try {      // for error handling
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1194 | Line 1345 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1345		}
1346		case MEMBERS:
1347		{
1348	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1349	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 = __t57;
1354	>	_t = __t67;
1355		_t = _t->getNextSibling();
1356	<	#line 208 "MDTreeParser.g"
1356	>	#line 234 "MDTreeParser.g"
1357		currCutoffGroupStamp->setMembers(ivec);
1358	<	#line 1208 "MDTreeParser.cpp"
1358	>	#line 1359 "MDTreeParser.cpp"
1359		break;
1360		}
1361		default:
#	Line 1222 | Line 1373 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1373		}
1374
1375		void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1376	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1377
1378		try {      // for error handling
1379		assignment(_t);
#	Line 1236 | Line 1387 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1387		_retTree = _t;
1388		}
1389
1390	<	double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391	<	#line 248 "MDTreeParser.g"
1392	<	double dval;
1393	<	#line 1243 "MDTreeParser.cpp"
1394	<	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1390	>	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391	>	#line 274 "MDTreeParser.g"
1392	>	RealType dval;
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;
1397
#	Line 1254 | Line 1405 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1405		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406		intConst(_t);
1407		_t = _retTree;
1408	<	#line 250 "MDTreeParser.g"
1409	<	dval = lexi_cast<double>(ic->getText());
1410	<	#line 1260 "MDTreeParser.cpp"
1408	>	#line 276 "MDTreeParser.g"
1409	>	dval = lexi_cast<RealType>(ic->getText());
1410	>	#line 1411 "MDTreeParser.cpp"
1411		break;
1412		}
1413		case NUM_FLOAT:
#	Line 1265 | Line 1416 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1416		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417		floatConst(_t);
1418		_t = _retTree;
1419	<	#line 251 "MDTreeParser.g"
1420	<	dval = lexi_cast<double>(fc->getText());
1421	<	#line 1271 "MDTreeParser.cpp"
1419	>	#line 277 "MDTreeParser.g"
1420	>	dval = lexi_cast<RealType>(fc->getText());
1421	>	#line 1422 "MDTreeParser.cpp"
1422		break;
1423		}
1424		default:
#	Line 1296 | Line 1447 | const char* MDTreeParser::tokenNames[] = {
1447		"\"component\"",
1448		"\"molecule\"",
1449		"\"zconstraint\"",
1450	+	"\"restraint\"",
1451		"\"atom\"",
1452		"\"bond\"",
1453		"\"bend\"",
1454		"\"torsion\"",
1455	+	"\"inversion\"",
1456		"\"rigidBody\"",
1457		"\"cutoffGroup\"",
1458		"\"fragment\"",
1459		"\"members\"",
1460	+	"\"center\"",
1461		"\"position\"",
1462		"\"orientation\"",
1463		"ENDBLOCK",
#	Line 1343 | Line 1497 | const char* MDTreeParser::tokenNames[] = {
1497		0
1498		};
1499
1500	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 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_[] = { 540544UL, 0UL, 0UL, 0UL };
1504	<	// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1505	<	// ASSIGNEQUAL
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);
1507
1508

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 814 by tim, Fri Dec 16 02:57:00 2005 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