ViewVC Help

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

root/OpenMD/branches/development/src/mdParser/MDTreeParser.cpp

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (file contents), Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (file contents), Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

Comparing:
trunk/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
branches/development/src/mdParser/MDTreeParser.cpp (property svn:keywords), Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

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

Diff Legend

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