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 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

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 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

Diff Legend

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