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 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20140107): "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	+	case MINIMIZER:
96	+	{
97	+	minimizerblock(_t);
98	+	_t = _retTree;
99	+	break;
100	+	}
101		default:
102		{
103		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 89 | Line 113 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl
113		}
114
115		void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
116	<	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
116	>	ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
117		ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
118
119		try {      // for error handling
#	Line 114 | Line 138 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
138		}
139
140		void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
141	<	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
141	>	ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
142
143		try {      // for error handling
144	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
144	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
145		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146		match(_t,COMPONENT);
147		_t = _t->getFirstChild();
148	<	#line 69 "MDTreeParser.g"
148	>	#line 72 "MDTreeParser.g"
149		Component* currComponet = new Component(); blockStack.push(currComponet);
150	<	#line 127 "MDTreeParser.cpp"
150	>	#line 151 "MDTreeParser.cpp"
151		{ // ( ... )*
152		for (;;) {
153		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 133 | Line 157 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
157		_t = _retTree;
158		}
159		else {
160	<	goto _loop15;
160	>	goto _loop12;
161		}
162
163		}
164	<	_loop15:;
164	>	_loop12:;
165		} // ( ... )*
166		ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167		match(_t,ENDBLOCK);
168		_t = _t->getNextSibling();
169	<	_t = __t13;
169	>	_t = __t10;
170		_t = _t->getNextSibling();
171	<	#line 71 "MDTreeParser.g"
171	>	#line 74 "MDTreeParser.g"
172		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173	<	#line 150 "MDTreeParser.cpp"
173	>	#line 174 "MDTreeParser.cpp"
174		}
175		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176		reportError(ex);
#	Line 157 | Line 181 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
181		}
182
183		void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
184	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
184	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
185
186		try {      // for error handling
187	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
187	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
188		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189		match(_t,MOLECULE);
190		_t = _t->getFirstChild();
191	<	#line 79 "MDTreeParser.g"
191	>	#line 103 "MDTreeParser.g"
192		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193	<	#line 170 "MDTreeParser.cpp"
193	>	#line 194 "MDTreeParser.cpp"
194		{ // ( ... )*
195		for (;;) {
196		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 176 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200		_t = _retTree;
201		}
202		else {
203	<	goto _loop23;
203	>	goto _loop36;
204		}
205
206		}
207	<	_loop23:;
207	>	_loop36:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t21;
212	>	_t = __t34;
213		_t = _t->getNextSibling();
214	<	#line 81 "MDTreeParser.g"
214	>	#line 105 "MDTreeParser.g"
215		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216	<	#line 193 "MDTreeParser.cpp"
216	>	#line 217 "MDTreeParser.cpp"
217		}
218		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219		reportError(ex);
#	Line 200 | Line 224 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
224		}
225
226		void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
227	<	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
227	>	ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
228
229		try {      // for error handling
230	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
230	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t;
231		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232		match(_t,ZCONSTRAINT);
233		_t = _t->getFirstChild();
234	<	#line 74 "MDTreeParser.g"
234	>	#line 77 "MDTreeParser.g"
235		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236	<	#line 213 "MDTreeParser.cpp"
236	>	#line 237 "MDTreeParser.cpp"
237		{ // ( ... )*
238		for (;;) {
239		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 219 | Line 243 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
243		_t = _retTree;
244		}
245		else {
246	<	goto _loop19;
246	>	goto _loop16;
247		}
248
249		}
250	<	_loop19:;
250	>	_loop16:;
251		} // ( ... )*
252		ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253		match(_t,ENDBLOCK);
254		_t = _t->getNextSibling();
255	<	_t = __t17;
255	>	_t = __t14;
256		_t = _t->getNextSibling();
257	<	#line 76 "MDTreeParser.g"
257	>	#line 79 "MDTreeParser.g"
258		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259	<	#line 236 "MDTreeParser.cpp"
259	>	#line 260 "MDTreeParser.cpp"
260		}
261		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262		reportError(ex);
#	Line 242 | Line 266 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
266		_retTree = _t;
267		}
268
269	+	void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
270	+	ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
271	+
272	+	try {      // for error handling
273	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t18 = _t;
274	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275	+	match(_t,RESTRAINT);
276	+	_t = _t->getFirstChild();
277	+	#line 82 "MDTreeParser.g"
278	+	RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279	+	#line 280 "MDTreeParser.cpp"
280	+	{ // ( ... )*
281	+	for (;;) {
282	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
283	+	_t = ASTNULL;
284	+	if ((_t->getType() == ASSIGNEQUAL)) {
285	+	assignment(_t);
286	+	_t = _retTree;
287	+	}
288	+	else {
289	+	goto _loop20;
290	+	}
291	+
292	+	}
293	+	_loop20:;
294	+	} // ( ... )*
295	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296	+	match(_t,ENDBLOCK);
297	+	_t = _t->getNextSibling();
298	+	_t = __t18;
299	+	_t = _t->getNextSibling();
300	+	#line 84 "MDTreeParser.g"
301	+	blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302	+	#line 303 "MDTreeParser.cpp"
303	+	}
304	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305	+	reportError(ex);
306	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
307	+	_t = _t->getNextSibling();
308	+	}
309	+	_retTree = _t;
310	+	}
311	+
312	+	void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
313	+	ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
314	+
315	+	try {      // for error handling
316	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
317	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318	+	match(_t,FLUCQ);
319	+	_t = _t->getFirstChild();
320	+	#line 87 "MDTreeParser.g"
321	+	FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322	+	#line 323 "MDTreeParser.cpp"
323	+	{ // ( ... )*
324	+	for (;;) {
325	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
326	+	_t = ASTNULL;
327	+	if ((_t->getType() == ASSIGNEQUAL)) {
328	+	assignment(_t);
329	+	_t = _retTree;
330	+	}
331	+	else {
332	+	goto _loop24;
333	+	}
334	+
335	+	}
336	+	_loop24:;
337	+	} // ( ... )*
338	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339	+	match(_t,ENDBLOCK);
340	+	_t = _t->getNextSibling();
341	+	_t = __t22;
342	+	_t = _t->getNextSibling();
343	+	#line 89 "MDTreeParser.g"
344	+	blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345	+	#line 346 "MDTreeParser.cpp"
346	+	}
347	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348	+	reportError(ex);
349	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
350	+	_t = _t->getNextSibling();
351	+	}
352	+	_retTree = _t;
353	+	}
354	+
355	+	void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
356	+	ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
357	+
358	+	try {      // for error handling
359	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
360	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361	+	match(_t,RNEMD);
362	+	_t = _t->getFirstChild();
363	+	#line 92 "MDTreeParser.g"
364	+	RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365	+	#line 366 "MDTreeParser.cpp"
366	+	{ // ( ... )*
367	+	for (;;) {
368	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
369	+	_t = ASTNULL;
370	+	if ((_t->getType() == ASSIGNEQUAL)) {
371	+	assignment(_t);
372	+	_t = _retTree;
373	+	}
374	+	else {
375	+	goto _loop28;
376	+	}
377	+
378	+	}
379	+	_loop28:;
380	+	} // ( ... )*
381	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382	+	match(_t,ENDBLOCK);
383	+	_t = _t->getNextSibling();
384	+	_t = __t26;
385	+	_t = _t->getNextSibling();
386	+	#line 94 "MDTreeParser.g"
387	+	blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388	+	#line 389 "MDTreeParser.cpp"
389	+	}
390	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
391	+	reportError(ex);
392	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
393	+	_t = _t->getNextSibling();
394	+	}
395	+	_retTree = _t;
396	+	}
397	+
398	+	void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
399	+	ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
400	+
401	+	try {      // for error handling
402	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
403	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404	+	match(_t,MINIMIZER);
405	+	_t = _t->getFirstChild();
406	+	#line 97 "MDTreeParser.g"
407	+	MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408	+	#line 409 "MDTreeParser.cpp"
409	+	{ // ( ... )*
410	+	for (;;) {
411	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
412	+	_t = ASTNULL;
413	+	if ((_t->getType() == ASSIGNEQUAL)) {
414	+	assignment(_t);
415	+	_t = _retTree;
416	+	}
417	+	else {
418	+	goto _loop32;
419	+	}
420	+
421	+	}
422	+	_loop32:;
423	+	} // ( ... )*
424	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425	+	match(_t,ENDBLOCK);
426	+	_t = _t->getNextSibling();
427	+	_t = __t30;
428	+	_t = _t->getNextSibling();
429	+	#line 99 "MDTreeParser.g"
430	+	blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431	+	#line 432 "MDTreeParser.cpp"
432	+	}
433	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
434	+	reportError(ex);
435	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
436	+	_t = _t->getNextSibling();
437	+	}
438	+	_retTree = _t;
439	+	}
440	+
441		void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
442		ANTLR_USE_NAMESPACE(antlr)RefAST id
443		) {
444	<	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
444	>	ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445		ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446		ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447	+	#line 50 "MDTreeParser.g"
448
449	+	int ival;
450	+	RealType dval, x, y, z;
451	+	Vector3d dvec;
452	+
453	+	#line 454 "MDTreeParser.cpp"
454	+
455		try {      // for error handling
456		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
457		_t = ASTNULL;
458		switch ( _t->getType()) {
459	<	case OCTALINT:
460	<	case DECIMALINT:
258	<	case HEXADECIMALINT:
259	<	case MINUS:
260	<	case FLOATONE:
261	<	case FLOATTWO:
459	>	case NUM_INT:
460	>	case NUM_LONG:
461		{
462	<	signedIntOrFloat(_t,id);
462	>	ival=intConst(_t);
463		_t = _retTree;
464	+	#line 56 "MDTreeParser.g"
465	+	blockStack.top()->assign(id->getText(), ival);
466	+	#line 467 "MDTreeParser.cpp"
467		break;
468		}
469	+	case NUM_FLOAT:
470	+	case NUM_DOUBLE:
471	+	{
472	+	dval=floatConst(_t);
473	+	_t = _retTree;
474	+	#line 57 "MDTreeParser.g"
475	+	blockStack.top()->assign(id->getText(), dval);
476	+	#line 477 "MDTreeParser.cpp"
477	+	break;
478	+	}
479	+	case LPAREN:
480	+	{
481	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
482	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
483	+	match(_t,LPAREN);
484	+	_t = _t->getFirstChild();
485	+	x=doubleNumber(_t);
486	+	_t = _retTree;
487	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
488	+	match(_t,COMMA);
489	+	_t = _t->getNextSibling();
490	+	y=doubleNumber(_t);
491	+	_t = _retTree;
492	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
493	+	match(_t,COMMA);
494	+	_t = _t->getNextSibling();
495	+	z=doubleNumber(_t);
496	+	_t = _retTree;
497	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
498	+	match(_t,RPAREN);
499	+	_t = _t->getNextSibling();
500	+	_t = __t8;
501	+	_t = _t->getNextSibling();
502	+	#line 59 "MDTreeParser.g"
503	+	dvec.x() = x;
504	+	dvec.y() = y;
505	+	dvec.z() = z;
506	+	blockStack.top()->assign(id->getText(), dvec);
507	+
508	+	#line 509 "MDTreeParser.cpp"
509	+	break;
510	+	}
511		case ID:
512		{
513		str1 = _t;
514		match(_t,ID);
515		_t = _t->getNextSibling();
516	<	#line 49 "MDTreeParser.g"
516	>	#line 64 "MDTreeParser.g"
517		blockStack.top()->assign(id->getText(), str1->getText());
518	<	#line 275 "MDTreeParser.cpp"
518	>	#line 519 "MDTreeParser.cpp"
519		break;
520		}
521		case StringLiteral:
#	Line 279 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523		str2 = _t;
524		match(_t,StringLiteral);
525		_t = _t->getNextSibling();
526	<	#line 50 "MDTreeParser.g"
526	>	#line 65 "MDTreeParser.g"
527		std::string s =  str2->getText();
528		s = s.substr(1, s.length()-2);
529		blockStack.top()->assign(id->getText(),s);
530
531	<	#line 288 "MDTreeParser.cpp"
531	>	#line 532 "MDTreeParser.cpp"
532		break;
533		}
534		default:
#	Line 301 | Line 545 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
545		_retTree = _t;
546		}
547
548	<	void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
549	<	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	<
548	>	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549	>	#line 314 "MDTreeParser.g"
550		int ival;
551	<	double dval;
552	<
553	<	#line 318 "MDTreeParser.cpp"
551	>	#line 552 "MDTreeParser.cpp"
552	>	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
553	>	ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
554	>	ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
555
556		try {      // for error handling
557		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
558		_t = ASTNULL;
559		switch ( _t->getType()) {
560	<	case MINUS:
560	>	case NUM_INT:
561		{
562	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
563	<	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;
562	>	i1 = _t;
563	>	match(_t,NUM_INT);
564		_t = _t->getNextSibling();
565	+	#line 315 "MDTreeParser.g"
566	+	ival = lexi_cast<int>(i1->getText());
567	+	#line 568 "MDTreeParser.cpp"
568		break;
569		}
570	<	case OCTALINT:
367	<	case DECIMALINT:
368	<	case HEXADECIMALINT:
369	<	case FLOATONE:
370	<	case FLOATTWO:
570	>	case NUM_LONG:
571		{
572	<	{
573	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
574	<	_t = ASTNULL;
575	<	switch ( _t->getType()) {
576	<	case OCTALINT:
577	<	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	<	}
572	>	i2 = _t;
573	>	match(_t,NUM_LONG);
574	>	_t = _t->getNextSibling();
575	>	#line 316 "MDTreeParser.g"
576	>	ival = lexi_cast<int>(i2->getText());
577	>	#line 578 "MDTreeParser.cpp"
578		break;
579		}
580		default:
#	Line 416 | Line 589 | void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPAC
589		_t = _t->getNextSibling();
590		}
591		_retTree = _t;
592	+	return ival;
593		}
594
595	<	int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596	<	#line 249 "MDTreeParser.g"
597	<	int ival;
598	<	#line 425 "MDTreeParser.cpp"
599	<	ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
600	<	ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
601	<	ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
428	<	ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
595	>	RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596	>	#line 326 "MDTreeParser.g"
597	>	RealType dval;
598	>	#line 599 "MDTreeParser.cpp"
599	>	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
600	>	ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
601	>	ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
602
603		try {      // for error handling
604		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
605		_t = ASTNULL;
606		switch ( _t->getType()) {
607	<	case OCTALINT:
607	>	case NUM_FLOAT:
608		{
609	<	oival = _t;
610	<	match(_t,OCTALINT);
609	>	d1 = _t;
610	>	match(_t,NUM_FLOAT);
611		_t = _t->getNextSibling();
612	<	#line 250 "MDTreeParser.g"
613	<	ival = lexi_cast<int>(oival->getText());
614	<	#line 442 "MDTreeParser.cpp"
612	>	#line 327 "MDTreeParser.g"
613	>	dval = lexi_cast<RealType>(d1->getText());
614	>	#line 615 "MDTreeParser.cpp"
615		break;
616		}
617	<	case DECIMALINT:
617	>	case NUM_DOUBLE:
618		{
619	<	dival = _t;
620	<	match(_t,DECIMALINT);
619	>	d2 = _t;
620	>	match(_t,NUM_DOUBLE);
621		_t = _t->getNextSibling();
622	<	#line 251 "MDTreeParser.g"
623	<	ival = lexi_cast<int>(dival->getText());
624	<	#line 452 "MDTreeParser.cpp"
622	>	#line 328 "MDTreeParser.g"
623	>	dval = lexi_cast<RealType>(d2->getText());
624	>	#line 625 "MDTreeParser.cpp"
625		break;
626		}
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	–	}
627		default:
628		{
629		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 473 | Line 636 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
636		_t = _t->getNextSibling();
637		}
638		_retTree = _t;
639	<	return ival;
639	>	return dval;
640		}
641
642	<	double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643	<	#line 266 "MDTreeParser.g"
644	<	double dval;
645	<	#line 483 "MDTreeParser.cpp"
646	<	ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647	<	ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
648	<	ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
642	>	RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643	>	#line 320 "MDTreeParser.g"
644	>	RealType dval;
645	>	#line 646 "MDTreeParser.cpp"
646	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647	>	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
648	>	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
649
650		try {      // for error handling
651		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
652		_t = ASTNULL;
653		switch ( _t->getType()) {
654	<	case FLOATONE:
654	>	case NUM_INT:
655	>	case NUM_LONG:
656		{
657	<	d1 = _t;
658	<	match(_t,FLOATONE);
659	<	_t = _t->getNextSibling();
660	<	#line 267 "MDTreeParser.g"
661	<	dval = lexi_cast<double>(d1->getText());
662	<	#line 499 "MDTreeParser.cpp"
657	>	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658	>	intConst(_t);
659	>	_t = _retTree;
660	>	#line 321 "MDTreeParser.g"
661	>	dval = lexi_cast<RealType>(ic->getText());
662	>	#line 663 "MDTreeParser.cpp"
663		break;
664		}
665	<	case FLOATTWO:
665	>	case NUM_FLOAT:
666	>	case NUM_DOUBLE:
667		{
668	<	d2 = _t;
669	<	match(_t,FLOATTWO);
670	<	_t = _t->getNextSibling();
671	<	#line 268 "MDTreeParser.g"
672	<	dval = lexi_cast<double>(d2->getText());
673	<	#line 509 "MDTreeParser.cpp"
668	>	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669	>	floatConst(_t);
670	>	_t = _retTree;
671	>	#line 322 "MDTreeParser.g"
672	>	dval = lexi_cast<RealType>(fc->getText());
673	>	#line 674 "MDTreeParser.cpp"
674		break;
675		}
676		default:
#	Line 524 | Line 689 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
689		}
690
691		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
692	<	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
692	>	ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
693
694		try {      // for error handling
695		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 560 | Line 725 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
725		_t = _retTree;
726		break;
727		}
728	+	case INVERSION:
729	+	{
730	+	inversionblock(_t);
731	+	_t = _retTree;
732	+	break;
733	+	}
734		case RIGIDBODY:
735		{
736		rigidbodyblock(_t);
#	Line 578 | Line 749 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
749		_t = _retTree;
750		break;
751		}
752	+	case CONSTRAINT:
753	+	{
754	+	constraintblock(_t);
755	+	_t = _retTree;
756	+	break;
757	+	}
758		default:
759		{
760		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 593 | Line 770 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
770		}
771
772		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
773	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
774	<	#line 94 "MDTreeParser.g"
773	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
774	>	#line 120 "MDTreeParser.g"
775
776		int index;
777
778	<	#line 602 "MDTreeParser.cpp"
778	>	#line 779 "MDTreeParser.cpp"
779
780		try {      // for error handling
781	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
782	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
781	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
782	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
783		match(_t,ATOM);
784		_t = _t->getFirstChild();
785		index=intConst(_t);
786		_t = _retTree;
787	<	#line 98 "MDTreeParser.g"
787	>	#line 124 "MDTreeParser.g"
788		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
789	<	#line 613 "MDTreeParser.cpp"
789	>	#line 790 "MDTreeParser.cpp"
790		{ // ( ... )*
791		for (;;) {
792		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 619 | Line 796 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
796		_t = _retTree;
797		}
798		else {
799	<	goto _loop28;
799	>	goto _loop41;
800		}
801
802		}
803	<	_loop28:;
803	>	_loop41:;
804		} // ( ... )*
805	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
805	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
806		match(_t,ENDBLOCK);
807		_t = _t->getNextSibling();
808	<	_t = __t26;
808	>	_t = __t39;
809		_t = _t->getNextSibling();
810	<	#line 100 "MDTreeParser.g"
810	>	#line 126 "MDTreeParser.g"
811
812		blockStack.top()->validate();
813		blockStack.pop();
814		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
815		currMoleculeStamp->addAtomStamp(currAtomStamp);
816
817	<	#line 641 "MDTreeParser.cpp"
817	>	#line 818 "MDTreeParser.cpp"
818		}
819		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
820		reportError(ex);
#	Line 648 | Line 825 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
825		}
826
827		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
828	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
828	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
829
830		try {      // for error handling
831	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
832	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
831	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
832	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
833		match(_t,BOND);
834		_t = _t->getFirstChild();
835	<	#line 120 "MDTreeParser.g"
835	>	#line 146 "MDTreeParser.g"
836		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
837	<	#line 661 "MDTreeParser.cpp"
837	>	#line 838 "MDTreeParser.cpp"
838		{ // ( ... )*
839		for (;;) {
840		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 667 | Line 844 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
844		_t = _retTree;
845		}
846		else {
847	<	goto _loop35;
847	>	goto _loop48;
848		}
849
850		}
851	<	_loop35:;
851	>	_loop48:;
852		} // ( ... )*
853	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
853	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
854		match(_t,ENDBLOCK);
855		_t = _t->getNextSibling();
856	<	_t = __t33;
856	>	_t = __t46;
857		_t = _t->getNextSibling();
858	<	#line 122 "MDTreeParser.g"
858	>	#line 148 "MDTreeParser.g"
859
860		blockStack.pop();
861		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
862		currMoleculeStamp->addBondStamp(currBondStamp);
863
864	<	#line 688 "MDTreeParser.cpp"
864	>	#line 865 "MDTreeParser.cpp"
865		}
866		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
867		reportError(ex);
#	Line 695 | Line 872 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
872		}
873
874		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
875	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
875	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
876
877		try {      // for error handling
878	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
879	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
878	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
879	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
880		match(_t,BEND);
881		_t = _t->getFirstChild();
882	<	#line 138 "MDTreeParser.g"
882	>	#line 164 "MDTreeParser.g"
883		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
884	<	#line 708 "MDTreeParser.cpp"
884	>	#line 885 "MDTreeParser.cpp"
885		{ // ( ... )*
886		for (;;) {
887		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 714 | Line 891 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
891		_t = _retTree;
892		}
893		else {
894	<	goto _loop41;
894	>	goto _loop54;
895		}
896
897		}
898	<	_loop41:;
898	>	_loop54:;
899		} // ( ... )*
900	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
900	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
901		match(_t,ENDBLOCK);
902		_t = _t->getNextSibling();
903	<	_t = __t39;
903	>	_t = __t52;
904		_t = _t->getNextSibling();
905	<	#line 140 "MDTreeParser.g"
905	>	#line 166 "MDTreeParser.g"
906
907		blockStack.top()->validate();
908		blockStack.pop();
909		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
910		currMoleculeStamp->addBendStamp(currBendStamp);
911
912	<	#line 736 "MDTreeParser.cpp"
912	>	#line 913 "MDTreeParser.cpp"
913		}
914		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
915		reportError(ex);
#	Line 743 | Line 920 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
920		}
921
922		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
923	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
923	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
924
925		try {      // for error handling
926	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
927	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
926	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
927	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
928		match(_t,TORSION);
929		_t = _t->getFirstChild();
930	<	#line 157 "MDTreeParser.g"
930	>	#line 183 "MDTreeParser.g"
931		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
932	<	#line 756 "MDTreeParser.cpp"
932	>	#line 933 "MDTreeParser.cpp"
933		{ // ( ... )*
934		for (;;) {
935		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 762 | Line 939 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
939		_t = _retTree;
940		}
941		else {
942	<	goto _loop47;
942	>	goto _loop60;
943		}
944
945		}
946	<	_loop47:;
946	>	_loop60:;
947		} // ( ... )*
948	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
948	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
949		match(_t,ENDBLOCK);
950		_t = _t->getNextSibling();
951	<	_t = __t45;
951	>	_t = __t58;
952		_t = _t->getNextSibling();
953	<	#line 159 "MDTreeParser.g"
953	>	#line 185 "MDTreeParser.g"
954
955		blockStack.top()->validate();
956		blockStack.pop();
957		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
958		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
959
960	<	#line 784 "MDTreeParser.cpp"
960	>	#line 961 "MDTreeParser.cpp"
961		}
962		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
963		reportError(ex);
#	Line 790 | Line 967 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
967		_retTree = _t;
968		}
969
970	+	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
971	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
972	+
973	+	try {      // for error handling
974	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
975	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
976	+	match(_t,INVERSION);
977	+	_t = _t->getFirstChild();
978	+	#line 202 "MDTreeParser.g"
979	+	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
980	+	#line 981 "MDTreeParser.cpp"
981	+	{ // ( ... )*
982	+	for (;;) {
983	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
984	+	_t = ASTNULL;
985	+	if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
986	+	inversionstatement(_t);
987	+	_t = _retTree;
988	+	}
989	+	else {
990	+	goto _loop66;
991	+	}
992	+
993	+	}
994	+	_loop66:;
995	+	} // ( ... )*
996	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
997	+	match(_t,ENDBLOCK);
998	+	_t = _t->getNextSibling();
999	+	_t = __t64;
1000	+	_t = _t->getNextSibling();
1001	+	#line 204 "MDTreeParser.g"
1002	+
1003	+	blockStack.top()->validate();
1004	+	blockStack.pop();
1005	+	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1006	+	currMoleculeStamp->addInversionStamp(currInversionStamp);
1007	+
1008	+	#line 1009 "MDTreeParser.cpp"
1009	+	}
1010	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1011	+	reportError(ex);
1012	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1013	+	_t = _t->getNextSibling();
1014	+	}
1015	+	_retTree = _t;
1016	+	}
1017	+
1018		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1019	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1020	<	#line 176 "MDTreeParser.g"
1019	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1020	>	#line 223 "MDTreeParser.g"
1021
1022		int index;
1023
1024	<	#line 800 "MDTreeParser.cpp"
1024	>	#line 1025 "MDTreeParser.cpp"
1025
1026		try {      // for error handling
1027	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1028	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
1027	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1028	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1029		match(_t,RIGIDBODY);
1030		_t = _t->getFirstChild();
1031		index=intConst(_t);
1032		_t = _retTree;
1033	<	#line 180 "MDTreeParser.g"
1033	>	#line 227 "MDTreeParser.g"
1034		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1035	<	#line 811 "MDTreeParser.cpp"
1035	>	#line 1036 "MDTreeParser.cpp"
1036		{ // ( ... )*
1037		for (;;) {
1038		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 817 | Line 1042 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1042		_t = _retTree;
1043		}
1044		else {
1045	<	goto _loop53;
1045	>	goto _loop73;
1046		}
1047
1048		}
1049	<	_loop53:;
1049	>	_loop73:;
1050		} // ( ... )*
1051	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1051	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1052		match(_t,ENDBLOCK);
1053		_t = _t->getNextSibling();
1054	<	_t = __t51;
1054	>	_t = __t71;
1055		_t = _t->getNextSibling();
1056	<	#line 182 "MDTreeParser.g"
1056	>	#line 229 "MDTreeParser.g"
1057
1058		blockStack.top()->validate();
1059		blockStack.pop();
1060		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1061		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1062
1063	<	#line 839 "MDTreeParser.cpp"
1063	>	#line 1064 "MDTreeParser.cpp"
1064		}
1065		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1066		reportError(ex);
#	Line 846 | Line 1071 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1071		}
1072
1073		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1074	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1074	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1075
1076		try {      // for error handling
1077	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1078	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1077	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1078	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1079		match(_t,CUTOFFGROUP);
1080		_t = _t->getFirstChild();
1081	<	#line 199 "MDTreeParser.g"
1081	>	#line 246 "MDTreeParser.g"
1082		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1083	<	#line 859 "MDTreeParser.cpp"
1083	>	#line 1084 "MDTreeParser.cpp"
1084		{ // ( ... )*
1085		for (;;) {
1086		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 865 | Line 1090 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1090		_t = _retTree;
1091		}
1092		else {
1093	<	goto _loop59;
1093	>	goto _loop79;
1094		}
1095
1096		}
1097	<	_loop59:;
1097	>	_loop79:;
1098		} // ( ... )*
1099	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1099	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1100		match(_t,ENDBLOCK);
1101		_t = _t->getNextSibling();
1102	<	_t = __t57;
1102	>	_t = __t77;
1103		_t = _t->getNextSibling();
1104	<	#line 201 "MDTreeParser.g"
1104	>	#line 248 "MDTreeParser.g"
1105
1106		blockStack.top()->validate();
1107		blockStack.pop();
1108		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1109		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1110
1111	<	#line 887 "MDTreeParser.cpp"
1111	>	#line 1112 "MDTreeParser.cpp"
1112		}
1113		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1114		reportError(ex);
#	Line 894 | Line 1119 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1119		}
1120
1121		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1122	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1123	<	#line 218 "MDTreeParser.g"
1122	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1123	>	#line 265 "MDTreeParser.g"
1124		int ival;
1125	<	#line 901 "MDTreeParser.cpp"
1125	>	#line 1126 "MDTreeParser.cpp"
1126
1127		try {      // for error handling
1128	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1129	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1128	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1129	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1130		match(_t,FRAGMENT);
1131		_t = _t->getFirstChild();
1132		ival=intConst(_t);
1133		_t = _retTree;
1134	<	#line 219 "MDTreeParser.g"
1134	>	#line 266 "MDTreeParser.g"
1135		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1136	<	#line 912 "MDTreeParser.cpp"
1136	>	#line 1137 "MDTreeParser.cpp"
1137		{ // ( ... )*
1138		for (;;) {
1139		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 918 | Line 1143 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1143		_t = _retTree;
1144		}
1145		else {
1146	<	goto _loop65;
1146	>	goto _loop85;
1147		}
1148
1149		}
1150	<	_loop65:;
1150	>	_loop85:;
1151		} // ( ... )*
1152	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1152	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1153		match(_t,ENDBLOCK);
1154		_t = _t->getNextSibling();
1155	<	_t = __t63;
1155	>	_t = __t83;
1156		_t = _t->getNextSibling();
1157	<	#line 221 "MDTreeParser.g"
1157	>	#line 268 "MDTreeParser.g"
1158
1159		blockStack.top()->validate();
1160		blockStack.pop();
1161		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1162		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1163
1164	<	#line 940 "MDTreeParser.cpp"
1164	>	#line 1165 "MDTreeParser.cpp"
1165		}
1166		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1167		reportError(ex);
#	Line 946 | Line 1171 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1171		_retTree = _t;
1172		}
1173
1174	<	void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1175	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
951	<	#line 108 "MDTreeParser.g"
1174	>	void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1175	>	ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1176
1177	<	vector<double> dvec;
1177	>	try {      // for error handling
1178	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1179	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1180	>	match(_t,CONSTRAINT);
1181	>	_t = _t->getFirstChild();
1182	>	#line 279 "MDTreeParser.g"
1183	>	ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1184	>	#line 1185 "MDTreeParser.cpp"
1185	>	{ // ( ... )*
1186	>	for (;;) {
1187	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1188	>	_t = ASTNULL;
1189	>	if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1190	>	constraintstatement(_t);
1191	>	_t = _retTree;
1192	>	}
1193	>	else {
1194	>	goto _loop90;
1195	>	}
1196	>
1197	>	}
1198	>	_loop90:;
1199	>	} // ( ... )*
1200	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1201	>	match(_t,ENDBLOCK);
1202	>	_t = _t->getNextSibling();
1203	>	_t = __t88;
1204	>	_t = _t->getNextSibling();
1205	>	#line 281 "MDTreeParser.g"
1206	>
1207	>	blockStack.pop();
1208	>	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1209	>	currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1210	>
1211	>	#line 1212 "MDTreeParser.cpp"
1212	>	}
1213	>	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1214	>	reportError(ex);
1215	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1216	>	_t = _t->getNextSibling();
1217	>	}
1218	>	_retTree = _t;
1219	>	}
1220	>
1221	>	void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1222	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1223	>	#line 134 "MDTreeParser.g"
1224	>
1225	>	vector<RealType> dvec;
1226		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1227
1228
1229	<	#line 958 "MDTreeParser.cpp"
1229	>	#line 1230 "MDTreeParser.cpp"
1230
1231		try {      // for error handling
1232		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 968 | Line 1240 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1240		}
1241		case POSITION:
1242		{
1243	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1244	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1243	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1244	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1245		match(_t,POSITION);
1246		_t = _t->getFirstChild();
1247	<	dvec=signedNumberTuple(_t);
1247	>	dvec=doubleNumberTuple(_t);
1248		_t = _retTree;
1249	<	_t = __t30;
1249	>	_t = __t43;
1250		_t = _t->getNextSibling();
1251	<	#line 115 "MDTreeParser.g"
1251	>	#line 141 "MDTreeParser.g"
1252		currAtomStamp->setPosition(dvec);
1253	<	#line 982 "MDTreeParser.cpp"
1253	>	#line 1254 "MDTreeParser.cpp"
1254		break;
1255		}
1256		case ORIENTATION:
1257		{
1258	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1259	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1258	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1259	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1260		match(_t,ORIENTATION);
1261		_t = _t->getFirstChild();
1262	<	dvec=signedNumberTuple(_t);
1262	>	dvec=doubleNumberTuple(_t);
1263		_t = _retTree;
1264	<	_t = __t31;
1264	>	_t = __t44;
1265		_t = _t->getNextSibling();
1266	<	#line 116 "MDTreeParser.g"
1266	>	#line 142 "MDTreeParser.g"
1267		currAtomStamp->setOrientation(dvec);
1268	<	#line 997 "MDTreeParser.cpp"
1268	>	#line 1269 "MDTreeParser.cpp"
1269		break;
1270		}
1271		default:
#	Line 1010 | Line 1282 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1282		_retTree = _t;
1283		}
1284
1285	<	vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286	<	#line 234 "MDTreeParser.g"
1287	<	vector<double> dvec;
1288	<	#line 1017 "MDTreeParser.cpp"
1289	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290	<	#line 234 "MDTreeParser.g"
1285	>	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286	>	#line 298 "MDTreeParser.g"
1287	>	vector<RealType> dvec;
1288	>	#line 1289 "MDTreeParser.cpp"
1289	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290	>	#line 298 "MDTreeParser.g"
1291
1292	<	double dval;
1292	>	RealType dval;
1293
1294	<	#line 1023 "MDTreeParser.cpp"
1294	>	#line 1295 "MDTreeParser.cpp"
1295
1296		try {      // for error handling
1297		{ // ( ... )+
1298	<	int _cnt69=0;
1298	>	int _cnt95=0;
1299		for (;;) {
1300		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1301		_t = ASTNULL;
1302	<	if ((_tokenSet_2.member(_t->getType()))) {
1303	<	dval=signedNumber(_t);
1302	>	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1303	>	dval=doubleNumber(_t);
1304		_t = _retTree;
1305	<	#line 238 "MDTreeParser.g"
1305	>	#line 302 "MDTreeParser.g"
1306		dvec.push_back(dval);
1307	<	#line 1036 "MDTreeParser.cpp"
1307	>	#line 1308 "MDTreeParser.cpp"
1308		}
1309		else {
1310	<	if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1310	>	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1311		}
1312
1313	<	_cnt69++;
1313	>	_cnt95++;
1314		}
1315	<	_loop69:;
1315	>	_loop95:;
1316		}  // ( ... )+
1317		}
1318		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1053 | Line 1325 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1325		}
1326
1327		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	<	#line 129 "MDTreeParser.g"
1328	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329	>	#line 155 "MDTreeParser.g"
1330
1331		vector<int> ivec;
1332		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1333
1334	<	#line 1063 "MDTreeParser.cpp"
1334	>	#line 1335 "MDTreeParser.cpp"
1335
1336		try {      // for error handling
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1073 | Line 1345 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1345		}
1346		case MEMBERS:
1347		{
1348	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1349	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1348	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1349	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1350		match(_t,MEMBERS);
1351		_t = _t->getFirstChild();
1352		ivec=inttuple(_t);
1353		_t = _retTree;
1354	<	_t = __t37;
1354	>	_t = __t50;
1355		_t = _t->getNextSibling();
1356	<	#line 135 "MDTreeParser.g"
1356	>	#line 161 "MDTreeParser.g"
1357		currBondStamp->setMembers(ivec);
1358	<	#line 1087 "MDTreeParser.cpp"
1358	>	#line 1359 "MDTreeParser.cpp"
1359		break;
1360		}
1361		default:
#	Line 1101 | Line 1373 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1373		}
1374
1375		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376	<	#line 241 "MDTreeParser.g"
1376	>	#line 306 "MDTreeParser.g"
1377		vector<int> ivec;
1378	<	#line 1107 "MDTreeParser.cpp"
1379	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380	<	#line 241 "MDTreeParser.g"
1378	>	#line 1379 "MDTreeParser.cpp"
1379	>	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380	>	#line 306 "MDTreeParser.g"
1381
1382		int ival;
1383
1384	<	#line 1113 "MDTreeParser.cpp"
1384	>	#line 1385 "MDTreeParser.cpp"
1385
1386		try {      // for error handling
1387		{ // ( ... )+
1388	<	int _cnt72=0;
1388	>	int _cnt98=0;
1389		for (;;) {
1390		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1391		_t = ASTNULL;
1392	<	if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1392	>	if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1393		ival=intConst(_t);
1394		_t = _retTree;
1395	<	#line 245 "MDTreeParser.g"
1395	>	#line 310 "MDTreeParser.g"
1396		ivec.push_back(ival);
1397	<	#line 1126 "MDTreeParser.cpp"
1397	>	#line 1398 "MDTreeParser.cpp"
1398		}
1399		else {
1400	<	if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1400	>	if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1401		}
1402
1403	<	_cnt72++;
1403	>	_cnt98++;
1404		}
1405	<	_loop72:;
1405	>	_loop98:;
1406		}  // ( ... )+
1407		}
1408		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1143 | Line 1415 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1415		}
1416
1417		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1418	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1419	<	#line 148 "MDTreeParser.g"
1418	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1419	>	#line 174 "MDTreeParser.g"
1420
1421		vector<int> ivec;
1422		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1423
1424	<	#line 1153 "MDTreeParser.cpp"
1424	>	#line 1425 "MDTreeParser.cpp"
1425
1426		try {      // for error handling
1427		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1163 | Line 1435 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1435		}
1436		case MEMBERS:
1437		{
1438	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1439	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1438	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1439	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1440		match(_t,MEMBERS);
1441		_t = _t->getFirstChild();
1442		ivec=inttuple(_t);
1443		_t = _retTree;
1444	<	_t = __t43;
1444	>	_t = __t56;
1445		_t = _t->getNextSibling();
1446	<	#line 154 "MDTreeParser.g"
1446	>	#line 180 "MDTreeParser.g"
1447		currBendStamp->setMembers(ivec);
1448	<	#line 1177 "MDTreeParser.cpp"
1448	>	#line 1449 "MDTreeParser.cpp"
1449		break;
1450		}
1451		default:
#	Line 1191 | Line 1463 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1463		}
1464
1465		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1466	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1467	<	#line 167 "MDTreeParser.g"
1466	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1467	>	#line 193 "MDTreeParser.g"
1468
1469		vector<int> ivec;
1470		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1471
1472	<	#line 1201 "MDTreeParser.cpp"
1472	>	#line 1473 "MDTreeParser.cpp"
1473
1474		try {      // for error handling
1475		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1211 | Line 1483 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1483		}
1484		case MEMBERS:
1485		{
1486	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1487	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1486	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1487	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1488		match(_t,MEMBERS);
1489		_t = _t->getFirstChild();
1490		ivec=inttuple(_t);
1491		_t = _retTree;
1492	<	_t = __t49;
1492	>	_t = __t62;
1493		_t = _t->getNextSibling();
1494	<	#line 173 "MDTreeParser.g"
1494	>	#line 199 "MDTreeParser.g"
1495		currTorsionStamp->setMembers(ivec);
1496	<	#line 1225 "MDTreeParser.cpp"
1496	>	#line 1497 "MDTreeParser.cpp"
1497		break;
1498		}
1499		default:
#	Line 1238 | Line 1510 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1510		_retTree = _t;
1511		}
1512
1513	+	void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1514	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515	+	#line 212 "MDTreeParser.g"
1516	+
1517	+	int icent;
1518	+	vector<int> ivec;
1519	+	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1520	+
1521	+	#line 1522 "MDTreeParser.cpp"
1522	+
1523	+	try {      // for error handling
1524	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1525	+	_t = ASTNULL;
1526	+	switch ( _t->getType()) {
1527	+	case ASSIGNEQUAL:
1528	+	{
1529	+	assignment(_t);
1530	+	_t = _retTree;
1531	+	break;
1532	+	}
1533	+	case CENTER:
1534	+	{
1535	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1536	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1537	+	match(_t,CENTER);
1538	+	_t = _t->getFirstChild();
1539	+	icent=intConst(_t);
1540	+	_t = _retTree;
1541	+	_t = __t68;
1542	+	_t = _t->getNextSibling();
1543	+	#line 219 "MDTreeParser.g"
1544	+	currInversionStamp->setCenter(icent);
1545	+	#line 1546 "MDTreeParser.cpp"
1546	+	break;
1547	+	}
1548	+	case SATELLITES:
1549	+	{
1550	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1551	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1552	+	match(_t,SATELLITES);
1553	+	_t = _t->getFirstChild();
1554	+	ivec=inttuple(_t);
1555	+	_t = _retTree;
1556	+	_t = __t69;
1557	+	_t = _t->getNextSibling();
1558	+	#line 220 "MDTreeParser.g"
1559	+	currInversionStamp->setSatellites(ivec);
1560	+	#line 1561 "MDTreeParser.cpp"
1561	+	break;
1562	+	}
1563	+	default:
1564	+	{
1565	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1566	+	}
1567	+	}
1568	+	}
1569	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1570	+	reportError(ex);
1571	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1572	+	_t = _t->getNextSibling();
1573	+	}
1574	+	_retTree = _t;
1575	+	}
1576	+
1577		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1578	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1579	<	#line 190 "MDTreeParser.g"
1578	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1579	>	#line 237 "MDTreeParser.g"
1580
1581		vector<int> ivec;
1582		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1583
1584	<	#line 1249 "MDTreeParser.cpp"
1584	>	#line 1585 "MDTreeParser.cpp"
1585
1586		try {      // for error handling
1587		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1259 | Line 1595 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1595		}
1596		case MEMBERS:
1597		{
1598	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1599	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1598	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1599	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1600		match(_t,MEMBERS);
1601		_t = _t->getFirstChild();
1602		ivec=inttuple(_t);
1603		_t = _retTree;
1604	<	_t = __t55;
1604	>	_t = __t75;
1605		_t = _t->getNextSibling();
1606	<	#line 196 "MDTreeParser.g"
1606	>	#line 243 "MDTreeParser.g"
1607		currRigidBodyStamp->setMembers(ivec);
1608	<	#line 1273 "MDTreeParser.cpp"
1608	>	#line 1609 "MDTreeParser.cpp"
1609		break;
1610		}
1611		default:
#	Line 1287 | Line 1623 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1623		}
1624
1625		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1626	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1627	<	#line 209 "MDTreeParser.g"
1626	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1627	>	#line 256 "MDTreeParser.g"
1628
1629		vector<int> ivec;
1630		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1631
1632	<	#line 1297 "MDTreeParser.cpp"
1632	>	#line 1633 "MDTreeParser.cpp"
1633
1634		try {      // for error handling
1635		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1307 | Line 1643 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1643		}
1644		case MEMBERS:
1645		{
1646	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1647	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1646	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1647	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1648		match(_t,MEMBERS);
1649		_t = _t->getFirstChild();
1650		ivec=inttuple(_t);
1651		_t = _retTree;
1652	<	_t = __t61;
1652	>	_t = __t81;
1653		_t = _t->getNextSibling();
1654	<	#line 215 "MDTreeParser.g"
1654	>	#line 262 "MDTreeParser.g"
1655		currCutoffGroupStamp->setMembers(ivec);
1656	<	#line 1321 "MDTreeParser.cpp"
1656	>	#line 1657 "MDTreeParser.cpp"
1657		break;
1658		}
1659		default:
#	Line 1335 | Line 1671 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1671		}
1672
1673		void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1674	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1674	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1675
1676		try {      // for error handling
1677		assignment(_t);
#	Line 1349 | Line 1685 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1685		_retTree = _t;
1686		}
1687
1688	<	double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1689	<	#line 256 "MDTreeParser.g"
1690	<	double dval;
1355	<	#line 1356 "MDTreeParser.cpp"
1356	<	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;
1359	<	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1360	<	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1688	>	void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1689	>	ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1690	>	#line 288 "MDTreeParser.g"
1691
1692	+	vector<int> ivec;
1693	+	ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1694	+
1695	+	#line 1696 "MDTreeParser.cpp"
1696	+
1697		try {      // for error handling
1698		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1699		_t = ASTNULL;
1700		switch ( _t->getType()) {
1701	<	case MINUS:
1701	>	case ASSIGNEQUAL:
1702		{
1703	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1704	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1705	<	match(_t,MINUS);
1703	>	assignment(_t);
1704	>	_t = _retTree;
1705	>	break;
1706	>	}
1707	>	case MEMBERS:
1708	>	{
1709	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1710	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1711	>	match(_t,MEMBERS);
1712		_t = _t->getFirstChild();
1713	<	{
1714	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1715	<	_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;
1713	>	ivec=inttuple(_t);
1714	>	_t = _retTree;
1715	>	_t = __t92;
1716		_t = _t->getNextSibling();
1717	+	#line 294 "MDTreeParser.g"
1718	+	currConstraintStamp->setMembers(ivec);
1719	+	#line 1720 "MDTreeParser.cpp"
1720		break;
1721		}
1409	–	case OCTALINT:
1410	–	case DECIMALINT:
1411	–	case HEXADECIMALINT:
1412	–	case FLOATONE:
1413	–	case FLOATTWO:
1414	–	{
1415	–	{
1416	–	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1417	–	_t = ASTNULL;
1418	–	switch ( _t->getType()) {
1419	–	case OCTALINT:
1420	–	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	–	}
1448	–	break;
1449	–	}
1722		default:
1723		{
1724		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 1459 | Line 1731 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1731		_t = _t->getNextSibling();
1732		}
1733		_retTree = _t;
1462	–	return dval;
1734		}
1735
1736		void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
#	Line 1473 | Line 1744 | const char* MDTreeParser::tokenNames[] = {
1744		"\"component\"",
1745		"\"molecule\"",
1746		"\"zconstraint\"",
1747	+	"\"restraint\"",
1748		"\"atom\"",
1749		"\"bond\"",
1750		"\"bend\"",
1751		"\"torsion\"",
1752	+	"\"inversion\"",
1753		"\"rigidBody\"",
1754		"\"cutoffGroup\"",
1755	+	"\"constraint\"",
1756	+	"\"distance\"",
1757		"\"fragment\"",
1758		"\"members\"",
1759	+	"\"center\"",
1760	+	"\"satellites\"",
1761		"\"position\"",
1762		"\"orientation\"",
1763	+	"\"flucQ\"",
1764	+	"\"RNEMD\"",
1765	+	"\"minimizer\"",
1766		"ENDBLOCK",
1767		"ID",
1768		"ASSIGNEQUAL",
#	Line 1495 | Line 1775 | const char* MDTreeParser::tokenNames[] = {
1775		"LPAREN",
1776		"RPAREN",
1777		"COMMA",
1778	<	"OCTALINT",
1779	<	"DECIMALINT",
1780	<	"HEXADECIMALINT",
1781	<	"PLUS",
1502	<	"MINUS",
1503	<	"FLOATONE",
1504	<	"FLOATTWO",
1778	>	"NUM_INT",
1779	>	"NUM_LONG",
1780	>	"NUM_FLOAT",
1781	>	"NUM_DOUBLE",
1782		"DOT",
1783		"COLON",
1784		"QUESTIONMARK",
#	Line 1514 | Line 1791 | const char* MDTreeParser::tokenNames[] = {
1791		"CharLiteral",
1792		"EndOfLine",
1793		"Escape",
1794	+	"Vocabulary",
1795		"Digit",
1796		"Decimal",
1797	<	"LongSuffix",
1798	<	"UnsignedSuffix",
1799	<	"FloatSuffix",
1522	<	"Exponent",
1523	<	"Vocabulary",
1524	<	"Number",
1797	>	"HEX_DIGIT",
1798	>	"EXPONENT",
1799	>	"FLOAT_SUFFIX",
1800		0
1801		};
1802
1803	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1804	<	// "component" "molecule" "zconstraint" ASSIGNEQUAL
1530	<	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1531	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1532	<	// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1803	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1804	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1805		// ASSIGNEQUAL
1806	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1807	+	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1808	+	// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1809	+	// "constraint" "fragment" ASSIGNEQUAL
1810		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);
1811
1812

Comparing trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC

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

Diff Legend

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