ViewVC Help

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

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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1558 by gezelter, Wed May 11 16:32:48 2011 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20101020): "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 __t13 = _t;
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 69 "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 133 | Line 139 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
139		_t = _retTree;
140		}
141		else {
142	<	goto _loop15;
142	>	goto _loop11;
143		}
144
145		}
146	<	_loop15:;
146	>	_loop11:;
147		} // ( ... )*
148		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
149		match(_t,ENDBLOCK);
150		_t = _t->getNextSibling();
151	<	_t = __t13;
151	>	_t = __t9;
152		_t = _t->getNextSibling();
153	<	#line 71 "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 __t21 = _t;
170		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
171		match(_t,MOLECULE);
172		_t = _t->getFirstChild();
173	<	#line 79 "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 187 | Line 193 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
193		_t = _t->getNextSibling();
194		_t = __t21;
195		_t = _t->getNextSibling();
196	<	#line 81 "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 __t17 = _t;
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 74 "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 219 | Line 225 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
225		_t = _retTree;
226		}
227		else {
228	+	goto _loop15;
229	+	}
230	+
231	+	}
232	+	_loop15:;
233	+	} // ( ... )*
234	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
235	+	match(_t,ENDBLOCK);
236	+	_t = _t->getNextSibling();
237	+	_t = __t13;
238	+	_t = _t->getNextSibling();
239	+	#line 70 "MDTreeParser.g"
240	+	blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
241	+	#line 242 "MDTreeParser.cpp"
242	+	}
243	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
244	+	reportError(ex);
245	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
246	+	_t = _t->getNextSibling();
247	+	}
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 tmp7_AST_in = _t;
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 76 "MDTreeParser.g"
283	<	blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
284	<	#line 236 "MDTreeParser.cpp"
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);
#	Line 245 | Line 294 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
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 48 "MDTreeParser.g"
301
302	+	int ival;
303	+	RealType dval;
304	+
305	+	#line 306 "MDTreeParser.cpp"
306	+
307		try {      // for error handling
308		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
309		_t = ASTNULL;
310		switch ( _t->getType()) {
311	<	case OCTALINT:
312	<	case DECIMALINT:
313	<	case HEXADECIMALINT:
314	<	case MINUS:
260	<	case FLOATONE:
261	<	case FLOATTWO:
262	<	{
263	<	signedIntOrFloat(_t,id);
311	>	case NUM_INT:
312	>	case NUM_LONG:
313	>	{
314	>	ival=intConst(_t);
315		_t = _retTree;
316	+	#line 53 "MDTreeParser.g"
317	+	blockStack.top()->assign(id->getText(), ival);
318	+	#line 319 "MDTreeParser.cpp"
319		break;
320		}
321	+	case NUM_FLOAT:
322	+	case NUM_DOUBLE:
323	+	{
324	+	dval=floatConst(_t);
325	+	_t = _retTree;
326	+	#line 54 "MDTreeParser.g"
327	+	blockStack.top()->assign(id->getText(), dval);
328	+	#line 329 "MDTreeParser.cpp"
329	+	break;
330	+	}
331		case ID:
332		{
333		str1 = _t;
334		match(_t,ID);
335		_t = _t->getNextSibling();
336	<	#line 49 "MDTreeParser.g"
336	>	#line 55 "MDTreeParser.g"
337		blockStack.top()->assign(id->getText(), str1->getText());
338	<	#line 275 "MDTreeParser.cpp"
338	>	#line 339 "MDTreeParser.cpp"
339		break;
340		}
341		case StringLiteral:
#	Line 279 | Line 343 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
343		str2 = _t;
344		match(_t,StringLiteral);
345		_t = _t->getNextSibling();
346	<	#line 50 "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 288 "MDTreeParser.cpp"
351	>	#line 352 "MDTreeParser.cpp"
352		break;
353		}
354		default:
#	Line 301 | Line 365 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
365		_retTree = _t;
366		}
367
368	<	void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
369	<	ANTLR_USE_NAMESPACE(antlr)RefAST id
306	<	) {
307	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedIntOrFloat_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
308	<	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
309	<	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
310	<	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
311	<	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
312	<	#line 56 "MDTreeParser.g"
313	<
368	>	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
369	>	#line 268 "MDTreeParser.g"
370		int ival;
371	<	double dval;
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
317	–	#line 318 "MDTreeParser.cpp"
318	–
376		try {      // for error handling
377		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
378		_t = ASTNULL;
379		switch ( _t->getType()) {
380	<	case MINUS:
380	>	case NUM_INT:
381		{
382	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
383	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
327	<	match(_t,MINUS);
328	<	_t = _t->getFirstChild();
329	<	{
330	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
331	<	_t = ASTNULL;
332	<	switch ( _t->getType()) {
333	<	case OCTALINT:
334	<	case DECIMALINT:
335	<	case HEXADECIMALINT:
336	<	{
337	<	icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
338	<	intConst(_t);
339	<	_t = _retTree;
340	<	#line 61 "MDTreeParser.g"
341	<	ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);
342	<	#line 343 "MDTreeParser.cpp"
343	<	break;
344	<	}
345	<	case FLOATONE:
346	<	case FLOATTWO:
347	<	{
348	<	fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
349	<	floatConst(_t);
350	<	_t = _retTree;
351	<	break;
352	<	}
353	<	default:
354	<	{
355	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
356	<	}
357	<	}
358	<	}
359	<	#line 62 "MDTreeParser.g"
360	<	dval = lexi_cast<double>(fcMinus->getText());dval = -dval;  blockStack.top()->assign(id->getText(), dval);
361	<	#line 362 "MDTreeParser.cpp"
362	<	_t = __t9;
382	>	i1 = _t;
383	>	match(_t,NUM_INT);
384		_t = _t->getNextSibling();
385	+	#line 269 "MDTreeParser.g"
386	+	ival = lexi_cast<int>(i1->getText());
387	+	#line 388 "MDTreeParser.cpp"
388		break;
389		}
390	<	case OCTALINT:
367	<	case DECIMALINT:
368	<	case HEXADECIMALINT:
369	<	case FLOATONE:
370	<	case FLOATTWO:
390	>	case NUM_LONG:
391		{
392	<	{
393	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
374	<	_t = ASTNULL;
375	<	switch ( _t->getType()) {
376	<	case OCTALINT:
377	<	case DECIMALINT:
378	<	case HEXADECIMALINT:
379	<	{
380	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
381	<	intConst(_t);
382	<	_t = _retTree;
383	<	#line 64 "MDTreeParser.g"
384	<	ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);
385	<	#line 386 "MDTreeParser.cpp"
386	<	break;
387	<	}
388	<	case FLOATONE:
389	<	case FLOATTWO:
390	<	{
391	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
392	<	floatConst(_t);
393	<	_t = _retTree;
394	<	#line 65 "MDTreeParser.g"
395	<	dval = lexi_cast<double>(fc->getText());  blockStack.top()->assign(id->getText(), dval);
396	<	#line 397 "MDTreeParser.cpp"
397	<	break;
398	<	}
399	<	default:
400	<	{
401	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
402	<	}
403	<	}
404	<	}
405	<	break;
406	<	}
407	<	default:
408	<	{
409	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
410	<	}
411	<	}
412	<	}
413	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
414	<	reportError(ex);
415	<	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
392	>	i2 = _t;
393	>	match(_t,NUM_LONG);
394		_t = _t->getNextSibling();
395	<	}
396	<	_retTree = _t;
397	<	}
420	<
421	<	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
422	<	#line 249 "MDTreeParser.g"
423	<	int ival;
424	<	#line 425 "MDTreeParser.cpp"
425	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
426	<	ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
427	<	ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
428	<	ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
429	<
430	<	try {      // for error handling
431	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
432	<	_t = ASTNULL;
433	<	switch ( _t->getType()) {
434	<	case OCTALINT:
435	<	{
436	<	oival = _t;
437	<	match(_t,OCTALINT);
438	<	_t = _t->getNextSibling();
439	<	#line 250 "MDTreeParser.g"
440	<	ival = lexi_cast<int>(oival->getText());
441	<	#line 442 "MDTreeParser.cpp"
395	>	#line 270 "MDTreeParser.g"
396	>	ival = lexi_cast<int>(i2->getText());
397	>	#line 398 "MDTreeParser.cpp"
398		break;
399		}
444	–	case DECIMALINT:
445	–	{
446	–	dival = _t;
447	–	match(_t,DECIMALINT);
448	–	_t = _t->getNextSibling();
449	–	#line 251 "MDTreeParser.g"
450	–	ival = lexi_cast<int>(dival->getText());
451	–	#line 452 "MDTreeParser.cpp"
452	–	break;
453	–	}
454	–	case HEXADECIMALINT:
455	–	{
456	–	hival = _t;
457	–	match(_t,HEXADECIMALINT);
458	–	_t = _t->getNextSibling();
459	–	#line 252 "MDTreeParser.g"
460	–	ival = lexi_cast<int>(hival->getText());
461	–	#line 462 "MDTreeParser.cpp"
462	–	break;
463	–	}
400		default:
401		{
402		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 476 | 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 266 "MDTreeParser.g"
417	<	double dval;
418	<	#line 483 "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 488 | Line 424 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
424		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
425		_t = ASTNULL;
426		switch ( _t->getType()) {
427	<	case FLOATONE:
427	>	case NUM_FLOAT:
428		{
429		d1 = _t;
430	<	match(_t,FLOATONE);
430	>	match(_t,NUM_FLOAT);
431		_t = _t->getNextSibling();
432	<	#line 267 "MDTreeParser.g"
433	<	dval = lexi_cast<double>(d1->getText());
434	<	#line 499 "MDTreeParser.cpp"
432	>	#line 283 "MDTreeParser.g"
433	>	dval = lexi_cast<RealType>(d1->getText());
434	>	#line 435 "MDTreeParser.cpp"
435		break;
436		}
437	<	case FLOATTWO:
437	>	case NUM_DOUBLE:
438		{
439		d2 = _t;
440	<	match(_t,FLOATTWO);
440	>	match(_t,NUM_DOUBLE);
441		_t = _t->getNextSibling();
442	<	#line 268 "MDTreeParser.g"
443	<	dval = lexi_cast<double>(d2->getText());
444	<	#line 509 "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 524 | 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 560 | 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 593 | 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;
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 602 "MDTreeParser.cpp"
543	>	#line 544 "MDTreeParser.cpp"
544
545		try {      // for error handling
546		ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
547	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _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 98 "MDTreeParser.g"
553		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554	<	#line 613 "MDTreeParser.cpp"
554	>	#line 555 "MDTreeParser.cpp"
555		{ // ( ... )*
556		for (;;) {
557		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 625 | Line 567 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
567		}
568		_loop28:;
569		} // ( ... )*
570	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
570	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
571		match(_t,ENDBLOCK);
572		_t = _t->getNextSibling();
573		_t = __t26;
#	Line 637 | Line 579 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
579		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
580		currMoleculeStamp->addAtomStamp(currAtomStamp);
581
582	<	#line 641 "MDTreeParser.cpp"
582	>	#line 583 "MDTreeParser.cpp"
583		}
584		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
585		reportError(ex);
#	Line 648 | 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 __t33 = _t;
597	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
597	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
598		match(_t,BOND);
599		_t = _t->getFirstChild();
600		#line 120 "MDTreeParser.g"
601		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602	<	#line 661 "MDTreeParser.cpp"
602	>	#line 603 "MDTreeParser.cpp"
603		{ // ( ... )*
604		for (;;) {
605		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 673 | Line 615 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
615		}
616		_loop35:;
617		} // ( ... )*
618	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
618	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
619		match(_t,ENDBLOCK);
620		_t = _t->getNextSibling();
621		_t = __t33;
#	Line 684 | Line 626 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
626		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
627		currMoleculeStamp->addBondStamp(currBondStamp);
628
629	<	#line 688 "MDTreeParser.cpp"
629	>	#line 630 "MDTreeParser.cpp"
630		}
631		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
632		reportError(ex);
#	Line 695 | 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 __t39 = _t;
644	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
644	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
645		match(_t,BEND);
646		_t = _t->getFirstChild();
647		#line 138 "MDTreeParser.g"
648		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649	<	#line 708 "MDTreeParser.cpp"
649	>	#line 650 "MDTreeParser.cpp"
650		{ // ( ... )*
651		for (;;) {
652		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 720 | Line 662 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
662		}
663		_loop41:;
664		} // ( ... )*
665	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
665	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
666		match(_t,ENDBLOCK);
667		_t = _t->getNextSibling();
668		_t = __t39;
#	Line 732 | Line 674 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
674		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
675		currMoleculeStamp->addBendStamp(currBendStamp);
676
677	<	#line 736 "MDTreeParser.cpp"
677	>	#line 678 "MDTreeParser.cpp"
678		}
679		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
680		reportError(ex);
#	Line 743 | 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 __t45 = _t;
692	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
692	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
693		match(_t,TORSION);
694		_t = _t->getFirstChild();
695		#line 157 "MDTreeParser.g"
696		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697	<	#line 756 "MDTreeParser.cpp"
697	>	#line 698 "MDTreeParser.cpp"
698		{ // ( ... )*
699		for (;;) {
700		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 768 | Line 710 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
710		}
711		_loop47:;
712		} // ( ... )*
713	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
713	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714		match(_t,ENDBLOCK);
715		_t = _t->getNextSibling();
716		_t = __t45;
#	Line 780 | Line 722 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
722		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
724
725	<	#line 784 "MDTreeParser.cpp"
725	>	#line 726 "MDTreeParser.cpp"
726		}
727		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728		reportError(ex);
#	Line 790 | Line 732 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
732		_retTree = _t;
733		}
734
735	<	void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
736	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
795	<	#line 176 "MDTreeParser.g"
796	<
797	<	int index;
798	<
799	<	#line 800 "MDTreeParser.cpp"
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 tmp17_AST_in = _t;
741	<	match(_t,RIGIDBODY);
740	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741	>	match(_t,INVERSION);
742		_t = _t->getFirstChild();
743	<	index=intConst(_t);
744	<	_t = _retTree;
745	<	#line 180 "MDTreeParser.g"
809	<	RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
810	<	#line 811 "MDTreeParser.cpp"
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() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
751	<	rigidbodystatement(_t);
750	>	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
751	>	inversionstatement(_t);
752		_t = _retTree;
753		}
754		else {
#	Line 823 | Line 758 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
758		}
759		_loop53:;
760		} // ( ... )*
761	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
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 182 "MDTreeParser.g"
766	>	#line 178 "MDTreeParser.g"
767
768		blockStack.top()->validate();
769		blockStack.pop();
770		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771	<	currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
771	>	currMoleculeStamp->addInversionStamp(currInversionStamp);
772
773	<	#line 839 "MDTreeParser.cpp"
773	>	#line 774 "MDTreeParser.cpp"
774		}
775		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776		reportError(ex);
#	Line 845 | Line 780 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
780		_retTree = _t;
781		}
782
783	<	void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
783	>	void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785	>	#line 195 "MDTreeParser.g"
786
787	+	int index;
788	+
789	+	#line 790 "MDTreeParser.cpp"
790	+
791		try {      // for error handling
792		ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
793	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
794	<	match(_t,CUTOFFGROUP);
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 199 "MDTreeParser.g"
799	<	CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
800	<	#line 859 "MDTreeParser.cpp"
799	>	RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800	>	#line 801 "MDTreeParser.cpp"
801		{ // ( ... )*
802		for (;;) {
803		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
804		_t = ASTNULL;
805		if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
806	<	cutoffgroupstatement(_t);
806	>	rigidbodystatement(_t);
807		_t = _retTree;
808		}
809		else {
#	Line 871 | Line 813 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
813		}
814		_loop59:;
815		} // ( ... )*
816	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
816	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817		match(_t,ENDBLOCK);
818		_t = _t->getNextSibling();
819		_t = __t57;
#	Line 881 | Line 823 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
823		blockStack.top()->validate();
824		blockStack.pop();
825		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
826	+	currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
827	+
828	+	#line 829 "MDTreeParser.cpp"
829	+	}
830	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
831	+	reportError(ex);
832	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
833	+	_t = _t->getNextSibling();
834	+	}
835	+	_retTree = _t;
836	+	}
837	+
838	+	void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _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 __t63 = _t;
843	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
844	+	match(_t,CUTOFFGROUP);
845	+	_t = _t->getFirstChild();
846	+	#line 218 "MDTreeParser.g"
847	+	CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848	+	#line 849 "MDTreeParser.cpp"
849	+	{ // ( ... )*
850	+	for (;;) {
851	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
852	+	_t = ASTNULL;
853	+	if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
854	+	cutoffgroupstatement(_t);
855	+	_t = _retTree;
856	+	}
857	+	else {
858	+	goto _loop65;
859	+	}
860	+
861	+	}
862	+	_loop65:;
863	+	} // ( ... )*
864	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865	+	match(_t,ENDBLOCK);
866	+	_t = _t->getNextSibling();
867	+	_t = __t63;
868	+	_t = _t->getNextSibling();
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 887 "MDTreeParser.cpp"
876	>	#line 877 "MDTreeParser.cpp"
877		}
878		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
879		reportError(ex);
#	Line 894 | 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 218 "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 901 "MDTreeParser.cpp"
890	>	#line 891 "MDTreeParser.cpp"
891
892		try {      // for error handling
893	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_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 219 "MDTreeParser.g"
899	>	#line 238 "MDTreeParser.g"
900		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901	<	#line 912 "MDTreeParser.cpp"
901	>	#line 902 "MDTreeParser.cpp"
902		{ // ( ... )*
903		for (;;) {
904		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 918 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
908		_t = _retTree;
909		}
910		else {
911	<	goto _loop65;
911	>	goto _loop71;
912		}
913
914		}
915	<	_loop65:;
915	>	_loop71:;
916		} // ( ... )*
917	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
917	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918		match(_t,ENDBLOCK);
919		_t = _t->getNextSibling();
920	<	_t = __t63;
920	>	_t = __t69;
921		_t = _t->getNextSibling();
922	<	#line 221 "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 940 "MDTreeParser.cpp"
929	>	#line 930 "MDTreeParser.cpp"
930		}
931		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
932		reportError(ex);
#	Line 947 | 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;
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 958 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948
949		try {      // for error handling
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 969 | Line 959 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
959		case POSITION:
960		{
961		ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
962	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
962	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
963		match(_t,POSITION);
964		_t = _t->getFirstChild();
965	<	dvec=signedNumberTuple(_t);
965	>	dvec=doubleNumberTuple(_t);
966		_t = _retTree;
967		_t = __t30;
968		_t = _t->getNextSibling();
969		#line 115 "MDTreeParser.g"
970		currAtomStamp->setPosition(dvec);
971	<	#line 982 "MDTreeParser.cpp"
971	>	#line 972 "MDTreeParser.cpp"
972		break;
973		}
974		case ORIENTATION:
975		{
976		ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
977	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
977	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978		match(_t,ORIENTATION);
979		_t = _t->getFirstChild();
980	<	dvec=signedNumberTuple(_t);
980	>	dvec=doubleNumberTuple(_t);
981		_t = _retTree;
982		_t = __t31;
983		_t = _t->getNextSibling();
984		#line 116 "MDTreeParser.g"
985		currAtomStamp->setOrientation(dvec);
986	<	#line 997 "MDTreeParser.cpp"
986	>	#line 987 "MDTreeParser.cpp"
987		break;
988		}
989		default:
#	Line 1010 | Line 1000 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1000		_retTree = _t;
1001		}
1002
1003	<	vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004	<	#line 234 "MDTreeParser.g"
1005	<	vector<double> dvec;
1006	<	#line 1017 "MDTreeParser.cpp"
1007	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008	<	#line 234 "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 1023 "MDTreeParser.cpp"
1012	>	#line 1013 "MDTreeParser.cpp"
1013
1014		try {      // for error handling
1015		{ // ( ... )+
1016	<	int _cnt69=0;
1016	>	int _cnt75=0;
1017		for (;;) {
1018		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1019		_t = ASTNULL;
1020	<	if ((_tokenSet_2.member(_t->getType()))) {
1021	<	dval=signedNumber(_t);
1020	>	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1021	>	dval=doubleNumber(_t);
1022		_t = _retTree;
1023	<	#line 238 "MDTreeParser.g"
1023	>	#line 257 "MDTreeParser.g"
1024		dvec.push_back(dval);
1025	<	#line 1036 "MDTreeParser.cpp"
1025	>	#line 1026 "MDTreeParser.cpp"
1026		}
1027		else {
1028	<	if ( _cnt69>=1 ) { goto _loop69; } 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	<	_cnt69++;
1031	>	_cnt75++;
1032		}
1033	<	_loop69:;
1033	>	_loop75:;
1034		}  // ( ... )+
1035		}
1036		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1053 | 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;
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 1063 "MDTreeParser.cpp"
1052	>	#line 1053 "MDTreeParser.cpp"
1053
1054		try {      // for error handling
1055		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1074 | Line 1064 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1064		case MEMBERS:
1065		{
1066		ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1067	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1067	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1068		match(_t,MEMBERS);
1069		_t = _t->getFirstChild();
1070		ivec=inttuple(_t);
#	Line 1083 | Line 1073 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1073		_t = _t->getNextSibling();
1074		#line 135 "MDTreeParser.g"
1075		currBondStamp->setMembers(ivec);
1076	<	#line 1087 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		break;
1078		}
1079		default:
#	Line 1101 | Line 1091 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1091		}
1092
1093		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1094	<	#line 241 "MDTreeParser.g"
1094	>	#line 260 "MDTreeParser.g"
1095		vector<int> ivec;
1096	<	#line 1107 "MDTreeParser.cpp"
1097	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098	<	#line 241 "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 1113 "MDTreeParser.cpp"
1102	>	#line 1103 "MDTreeParser.cpp"
1103
1104		try {      // for error handling
1105		{ // ( ... )+
1106	<	int _cnt72=0;
1106	>	int _cnt78=0;
1107		for (;;) {
1108		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1109		_t = ASTNULL;
1110	<	if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1110	>	if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1111		ival=intConst(_t);
1112		_t = _retTree;
1113	<	#line 245 "MDTreeParser.g"
1113	>	#line 264 "MDTreeParser.g"
1114		ivec.push_back(ival);
1115	<	#line 1126 "MDTreeParser.cpp"
1115	>	#line 1116 "MDTreeParser.cpp"
1116		}
1117		else {
1118	<	if ( _cnt72>=1 ) { goto _loop72; } 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	<	_cnt72++;
1121	>	_cnt78++;
1122		}
1123	<	_loop72:;
1123	>	_loop78:;
1124		}  // ( ... )+
1125		}
1126		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1143 | 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;
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 1153 "MDTreeParser.cpp"
1142	>	#line 1143 "MDTreeParser.cpp"
1143
1144		try {      // for error handling
1145		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1164 | Line 1154 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1154		case MEMBERS:
1155		{
1156		ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1157	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1157	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1158		match(_t,MEMBERS);
1159		_t = _t->getFirstChild();
1160		ivec=inttuple(_t);
#	Line 1173 | Line 1163 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1163		_t = _t->getNextSibling();
1164		#line 154 "MDTreeParser.g"
1165		currBendStamp->setMembers(ivec);
1166	<	#line 1177 "MDTreeParser.cpp"
1166	>	#line 1167 "MDTreeParser.cpp"
1167		break;
1168		}
1169		default:
#	Line 1191 | 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;
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 1201 "MDTreeParser.cpp"
1190	>	#line 1191 "MDTreeParser.cpp"
1191
1192		try {      // for error handling
1193		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1212 | Line 1202 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1202		case MEMBERS:
1203		{
1204		ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1205	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1205	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1206		match(_t,MEMBERS);
1207		_t = _t->getFirstChild();
1208		ivec=inttuple(_t);
#	Line 1221 | Line 1211 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1211		_t = _t->getNextSibling();
1212		#line 173 "MDTreeParser.g"
1213		currTorsionStamp->setMembers(ivec);
1214	<	#line 1225 "MDTreeParser.cpp"
1214	>	#line 1215 "MDTreeParser.cpp"
1215		break;
1216		}
1217		default:
#	Line 1238 | Line 1228 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1228		_retTree = _t;
1229		}
1230
1231	<	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1232	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1233	<	#line 190 "MDTreeParser.g"
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	<	vector<int> ivec;
1236	<	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1235	>	int icent;
1236	>	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1237
1238	<	#line 1249 "MDTreeParser.cpp"
1238	>	#line 1239 "MDTreeParser.cpp"
1239
1240		try {      // for error handling
1241		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1257 | Line 1247 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1247		_t = _retTree;
1248		break;
1249		}
1250	<	case MEMBERS:
1250	>	case CENTER:
1251		{
1252		ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1253	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1254	<	match(_t,MEMBERS);
1253	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1254	>	match(_t,CENTER);
1255		_t = _t->getFirstChild();
1256	<	ivec=inttuple(_t);
1256	>	icent=intConst(_t);
1257		_t = _retTree;
1258		_t = __t55;
1259		_t = _t->getNextSibling();
1260	<	#line 196 "MDTreeParser.g"
1261	<	currRigidBodyStamp->setMembers(ivec);
1262	<	#line 1273 "MDTreeParser.cpp"
1260	>	#line 192 "MDTreeParser.g"
1261	>	currInversionStamp->setCenter(icent);
1262	>	#line 1263 "MDTreeParser.cpp"
1263		break;
1264		}
1265		default:
#	Line 1286 | Line 1276 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1276		_retTree = _t;
1277		}
1278
1279	<	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1279	>	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281		#line 209 "MDTreeParser.g"
1282
1283		vector<int> ivec;
1284	<	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1284	>	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1285
1286	<	#line 1297 "MDTreeParser.cpp"
1286	>	#line 1287 "MDTreeParser.cpp"
1287
1288		try {      // for error handling
1289		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1308 | Line 1298 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1298		case MEMBERS:
1299		{
1300		ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1301	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1301	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1302		match(_t,MEMBERS);
1303		_t = _t->getFirstChild();
1304		ivec=inttuple(_t);
#	Line 1316 | Line 1306 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1306		_t = __t61;
1307		_t = _t->getNextSibling();
1308		#line 215 "MDTreeParser.g"
1309	+	currRigidBodyStamp->setMembers(ivec);
1310	+	#line 1311 "MDTreeParser.cpp"
1311	+	break;
1312	+	}
1313	+	default:
1314	+	{
1315	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1316	+	}
1317	+	}
1318	+	}
1319	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1320	+	reportError(ex);
1321	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1322	+	_t = _t->getNextSibling();
1323	+	}
1324	+	_retTree = _t;
1325	+	}
1326	+
1327	+	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328	+	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	+	#line 228 "MDTreeParser.g"
1330	+
1331	+	vector<int> ivec;
1332	+	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1333	+
1334	+	#line 1335 "MDTreeParser.cpp"
1335	+
1336	+	try {      // for error handling
1337	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338	+	_t = ASTNULL;
1339	+	switch ( _t->getType()) {
1340	+	case ASSIGNEQUAL:
1341	+	{
1342	+	assignment(_t);
1343	+	_t = _retTree;
1344	+	break;
1345	+	}
1346	+	case MEMBERS:
1347	+	{
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 = __t67;
1355	+	_t = _t->getNextSibling();
1356	+	#line 234 "MDTreeParser.g"
1357		currCutoffGroupStamp->setMembers(ivec);
1358	<	#line 1321 "MDTreeParser.cpp"
1358	>	#line 1359 "MDTreeParser.cpp"
1359		break;
1360		}
1361		default:
#	Line 1335 | 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 1349 | Line 1387 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1387		_retTree = _t;
1388		}
1389
1390	<	double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391	<	#line 256 "MDTreeParser.g"
1392	<	double dval;
1393	<	#line 1356 "MDTreeParser.cpp"
1394	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357	<	ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
1358	<	ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
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 1363 | Line 1399 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1399		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1400		_t = ASTNULL;
1401		switch ( _t->getType()) {
1402	<	case MINUS:
1402	>	case NUM_INT:
1403	>	case NUM_LONG:
1404		{
1405	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1406	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1407	<	match(_t,MINUS);
1408	<	_t = _t->getFirstChild();
1409	<	{
1410	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1374	<	_t = ASTNULL;
1375	<	switch ( _t->getType()) {
1376	<	case OCTALINT:
1377	<	case DECIMALINT:
1378	<	case HEXADECIMALINT:
1379	<	{
1380	<	icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1381	<	intConst(_t);
1382	<	_t = _retTree;
1383	<	#line 257 "MDTreeParser.g"
1384	<	dval = lexi_cast<double>(icMinus->getText()); dval = -dval;
1385	<	#line 1386 "MDTreeParser.cpp"
1386	<	break;
1387	<	}
1388	<	case FLOATONE:
1389	<	case FLOATTWO:
1390	<	{
1391	<	fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1392	<	floatConst(_t);
1393	<	_t = _retTree;
1394	<	break;
1395	<	}
1396	<	default:
1397	<	{
1398	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1399	<	}
1400	<	}
1401	<	}
1402	<	#line 258 "MDTreeParser.g"
1403	<	dval = lexi_cast<double>(fcMinus->getText());dval = -dval;
1404	<	#line 1405 "MDTreeParser.cpp"
1405	<	_t = __t75;
1406	<	_t = _t->getNextSibling();
1405	>	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406	>	intConst(_t);
1407	>	_t = _retTree;
1408	>	#line 276 "MDTreeParser.g"
1409	>	dval = lexi_cast<RealType>(ic->getText());
1410	>	#line 1411 "MDTreeParser.cpp"
1411		break;
1412		}
1413	<	case OCTALINT:
1414	<	case DECIMALINT:
1411	<	case HEXADECIMALINT:
1412	<	case FLOATONE:
1413	<	case FLOATTWO:
1413	>	case NUM_FLOAT:
1414	>	case NUM_DOUBLE:
1415		{
1416	<	{
1417	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1418	<	_t = ASTNULL;
1419	<	switch ( _t->getType()) {
1420	<	case OCTALINT:
1421	<	case DECIMALINT:
1421	<	case HEXADECIMALINT:
1422	<	{
1423	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1424	<	intConst(_t);
1425	<	_t = _retTree;
1426	<	#line 260 "MDTreeParser.g"
1427	<	dval = lexi_cast<double>(ic->getText());
1428	<	#line 1429 "MDTreeParser.cpp"
1429	<	break;
1430	<	}
1431	<	case FLOATONE:
1432	<	case FLOATTWO:
1433	<	{
1434	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1435	<	floatConst(_t);
1436	<	_t = _retTree;
1437	<	#line 261 "MDTreeParser.g"
1438	<	dval = lexi_cast<double>(fc->getText());
1439	<	#line 1440 "MDTreeParser.cpp"
1440	<	break;
1441	<	}
1442	<	default:
1443	<	{
1444	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1445	<	}
1446	<	}
1447	<	}
1416	>	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417	>	floatConst(_t);
1418	>	_t = _retTree;
1419	>	#line 277 "MDTreeParser.g"
1420	>	dval = lexi_cast<RealType>(fc->getText());
1421	>	#line 1422 "MDTreeParser.cpp"
1422		break;
1423		}
1424		default:
#	Line 1473 | 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 1495 | Line 1472 | const char* MDTreeParser::tokenNames[] = {
1472		"LPAREN",
1473		"RPAREN",
1474		"COMMA",
1475	<	"OCTALINT",
1476	<	"DECIMALINT",
1477	<	"HEXADECIMALINT",
1478	<	"PLUS",
1502	<	"MINUS",
1503	<	"FLOATONE",
1504	<	"FLOATTWO",
1475	>	"NUM_INT",
1476	>	"NUM_LONG",
1477	>	"NUM_FLOAT",
1478	>	"NUM_DOUBLE",
1479		"DOT",
1480		"COLON",
1481		"QUESTIONMARK",
#	Line 1514 | Line 1488 | const char* MDTreeParser::tokenNames[] = {
1488		"CharLiteral",
1489		"EndOfLine",
1490		"Escape",
1491	+	"Vocabulary",
1492		"Digit",
1493		"Decimal",
1494	<	"LongSuffix",
1495	<	"UnsignedSuffix",
1496	<	"FloatSuffix",
1522	<	"Exponent",
1523	<	"Vocabulary",
1524	<	"Number",
1494	>	"HEX_DIGIT",
1495	>	"EXPONENT",
1496	>	"FLOAT_SUFFIX",
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);
1535	–	const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 3758096384UL, 14UL, 0UL, 0UL };
1536	–	// OCTALINT DECIMALINT HEXADECIMALINT MINUS FLOATONE FLOATTWO
1537	–	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);
1507
1508

Comparing trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1558 by gezelter, Wed May 11 16:32:48 2011 UTC

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

Diff Legend

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