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 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

#	Line 1 | Line 1
1	<	/* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20120725): "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);
263	>	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
264	>	_t = _t->getNextSibling();
265	>	}
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);
#	Line 242 | Line 352 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
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 294 "MDTreeParser.g"
550		int ival;
551	<	double dval;
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
317	–	#line 318 "MDTreeParser.cpp"
318	–
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 295 "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 296 "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 306 "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 307 "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"
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"
622	>	#line 308 "MDTreeParser.g"
623	>	dval = lexi_cast<RealType>(d2->getText());
624	>	#line 625 "MDTreeParser.cpp"
625		break;
626		}
627		default:
#	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 300 "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 301 "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 302 "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 593 | Line 764 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
764		}
765
766		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
767	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768	<	#line 94 "MDTreeParser.g"
767	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768	>	#line 119 "MDTreeParser.g"
769
770		int index;
771
772	<	#line 602 "MDTreeParser.cpp"
772	>	#line 773 "MDTreeParser.cpp"
773
774		try {      // for error handling
775	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
776	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
775	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
776	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
777		match(_t,ATOM);
778		_t = _t->getFirstChild();
779		index=intConst(_t);
780		_t = _retTree;
781	<	#line 98 "MDTreeParser.g"
781	>	#line 123 "MDTreeParser.g"
782		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783	<	#line 613 "MDTreeParser.cpp"
783	>	#line 784 "MDTreeParser.cpp"
784		{ // ( ... )*
785		for (;;) {
786		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 619 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790		_t = _retTree;
791		}
792		else {
793	<	goto _loop28;
793	>	goto _loop41;
794		}
795
796		}
797	<	_loop28:;
797	>	_loop41:;
798		} // ( ... )*
799	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
799	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800		match(_t,ENDBLOCK);
801		_t = _t->getNextSibling();
802	<	_t = __t26;
802	>	_t = __t39;
803		_t = _t->getNextSibling();
804	<	#line 100 "MDTreeParser.g"
804	>	#line 125 "MDTreeParser.g"
805
806		blockStack.top()->validate();
807		blockStack.pop();
808		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
809		currMoleculeStamp->addAtomStamp(currAtomStamp);
810
811	<	#line 641 "MDTreeParser.cpp"
811	>	#line 812 "MDTreeParser.cpp"
812		}
813		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814		reportError(ex);
#	Line 648 | Line 819 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
819		}
820
821		void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
822	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
822	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
823
824		try {      // for error handling
825	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
826	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
825	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
826	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
827		match(_t,BOND);
828		_t = _t->getFirstChild();
829	<	#line 120 "MDTreeParser.g"
829	>	#line 145 "MDTreeParser.g"
830		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831	<	#line 661 "MDTreeParser.cpp"
831	>	#line 832 "MDTreeParser.cpp"
832		{ // ( ... )*
833		for (;;) {
834		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 667 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838		_t = _retTree;
839		}
840		else {
841	<	goto _loop35;
841	>	goto _loop48;
842		}
843
844		}
845	<	_loop35:;
845	>	_loop48:;
846		} // ( ... )*
847	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
847	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848		match(_t,ENDBLOCK);
849		_t = _t->getNextSibling();
850	<	_t = __t33;
850	>	_t = __t46;
851		_t = _t->getNextSibling();
852	<	#line 122 "MDTreeParser.g"
852	>	#line 147 "MDTreeParser.g"
853
854		blockStack.pop();
855		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
856		currMoleculeStamp->addBondStamp(currBondStamp);
857
858	<	#line 688 "MDTreeParser.cpp"
858	>	#line 859 "MDTreeParser.cpp"
859		}
860		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861		reportError(ex);
#	Line 695 | Line 866 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
866		}
867
868		void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
869	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
869	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
870
871		try {      // for error handling
872	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
873	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
872	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
873	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
874		match(_t,BEND);
875		_t = _t->getFirstChild();
876	<	#line 138 "MDTreeParser.g"
876	>	#line 163 "MDTreeParser.g"
877		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878	<	#line 708 "MDTreeParser.cpp"
878	>	#line 879 "MDTreeParser.cpp"
879		{ // ( ... )*
880		for (;;) {
881		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 714 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885		_t = _retTree;
886		}
887		else {
888	<	goto _loop41;
888	>	goto _loop54;
889		}
890
891		}
892	<	_loop41:;
892	>	_loop54:;
893		} // ( ... )*
894	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
894	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895		match(_t,ENDBLOCK);
896		_t = _t->getNextSibling();
897	<	_t = __t39;
897	>	_t = __t52;
898		_t = _t->getNextSibling();
899	<	#line 140 "MDTreeParser.g"
899	>	#line 165 "MDTreeParser.g"
900
901		blockStack.top()->validate();
902		blockStack.pop();
903		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
904		currMoleculeStamp->addBendStamp(currBendStamp);
905
906	<	#line 736 "MDTreeParser.cpp"
906	>	#line 907 "MDTreeParser.cpp"
907		}
908		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909		reportError(ex);
#	Line 743 | Line 914 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
914		}
915
916		void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
917	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
917	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
918
919		try {      // for error handling
920	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
921	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
920	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
921	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
922		match(_t,TORSION);
923		_t = _t->getFirstChild();
924	<	#line 157 "MDTreeParser.g"
924	>	#line 182 "MDTreeParser.g"
925		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926	<	#line 756 "MDTreeParser.cpp"
926	>	#line 927 "MDTreeParser.cpp"
927		{ // ( ... )*
928		for (;;) {
929		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 762 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933		_t = _retTree;
934		}
935		else {
936	<	goto _loop47;
936	>	goto _loop60;
937		}
938
939		}
940	<	_loop47:;
940	>	_loop60:;
941		} // ( ... )*
942	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
942	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943		match(_t,ENDBLOCK);
944		_t = _t->getNextSibling();
945	<	_t = __t45;
945	>	_t = __t58;
946		_t = _t->getNextSibling();
947	<	#line 159 "MDTreeParser.g"
947	>	#line 184 "MDTreeParser.g"
948
949		blockStack.top()->validate();
950		blockStack.pop();
951		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
952		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
953
954	<	#line 784 "MDTreeParser.cpp"
954	>	#line 955 "MDTreeParser.cpp"
955		}
956		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957		reportError(ex);
#	Line 790 | Line 961 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
961		_retTree = _t;
962		}
963
964	+	void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
965	+	ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
966	+
967	+	try {      // for error handling
968	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
969	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
970	+	match(_t,INVERSION);
971	+	_t = _t->getFirstChild();
972	+	#line 201 "MDTreeParser.g"
973	+	InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974	+	#line 975 "MDTreeParser.cpp"
975	+	{ // ( ... )*
976	+	for (;;) {
977	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
978	+	_t = ASTNULL;
979	+	if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
980	+	inversionstatement(_t);
981	+	_t = _retTree;
982	+	}
983	+	else {
984	+	goto _loop66;
985	+	}
986	+
987	+	}
988	+	_loop66:;
989	+	} // ( ... )*
990	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991	+	match(_t,ENDBLOCK);
992	+	_t = _t->getNextSibling();
993	+	_t = __t64;
994	+	_t = _t->getNextSibling();
995	+	#line 203 "MDTreeParser.g"
996	+
997	+	blockStack.top()->validate();
998	+	blockStack.pop();
999	+	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1000	+	currMoleculeStamp->addInversionStamp(currInversionStamp);
1001	+
1002	+	#line 1003 "MDTreeParser.cpp"
1003	+	}
1004	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005	+	reportError(ex);
1006	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1007	+	_t = _t->getNextSibling();
1008	+	}
1009	+	_retTree = _t;
1010	+	}
1011	+
1012		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014	<	#line 176 "MDTreeParser.g"
1013	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014	>	#line 220 "MDTreeParser.g"
1015
1016		int index;
1017
1018	<	#line 800 "MDTreeParser.cpp"
1018	>	#line 1019 "MDTreeParser.cpp"
1019
1020		try {      // for error handling
1021	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1022	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
1021	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1022	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023		match(_t,RIGIDBODY);
1024		_t = _t->getFirstChild();
1025		index=intConst(_t);
1026		_t = _retTree;
1027	<	#line 180 "MDTreeParser.g"
1027	>	#line 224 "MDTreeParser.g"
1028		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029	<	#line 811 "MDTreeParser.cpp"
1029	>	#line 1030 "MDTreeParser.cpp"
1030		{ // ( ... )*
1031		for (;;) {
1032		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 817 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036		_t = _retTree;
1037		}
1038		else {
1039	<	goto _loop53;
1039	>	goto _loop72;
1040		}
1041
1042		}
1043	<	_loop53:;
1043	>	_loop72:;
1044		} // ( ... )*
1045	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
1045	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046		match(_t,ENDBLOCK);
1047		_t = _t->getNextSibling();
1048	<	_t = __t51;
1048	>	_t = __t70;
1049		_t = _t->getNextSibling();
1050	<	#line 182 "MDTreeParser.g"
1050	>	#line 226 "MDTreeParser.g"
1051
1052		blockStack.top()->validate();
1053		blockStack.pop();
1054		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1055		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1056
1057	<	#line 839 "MDTreeParser.cpp"
1057	>	#line 1058 "MDTreeParser.cpp"
1058		}
1059		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060		reportError(ex);
#	Line 846 | Line 1065 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1065		}
1066
1067		void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1068	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1068	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069
1070		try {      // for error handling
1071	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1072	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
1071	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1072	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073		match(_t,CUTOFFGROUP);
1074		_t = _t->getFirstChild();
1075	<	#line 199 "MDTreeParser.g"
1075	>	#line 243 "MDTreeParser.g"
1076		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077	<	#line 859 "MDTreeParser.cpp"
1077	>	#line 1078 "MDTreeParser.cpp"
1078		{ // ( ... )*
1079		for (;;) {
1080		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 865 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084		_t = _retTree;
1085		}
1086		else {
1087	<	goto _loop59;
1087	>	goto _loop78;
1088		}
1089
1090		}
1091	<	_loop59:;
1091	>	_loop78:;
1092		} // ( ... )*
1093	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
1093	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094		match(_t,ENDBLOCK);
1095		_t = _t->getNextSibling();
1096	<	_t = __t57;
1096	>	_t = __t76;
1097		_t = _t->getNextSibling();
1098	<	#line 201 "MDTreeParser.g"
1098	>	#line 245 "MDTreeParser.g"
1099
1100		blockStack.top()->validate();
1101		blockStack.pop();
1102		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1103		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1104
1105	<	#line 887 "MDTreeParser.cpp"
1105	>	#line 1106 "MDTreeParser.cpp"
1106		}
1107		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108		reportError(ex);
#	Line 894 | Line 1113 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1113		}
1114
1115		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117	<	#line 218 "MDTreeParser.g"
1116	>	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117	>	#line 262 "MDTreeParser.g"
1118		int ival;
1119	<	#line 901 "MDTreeParser.cpp"
1119	>	#line 1120 "MDTreeParser.cpp"
1120
1121		try {      // for error handling
1122	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1122	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1123	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124		match(_t,FRAGMENT);
1125		_t = _t->getFirstChild();
1126		ival=intConst(_t);
1127		_t = _retTree;
1128	<	#line 219 "MDTreeParser.g"
1128	>	#line 263 "MDTreeParser.g"
1129		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130	<	#line 912 "MDTreeParser.cpp"
1130	>	#line 1131 "MDTreeParser.cpp"
1131		{ // ( ... )*
1132		for (;;) {
1133		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 918 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137		_t = _retTree;
1138		}
1139		else {
1140	<	goto _loop65;
1140	>	goto _loop84;
1141		}
1142
1143		}
1144	<	_loop65:;
1144	>	_loop84:;
1145		} // ( ... )*
1146	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
1146	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147		match(_t,ENDBLOCK);
1148		_t = _t->getNextSibling();
1149	<	_t = __t63;
1149	>	_t = __t82;
1150		_t = _t->getNextSibling();
1151	<	#line 221 "MDTreeParser.g"
1151	>	#line 265 "MDTreeParser.g"
1152
1153		blockStack.top()->validate();
1154		blockStack.pop();
1155		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1156		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1157
1158	<	#line 940 "MDTreeParser.cpp"
1158	>	#line 1159 "MDTreeParser.cpp"
1159		}
1160		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161		reportError(ex);
#	Line 947 | Line 1166 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1166		}
1167
1168		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1169	<	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170	<	#line 108 "MDTreeParser.g"
1169	>	ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170	>	#line 133 "MDTreeParser.g"
1171
1172	<	vector<double> dvec;
1172	>	vector<RealType> dvec;
1173		AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174
1175
1176	<	#line 958 "MDTreeParser.cpp"
1176	>	#line 1177 "MDTreeParser.cpp"
1177
1178		try {      // for error handling
1179		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 968 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187		}
1188		case POSITION:
1189		{
1190	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1191	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1190	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1191	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1192		match(_t,POSITION);
1193		_t = _t->getFirstChild();
1194	<	dvec=signedNumberTuple(_t);
1194	>	dvec=doubleNumberTuple(_t);
1195		_t = _retTree;
1196	<	_t = __t30;
1196	>	_t = __t43;
1197		_t = _t->getNextSibling();
1198	<	#line 115 "MDTreeParser.g"
1198	>	#line 140 "MDTreeParser.g"
1199		currAtomStamp->setPosition(dvec);
1200	<	#line 982 "MDTreeParser.cpp"
1200	>	#line 1201 "MDTreeParser.cpp"
1201		break;
1202		}
1203		case ORIENTATION:
1204		{
1205	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1206	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1205	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1206	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1207		match(_t,ORIENTATION);
1208		_t = _t->getFirstChild();
1209	<	dvec=signedNumberTuple(_t);
1209	>	dvec=doubleNumberTuple(_t);
1210		_t = _retTree;
1211	<	_t = __t31;
1211	>	_t = __t44;
1212		_t = _t->getNextSibling();
1213	<	#line 116 "MDTreeParser.g"
1213	>	#line 141 "MDTreeParser.g"
1214		currAtomStamp->setOrientation(dvec);
1215	<	#line 997 "MDTreeParser.cpp"
1215	>	#line 1216 "MDTreeParser.cpp"
1216		break;
1217		}
1218		default:
#	Line 1010 | Line 1229 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1229		_retTree = _t;
1230		}
1231
1232	<	vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233	<	#line 234 "MDTreeParser.g"
1234	<	vector<double> dvec;
1235	<	#line 1017 "MDTreeParser.cpp"
1236	<	ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237	<	#line 234 "MDTreeParser.g"
1232	>	vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233	>	#line 278 "MDTreeParser.g"
1234	>	vector<RealType> dvec;
1235	>	#line 1236 "MDTreeParser.cpp"
1236	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237	>	#line 278 "MDTreeParser.g"
1238
1239	<	double dval;
1239	>	RealType dval;
1240
1241	<	#line 1023 "MDTreeParser.cpp"
1241	>	#line 1242 "MDTreeParser.cpp"
1242
1243		try {      // for error handling
1244		{ // ( ... )+
1245	<	int _cnt69=0;
1245	>	int _cnt88=0;
1246		for (;;) {
1247		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248		_t = ASTNULL;
1249	<	if ((_tokenSet_2.member(_t->getType()))) {
1250	<	dval=signedNumber(_t);
1249	>	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250	>	dval=doubleNumber(_t);
1251		_t = _retTree;
1252	<	#line 238 "MDTreeParser.g"
1252	>	#line 282 "MDTreeParser.g"
1253		dvec.push_back(dval);
1254	<	#line 1036 "MDTreeParser.cpp"
1254	>	#line 1255 "MDTreeParser.cpp"
1255		}
1256		else {
1257	<	if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1257	>	if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258		}
1259
1260	<	_cnt69++;
1260	>	_cnt88++;
1261		}
1262	<	_loop69:;
1262	>	_loop88:;
1263		}  // ( ... )+
1264		}
1265		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1053 | Line 1272 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1272		}
1273
1274		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1275	<	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276	<	#line 129 "MDTreeParser.g"
1275	>	ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276	>	#line 154 "MDTreeParser.g"
1277
1278		vector<int> ivec;
1279		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280
1281	<	#line 1063 "MDTreeParser.cpp"
1281	>	#line 1282 "MDTreeParser.cpp"
1282
1283		try {      // for error handling
1284		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1073 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292		}
1293		case MEMBERS:
1294		{
1295	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1296	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1295	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1296	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1297		match(_t,MEMBERS);
1298		_t = _t->getFirstChild();
1299		ivec=inttuple(_t);
1300		_t = _retTree;
1301	<	_t = __t37;
1301	>	_t = __t50;
1302		_t = _t->getNextSibling();
1303	<	#line 135 "MDTreeParser.g"
1303	>	#line 160 "MDTreeParser.g"
1304		currBondStamp->setMembers(ivec);
1305	<	#line 1087 "MDTreeParser.cpp"
1305	>	#line 1306 "MDTreeParser.cpp"
1306		break;
1307		}
1308		default:
#	Line 1101 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320		}
1321
1322		vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323	<	#line 241 "MDTreeParser.g"
1323	>	#line 286 "MDTreeParser.g"
1324		vector<int> ivec;
1325	<	#line 1107 "MDTreeParser.cpp"
1326	<	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327	<	#line 241 "MDTreeParser.g"
1325	>	#line 1326 "MDTreeParser.cpp"
1326	>	ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327	>	#line 286 "MDTreeParser.g"
1328
1329		int ival;
1330
1331	<	#line 1113 "MDTreeParser.cpp"
1331	>	#line 1332 "MDTreeParser.cpp"
1332
1333		try {      // for error handling
1334		{ // ( ... )+
1335	<	int _cnt72=0;
1335	>	int _cnt91=0;
1336		for (;;) {
1337		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338		_t = ASTNULL;
1339	<	if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1339	>	if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340		ival=intConst(_t);
1341		_t = _retTree;
1342	<	#line 245 "MDTreeParser.g"
1342	>	#line 290 "MDTreeParser.g"
1343		ivec.push_back(ival);
1344	<	#line 1126 "MDTreeParser.cpp"
1344	>	#line 1345 "MDTreeParser.cpp"
1345		}
1346		else {
1347	<	if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1347	>	if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348		}
1349
1350	<	_cnt72++;
1350	>	_cnt91++;
1351		}
1352	<	_loop72:;
1352	>	_loop91:;
1353		}  // ( ... )+
1354		}
1355		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1143 | Line 1362 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1362		}
1363
1364		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1365	<	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366	<	#line 148 "MDTreeParser.g"
1365	>	ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366	>	#line 173 "MDTreeParser.g"
1367
1368		vector<int> ivec;
1369		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370
1371	<	#line 1153 "MDTreeParser.cpp"
1371	>	#line 1372 "MDTreeParser.cpp"
1372
1373		try {      // for error handling
1374		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1163 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382		}
1383		case MEMBERS:
1384		{
1385	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1386	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1385	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1386	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1387		match(_t,MEMBERS);
1388		_t = _t->getFirstChild();
1389		ivec=inttuple(_t);
1390		_t = _retTree;
1391	<	_t = __t43;
1391	>	_t = __t56;
1392		_t = _t->getNextSibling();
1393	<	#line 154 "MDTreeParser.g"
1393	>	#line 179 "MDTreeParser.g"
1394		currBendStamp->setMembers(ivec);
1395	<	#line 1177 "MDTreeParser.cpp"
1395	>	#line 1396 "MDTreeParser.cpp"
1396		break;
1397		}
1398		default:
#	Line 1191 | Line 1410 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1410		}
1411
1412		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1413	<	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414	<	#line 167 "MDTreeParser.g"
1413	>	ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414	>	#line 192 "MDTreeParser.g"
1415
1416		vector<int> ivec;
1417		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418
1419	<	#line 1201 "MDTreeParser.cpp"
1419	>	#line 1420 "MDTreeParser.cpp"
1420
1421		try {      // for error handling
1422		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1211 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430		}
1431		case MEMBERS:
1432		{
1433	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1434	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1433	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1434	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1435		match(_t,MEMBERS);
1436		_t = _t->getFirstChild();
1437		ivec=inttuple(_t);
1438		_t = _retTree;
1439	<	_t = __t49;
1439	>	_t = __t62;
1440		_t = _t->getNextSibling();
1441	<	#line 173 "MDTreeParser.g"
1441	>	#line 198 "MDTreeParser.g"
1442		currTorsionStamp->setMembers(ivec);
1443	<	#line 1225 "MDTreeParser.cpp"
1443	>	#line 1444 "MDTreeParser.cpp"
1444		break;
1445		}
1446		default:
#	Line 1238 | Line 1457 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1457		_retTree = _t;
1458		}
1459
1460	<	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461	<	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462	<	#line 190 "MDTreeParser.g"
1460	>	void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461	>	ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462	>	#line 211 "MDTreeParser.g"
1463
1464	<	vector<int> ivec;
1465	<	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1464	>	int icent;
1465	>	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466
1467	<	#line 1249 "MDTreeParser.cpp"
1467	>	#line 1468 "MDTreeParser.cpp"
1468
1469		try {      // for error handling
1470		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1257 | Line 1476 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1476		_t = _retTree;
1477		break;
1478		}
1479	<	case MEMBERS:
1479	>	case CENTER:
1480		{
1481	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1482	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1483	<	match(_t,MEMBERS);
1481	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1482	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1483	>	match(_t,CENTER);
1484		_t = _t->getFirstChild();
1485	<	ivec=inttuple(_t);
1485	>	icent=intConst(_t);
1486		_t = _retTree;
1487	<	_t = __t55;
1487	>	_t = __t68;
1488		_t = _t->getNextSibling();
1489	<	#line 196 "MDTreeParser.g"
1490	<	currRigidBodyStamp->setMembers(ivec);
1491	<	#line 1273 "MDTreeParser.cpp"
1489	>	#line 217 "MDTreeParser.g"
1490	>	currInversionStamp->setCenter(icent);
1491	>	#line 1492 "MDTreeParser.cpp"
1492		break;
1493		}
1494		default:
#	Line 1286 | Line 1505 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1505		_retTree = _t;
1506		}
1507
1508	<	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509	<	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510	<	#line 209 "MDTreeParser.g"
1508	>	void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509	>	ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510	>	#line 234 "MDTreeParser.g"
1511
1512		vector<int> ivec;
1513	<	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1513	>	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514
1515	<	#line 1297 "MDTreeParser.cpp"
1515	>	#line 1516 "MDTreeParser.cpp"
1516
1517		try {      // for error handling
1518		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1307 | Line 1526 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1526		}
1527		case MEMBERS:
1528		{
1529	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1530	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1529	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1530	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1531		match(_t,MEMBERS);
1532		_t = _t->getFirstChild();
1533		ivec=inttuple(_t);
1534		_t = _retTree;
1535	<	_t = __t61;
1535	>	_t = __t74;
1536		_t = _t->getNextSibling();
1537	<	#line 215 "MDTreeParser.g"
1538	<	currCutoffGroupStamp->setMembers(ivec);
1539	<	#line 1321 "MDTreeParser.cpp"
1537	>	#line 240 "MDTreeParser.g"
1538	>	currRigidBodyStamp->setMembers(ivec);
1539	>	#line 1540 "MDTreeParser.cpp"
1540		break;
1541		}
1542		default:
#	Line 1334 | Line 1553 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1553		_retTree = _t;
1554		}
1555
1556	<	void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557	<	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1556	>	void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557	>	ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1558	>	#line 253 "MDTreeParser.g"
1559
1560	<	try {      // for error handling
1561	<	assignment(_t);
1342	<	_t = _retTree;
1343	<	}
1344	<	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1345	<	reportError(ex);
1346	<	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1347	<	_t = _t->getNextSibling();
1348	<	}
1349	<	_retTree = _t;
1350	<	}
1351	<
1352	<	double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1353	<	#line 256 "MDTreeParser.g"
1354	<	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;
1560	>	vector<int> ivec;
1561	>	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562
1563	+	#line 1564 "MDTreeParser.cpp"
1564	+
1565		try {      // for error handling
1566		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1567		_t = ASTNULL;
1568		switch ( _t->getType()) {
1569	<	case MINUS:
1569	>	case ASSIGNEQUAL:
1570		{
1571	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1572	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1573	<	match(_t,MINUS);
1571	>	assignment(_t);
1572	>	_t = _retTree;
1573	>	break;
1574	>	}
1575	>	case MEMBERS:
1576	>	{
1577	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1578	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1579	>	match(_t,MEMBERS);
1580		_t = _t->getFirstChild();
1581	<	{
1582	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1583	<	_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;
1581	>	ivec=inttuple(_t);
1582	>	_t = _retTree;
1583	>	_t = __t80;
1584		_t = _t->getNextSibling();
1585	+	#line 259 "MDTreeParser.g"
1586	+	currCutoffGroupStamp->setMembers(ivec);
1587	+	#line 1588 "MDTreeParser.cpp"
1588		break;
1589		}
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	–	}
1590		default:
1591		{
1592		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 1459 | Line 1599 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1599		_t = _t->getNextSibling();
1600		}
1601		_retTree = _t;
1462	–	return dval;
1602		}
1603
1604	+	void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1605	+	ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1606	+
1607	+	try {      // for error handling
1608	+	assignment(_t);
1609	+	_t = _retTree;
1610	+	}
1611	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1612	+	reportError(ex);
1613	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1614	+	_t = _t->getNextSibling();
1615	+	}
1616	+	_retTree = _t;
1617	+	}
1618	+
1619		void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620		{
1621		}
#	Line 1473 | Line 1627 | const char* MDTreeParser::tokenNames[] = {
1627		"\"component\"",
1628		"\"molecule\"",
1629		"\"zconstraint\"",
1630	+	"\"restraint\"",
1631		"\"atom\"",
1632		"\"bond\"",
1633		"\"bend\"",
1634		"\"torsion\"",
1635	+	"\"inversion\"",
1636		"\"rigidBody\"",
1637		"\"cutoffGroup\"",
1638		"\"fragment\"",
1639		"\"members\"",
1640	+	"\"center\"",
1641		"\"position\"",
1642		"\"orientation\"",
1643	+	"\"flucQ\"",
1644	+	"\"RNEMD\"",
1645	+	"\"minimizer\"",
1646		"ENDBLOCK",
1647		"ID",
1648		"ASSIGNEQUAL",
#	Line 1495 | Line 1655 | const char* MDTreeParser::tokenNames[] = {
1655		"LPAREN",
1656		"RPAREN",
1657		"COMMA",
1658	<	"OCTALINT",
1659	<	"DECIMALINT",
1660	<	"HEXADECIMALINT",
1661	<	"PLUS",
1502	<	"MINUS",
1503	<	"FLOATONE",
1504	<	"FLOATTWO",
1658	>	"NUM_INT",
1659	>	"NUM_LONG",
1660	>	"NUM_FLOAT",
1661	>	"NUM_DOUBLE",
1662		"DOT",
1663		"COLON",
1664		"QUESTIONMARK",
#	Line 1514 | Line 1671 | const char* MDTreeParser::tokenNames[] = {
1671		"CharLiteral",
1672		"EndOfLine",
1673		"Escape",
1674	+	"Vocabulary",
1675		"Digit",
1676		"Decimal",
1677	<	"LongSuffix",
1678	<	"UnsignedSuffix",
1679	<	"FloatSuffix",
1522	<	"Exponent",
1523	<	"Vocabulary",
1524	<	"Number",
1677	>	"HEX_DIGIT",
1678	>	"EXPONENT",
1679	>	"FLOAT_SUFFIX",
1680		0
1681		};
1682
1683	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1684	<	// "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"
1683	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1684	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1685		// ASSIGNEQUAL
1686	+	const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1687	+	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1688	+	// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1689	+	// "fragment" ASSIGNEQUAL
1690		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);
1691
1692

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 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

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

Diff Legend

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