[ViewVC] Diff of: OpenMD/branches/development/src/mdParser/MDTreeParser.cpp

Comparing branches/development/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

#	Line 1 \| Line 1
1	<	/* $ANTLR 2.7.7 (20090623): "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 80 \| Line 80 \| void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
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 127 \| Line 145 \| void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
145		ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146		match(_t,COMPONENT);
147		_t = _t->getFirstChild();
148	<	#line 63 "MDTreeParser.g"
148	>	#line 65 "MDTreeParser.g"
149		Component* currComponet = new Component(); blockStack.push(currComponet);
150	<	#line 133 "MDTreeParser.cpp"
150	>	#line 151 "MDTreeParser.cpp"
151		{ // ( ... )*
152		for (;;) {
153		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 150 \| Line 168 \| void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
168		_t = _t->getNextSibling();
169		_t = __t9;
170		_t = _t->getNextSibling();
171	<	#line 65 "MDTreeParser.g"
171	>	#line 67 "MDTreeParser.g"
172		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173	<	#line 156 "MDTreeParser.cpp"
173	>	#line 174 "MDTreeParser.cpp"
174		}
175		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176		reportError(ex);
#	Line 166 \| Line 184 \| void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
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 __t33 = _t;
188		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189		match(_t,MOLECULE);
190		_t = _t->getFirstChild();
191	<	#line 78 "MDTreeParser.g"
191	>	#line 96 "MDTreeParser.g"
192		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193	<	#line 176 "MDTreeParser.cpp"
193	>	#line 194 "MDTreeParser.cpp"
194		{ // ( ... )*
195		for (;;) {
196		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 182 \| Line 200 \| void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200		_t = _retTree;
201		}
202		else {
203	<	goto _loop23;
203	>	goto _loop35;
204		}
205
206		}
207	<	_loop23:;
207	>	_loop35:;
208		} // ( ... )*
209		ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210		match(_t,ENDBLOCK);
211		_t = _t->getNextSibling();
212	<	_t = __t21;
212	>	_t = __t33;
213		_t = _t->getNextSibling();
214	<	#line 80 "MDTreeParser.g"
214	>	#line 98 "MDTreeParser.g"
215		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216	<	#line 199 "MDTreeParser.cpp"
216	>	#line 217 "MDTreeParser.cpp"
217		}
218		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219		reportError(ex);
#	Line 213 \| Line 231 \| void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
231		ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232		match(_t,ZCONSTRAINT);
233		_t = _t->getFirstChild();
234	<	#line 68 "MDTreeParser.g"
234	>	#line 70 "MDTreeParser.g"
235		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236	<	#line 219 "MDTreeParser.cpp"
236	>	#line 237 "MDTreeParser.cpp"
237		{ // ( ... )*
238		for (;;) {
239		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 236 \| Line 254 \| void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
254		_t = _t->getNextSibling();
255		_t = __t13;
256		_t = _t->getNextSibling();
257	<	#line 70 "MDTreeParser.g"
257	>	#line 72 "MDTreeParser.g"
258		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259	<	#line 242 "MDTreeParser.cpp"
259	>	#line 260 "MDTreeParser.cpp"
260		}
261		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262		reportError(ex);
#	Line 256 \| Line 274 \| void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
274		ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275		match(_t,RESTRAINT);
276		_t = _t->getFirstChild();
277	<	#line 73 "MDTreeParser.g"
277	>	#line 75 "MDTreeParser.g"
278		RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279	<	#line 262 "MDTreeParser.cpp"
279	>	#line 280 "MDTreeParser.cpp"
280		{ // ( ... )*
281		for (;;) {
282		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 279 \| Line 297 \| void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
297		_t = _t->getNextSibling();
298		_t = __t17;
299		_t = _t->getNextSibling();
300	<	#line 75 "MDTreeParser.g"
300	>	#line 77 "MDTreeParser.g"
301		blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302	<	#line 285 "MDTreeParser.cpp"
302	>	#line 303 "MDTreeParser.cpp"
303		}
304		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305		reportError(ex);
#	Line 291 \| Line 309 \| void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
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 __t21 = _t;
317	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318	+	match(_t,FLUCQ);
319	+	_t = _t->getFirstChild();
320	+	#line 80 "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 _loop23;
333	+	}
334	+
335	+	}
336	+	_loop23:;
337	+	} // ( ... )*
338	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339	+	match(_t,ENDBLOCK);
340	+	_t = _t->getNextSibling();
341	+	_t = __t21;
342	+	_t = _t->getNextSibling();
343	+	#line 82 "MDTreeParser.g"
344	+	blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345	+	#line 346 "MDTreeParser.cpp"
346	+	}
347	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348	+	reportError(ex);
349	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
350	+	_t = _t->getNextSibling();
351	+	}
352	+	_retTree = _t;
353	+	}
354	+
355	+	void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
356	+	ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
357	+
358	+	try { // for error handling
359	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t25 = _t;
360	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361	+	match(_t,RNEMD);
362	+	_t = _t->getFirstChild();
363	+	#line 85 "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 _loop27;
376	+	}
377	+
378	+	}
379	+	_loop27:;
380	+	} // ( ... )*
381	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382	+	match(_t,ENDBLOCK);
383	+	_t = _t->getNextSibling();
384	+	_t = __t25;
385	+	_t = _t->getNextSibling();
386	+	#line 87 "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 __t29 = _t;
403	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404	+	match(_t,MINIMIZER);
405	+	_t = _t->getFirstChild();
406	+	#line 90 "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 _loop31;
419	+	}
420	+
421	+	}
422	+	_loop31:;
423	+	} // ( ... )*
424	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425	+	match(_t,ENDBLOCK);
426	+	_t = _t->getNextSibling();
427	+	_t = __t29;
428	+	_t = _t->getNextSibling();
429	+	#line 92 "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 == 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 48 "MDTreeParser.g"
447	>	#line 50 "MDTreeParser.g"
448
449		int ival;
450		RealType dval;
451
452	<	#line 306 "MDTreeParser.cpp"
452	>	#line 453 "MDTreeParser.cpp"
453
454		try { // for error handling
455		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 313 \| Line 460 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
460		{
461		ival=intConst(_t);
462		_t = _retTree;
463	<	#line 53 "MDTreeParser.g"
463	>	#line 55 "MDTreeParser.g"
464		blockStack.top()->assign(id->getText(), ival);
465	<	#line 319 "MDTreeParser.cpp"
465	>	#line 466 "MDTreeParser.cpp"
466		break;
467		}
468		case NUM_FLOAT:
#	Line 323 \| Line 470 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
470		{
471		dval=floatConst(_t);
472		_t = _retTree;
473	<	#line 54 "MDTreeParser.g"
473	>	#line 56 "MDTreeParser.g"
474		blockStack.top()->assign(id->getText(), dval);
475	<	#line 329 "MDTreeParser.cpp"
475	>	#line 476 "MDTreeParser.cpp"
476		break;
477		}
478		case ID:
#	Line 333 \| Line 480 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
480		str1 = _t;
481		match(_t,ID);
482		_t = _t->getNextSibling();
483	<	#line 55 "MDTreeParser.g"
483	>	#line 57 "MDTreeParser.g"
484		blockStack.top()->assign(id->getText(), str1->getText());
485	<	#line 339 "MDTreeParser.cpp"
485	>	#line 486 "MDTreeParser.cpp"
486		break;
487		}
488		case StringLiteral:
#	Line 343 \| Line 490 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
490		str2 = _t;
491		match(_t,StringLiteral);
492		_t = _t->getNextSibling();
493	<	#line 56 "MDTreeParser.g"
493	>	#line 58 "MDTreeParser.g"
494		std::string s = str2->getText();
495		s = s.substr(1, s.length()-2);
496		blockStack.top()->assign(id->getText(),s);
497
498	<	#line 352 "MDTreeParser.cpp"
498	>	#line 499 "MDTreeParser.cpp"
499		break;
500		}
501		default:
#	Line 366 \| Line 513 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
513		}
514
515		int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
516	<	#line 268 "MDTreeParser.g"
516	>	#line 286 "MDTreeParser.g"
517		int ival;
518	<	#line 372 "MDTreeParser.cpp"
518	>	#line 519 "MDTreeParser.cpp"
519		ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
520		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
521		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 382 \| Line 529 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
529		i1 = _t;
530		match(_t,NUM_INT);
531		_t = _t->getNextSibling();
532	<	#line 269 "MDTreeParser.g"
532	>	#line 287 "MDTreeParser.g"
533		ival = lexi_cast<int>(i1->getText());
534	<	#line 388 "MDTreeParser.cpp"
534	>	#line 535 "MDTreeParser.cpp"
535		break;
536		}
537		case NUM_LONG:
#	Line 392 \| Line 539 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
539		i2 = _t;
540		match(_t,NUM_LONG);
541		_t = _t->getNextSibling();
542	<	#line 270 "MDTreeParser.g"
542	>	#line 288 "MDTreeParser.g"
543		ival = lexi_cast<int>(i2->getText());
544	<	#line 398 "MDTreeParser.cpp"
544	>	#line 545 "MDTreeParser.cpp"
545		break;
546		}
547		default:
#	Line 413 \| Line 560 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
560		}
561
562		RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
563	<	#line 282 "MDTreeParser.g"
563	>	#line 300 "MDTreeParser.g"
564		RealType dval;
565	<	#line 419 "MDTreeParser.cpp"
565	>	#line 566 "MDTreeParser.cpp"
566		ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
567		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
568		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 429 \| Line 576 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
576		d1 = _t;
577		match(_t,NUM_FLOAT);
578		_t = _t->getNextSibling();
579	<	#line 283 "MDTreeParser.g"
579	>	#line 301 "MDTreeParser.g"
580		dval = lexi_cast<RealType>(d1->getText());
581	<	#line 435 "MDTreeParser.cpp"
581	>	#line 582 "MDTreeParser.cpp"
582		break;
583		}
584		case NUM_DOUBLE:
#	Line 439 \| Line 586 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
586		d2 = _t;
587		match(_t,NUM_DOUBLE);
588		_t = _t->getNextSibling();
589	<	#line 284 "MDTreeParser.g"
589	>	#line 302 "MDTreeParser.g"
590		dval = lexi_cast<RealType>(d2->getText());
591	<	#line 445 "MDTreeParser.cpp"
591	>	#line 592 "MDTreeParser.cpp"
592		break;
593		}
594		default:
#	Line 536 \| Line 683 \| void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
683
684		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
685		ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
686	<	#line 94 "MDTreeParser.g"
686	>	#line 112 "MDTreeParser.g"
687
688		int index;
689
690	<	#line 544 "MDTreeParser.cpp"
690	>	#line 691 "MDTreeParser.cpp"
691
692		try { // for error handling
693	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
694	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
693	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
694	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
695		match(_t,ATOM);
696		_t = _t->getFirstChild();
697		index=intConst(_t);
698		_t = _retTree;
699	<	#line 98 "MDTreeParser.g"
699	>	#line 116 "MDTreeParser.g"
700		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
701	<	#line 555 "MDTreeParser.cpp"
701	>	#line 702 "MDTreeParser.cpp"
702		{ // ( ... )*
703		for (;;) {
704		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 561 \| Line 708 \| void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
708		_t = _retTree;
709		}
710		else {
711	<	goto _loop28;
711	>	goto _loop40;
712		}
713
714		}
715	<	_loop28:;
715	>	_loop40:;
716		} // ( ... )*
717	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
717	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
718		match(_t,ENDBLOCK);
719		_t = _t->getNextSibling();
720	<	_t = __t26;
720	>	_t = __t38;
721		_t = _t->getNextSibling();
722	<	#line 100 "MDTreeParser.g"
722	>	#line 118 "MDTreeParser.g"
723
724		blockStack.top()->validate();
725		blockStack.pop();
726		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
727		currMoleculeStamp->addAtomStamp(currAtomStamp);
728
729	<	#line 583 "MDTreeParser.cpp"
729	>	#line 730 "MDTreeParser.cpp"
730		}
731		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
732		reportError(ex);
#	Line 593 \| Line 740 \| void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
740		ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
741
742		try { // for error handling
743	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
744	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
743	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
744	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745		match(_t,BOND);
746		_t = _t->getFirstChild();
747	<	#line 120 "MDTreeParser.g"
747	>	#line 138 "MDTreeParser.g"
748		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
749	<	#line 603 "MDTreeParser.cpp"
749	>	#line 750 "MDTreeParser.cpp"
750		{ // ( ... )*
751		for (;;) {
752		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 609 \| Line 756 \| void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
756		_t = _retTree;
757		}
758		else {
759	<	goto _loop35;
759	>	goto _loop47;
760		}
761
762		}
763	<	_loop35:;
763	>	_loop47:;
764		} // ( ... )*
765	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
765	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
766		match(_t,ENDBLOCK);
767		_t = _t->getNextSibling();
768	<	_t = __t33;
768	>	_t = __t45;
769		_t = _t->getNextSibling();
770	<	#line 122 "MDTreeParser.g"
770	>	#line 140 "MDTreeParser.g"
771
772		blockStack.pop();
773		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
774		currMoleculeStamp->addBondStamp(currBondStamp);
775
776	<	#line 630 "MDTreeParser.cpp"
776	>	#line 777 "MDTreeParser.cpp"
777		}
778		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
779		reportError(ex);
#	Line 640 \| Line 787 \| void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
787		ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
788
789		try { // for error handling
790	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
791	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
790	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
791	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
792		match(_t,BEND);
793		_t = _t->getFirstChild();
794	<	#line 138 "MDTreeParser.g"
794	>	#line 156 "MDTreeParser.g"
795		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
796	<	#line 650 "MDTreeParser.cpp"
796	>	#line 797 "MDTreeParser.cpp"
797		{ // ( ... )*
798		for (;;) {
799		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 656 \| Line 803 \| void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
803		_t = _retTree;
804		}
805		else {
806	<	goto _loop41;
806	>	goto _loop53;
807		}
808
809		}
810	<	_loop41:;
810	>	_loop53:;
811		} // ( ... )*
812	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
812	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
813		match(_t,ENDBLOCK);
814		_t = _t->getNextSibling();
815	<	_t = __t39;
815	>	_t = __t51;
816		_t = _t->getNextSibling();
817	<	#line 140 "MDTreeParser.g"
817	>	#line 158 "MDTreeParser.g"
818
819		blockStack.top()->validate();
820		blockStack.pop();
821		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
822		currMoleculeStamp->addBendStamp(currBendStamp);
823
824	<	#line 678 "MDTreeParser.cpp"
824	>	#line 825 "MDTreeParser.cpp"
825		}
826		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
827		reportError(ex);
#	Line 688 \| Line 835 \| void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
835		ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
836
837		try { // for error handling
838	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
839	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
838	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
839	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
840		match(_t,TORSION);
841		_t = _t->getFirstChild();
842	<	#line 157 "MDTreeParser.g"
842	>	#line 175 "MDTreeParser.g"
843		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
844	<	#line 698 "MDTreeParser.cpp"
844	>	#line 845 "MDTreeParser.cpp"
845		{ // ( ... )*
846		for (;;) {
847		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 704 \| Line 851 \| void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
851		_t = _retTree;
852		}
853		else {
854	<	goto _loop47;
854	>	goto _loop59;
855		}
856
857		}
858	<	_loop47:;
858	>	_loop59:;
859		} // ( ... )*
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
860	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
861		match(_t,ENDBLOCK);
862		_t = _t->getNextSibling();
863	<	_t = __t45;
863	>	_t = __t57;
864		_t = _t->getNextSibling();
865	<	#line 159 "MDTreeParser.g"
865	>	#line 177 "MDTreeParser.g"
866
867		blockStack.top()->validate();
868		blockStack.pop();
869		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
870		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
871
872	<	#line 726 "MDTreeParser.cpp"
872	>	#line 873 "MDTreeParser.cpp"
873		}
874		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
875		reportError(ex);
#	Line 736 \| Line 883 \| void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
883		ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
884
885		try { // for error handling
886	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
887	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
886	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
887	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
888		match(_t,INVERSION);
889		_t = _t->getFirstChild();
890	<	#line 176 "MDTreeParser.g"
890	>	#line 194 "MDTreeParser.g"
891		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
892	<	#line 746 "MDTreeParser.cpp"
892	>	#line 893 "MDTreeParser.cpp"
893		{ // ( ... )*
894		for (;;) {
895		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 752 \| Line 899 \| void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
899		_t = _retTree;
900		}
901		else {
902	<	goto _loop53;
902	>	goto _loop65;
903		}
904
905		}
906	<	_loop53:;
906	>	_loop65:;
907		} // ( ... )*
908	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
908	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
909		match(_t,ENDBLOCK);
910		_t = _t->getNextSibling();
911	<	_t = __t51;
911	>	_t = __t63;
912		_t = _t->getNextSibling();
913	<	#line 178 "MDTreeParser.g"
913	>	#line 196 "MDTreeParser.g"
914
915		blockStack.top()->validate();
916		blockStack.pop();
917		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
918		currMoleculeStamp->addInversionStamp(currInversionStamp);
919
920	<	#line 774 "MDTreeParser.cpp"
920	>	#line 921 "MDTreeParser.cpp"
921		}
922		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
923		reportError(ex);
#	Line 782 \| Line 929 \| void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
929
930		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
931		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
932	<	#line 195 "MDTreeParser.g"
932	>	#line 213 "MDTreeParser.g"
933
934		int index;
935
936	<	#line 790 "MDTreeParser.cpp"
936	>	#line 937 "MDTreeParser.cpp"
937
938		try { // for error handling
939	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
940	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
939	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
940	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
941		match(_t,RIGIDBODY);
942		_t = _t->getFirstChild();
943		index=intConst(_t);
944		_t = _retTree;
945	<	#line 199 "MDTreeParser.g"
945	>	#line 217 "MDTreeParser.g"
946		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
947	<	#line 801 "MDTreeParser.cpp"
947	>	#line 948 "MDTreeParser.cpp"
948		{ // ( ... )*
949		for (;;) {
950		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 807 \| Line 954 \| void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
954		_t = _retTree;
955		}
956		else {
957	<	goto _loop59;
957	>	goto _loop71;
958		}
959
960		}
961	<	_loop59:;
961	>	_loop71:;
962		} // ( ... )*
963	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
963	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
964		match(_t,ENDBLOCK);
965		_t = _t->getNextSibling();
966	<	_t = __t57;
966	>	_t = __t69;
967		_t = _t->getNextSibling();
968	<	#line 201 "MDTreeParser.g"
968	>	#line 219 "MDTreeParser.g"
969
970		blockStack.top()->validate();
971		blockStack.pop();
972		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
973		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
974
975	<	#line 829 "MDTreeParser.cpp"
975	>	#line 976 "MDTreeParser.cpp"
976		}
977		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
978		reportError(ex);
#	Line 839 \| Line 986 \| void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
986		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
987
988		try { // for error handling
989	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
990	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
989	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
990	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
991		match(_t,CUTOFFGROUP);
992		_t = _t->getFirstChild();
993	<	#line 218 "MDTreeParser.g"
993	>	#line 236 "MDTreeParser.g"
994		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
995	<	#line 849 "MDTreeParser.cpp"
995	>	#line 996 "MDTreeParser.cpp"
996		{ // ( ... )*
997		for (;;) {
998		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 855 \| Line 1002 \| void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1002		_t = _retTree;
1003		}
1004		else {
1005	<	goto _loop65;
1005	>	goto _loop77;
1006		}
1007
1008		}
1009	<	_loop65:;
1009	>	_loop77:;
1010		} // ( ... )*
1011	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1011	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1012		match(_t,ENDBLOCK);
1013		_t = _t->getNextSibling();
1014	<	_t = __t63;
1014	>	_t = __t75;
1015		_t = _t->getNextSibling();
1016	<	#line 220 "MDTreeParser.g"
1016	>	#line 238 "MDTreeParser.g"
1017
1018		blockStack.top()->validate();
1019		blockStack.pop();
1020		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1021		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1022
1023	<	#line 877 "MDTreeParser.cpp"
1023	>	#line 1024 "MDTreeParser.cpp"
1024		}
1025		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1026		reportError(ex);
#	Line 885 \| Line 1032 \| void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1032
1033		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1034		ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1035	<	#line 237 "MDTreeParser.g"
1035	>	#line 255 "MDTreeParser.g"
1036		int ival;
1037	<	#line 891 "MDTreeParser.cpp"
1037	>	#line 1038 "MDTreeParser.cpp"
1038
1039		try { // for error handling
1040	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1041	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1040	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1041	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1042		match(_t,FRAGMENT);
1043		_t = _t->getFirstChild();
1044		ival=intConst(_t);
1045		_t = _retTree;
1046	<	#line 238 "MDTreeParser.g"
1046	>	#line 256 "MDTreeParser.g"
1047		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1048	<	#line 902 "MDTreeParser.cpp"
1048	>	#line 1049 "MDTreeParser.cpp"
1049		{ // ( ... )*
1050		for (;;) {
1051		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 908 \| Line 1055 \| void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1055		_t = _retTree;
1056		}
1057		else {
1058	<	goto _loop71;
1058	>	goto _loop83;
1059		}
1060
1061		}
1062	<	_loop71:;
1062	>	_loop83:;
1063		} // ( ... )*
1064	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1064	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1065		match(_t,ENDBLOCK);
1066		_t = _t->getNextSibling();
1067	<	_t = __t69;
1067	>	_t = __t81;
1068		_t = _t->getNextSibling();
1069	<	#line 240 "MDTreeParser.g"
1069	>	#line 258 "MDTreeParser.g"
1070
1071		blockStack.top()->validate();
1072		blockStack.pop();
1073		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1074		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1075
1076	<	#line 930 "MDTreeParser.cpp"
1076	>	#line 1077 "MDTreeParser.cpp"
1077		}
1078		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1079		reportError(ex);
#	Line 938 \| Line 1085 \| void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1085
1086		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1087		ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088	<	#line 108 "MDTreeParser.g"
1088	>	#line 126 "MDTreeParser.g"
1089
1090		vector<RealType> dvec;
1091		AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1092
1093
1094	<	#line 948 "MDTreeParser.cpp"
1094	>	#line 1095 "MDTreeParser.cpp"
1095
1096		try { // for error handling
1097		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 958 \| Line 1105 \| void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1105		}
1106		case POSITION:
1107		{
1108	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1109	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1108	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t42 = _t;
1109	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1110		match(_t,POSITION);
1111		_t = _t->getFirstChild();
1112		dvec=doubleNumberTuple(_t);
1113		_t = _retTree;
1114	<	_t = __t30;
1114	>	_t = __t42;
1115		_t = _t->getNextSibling();
1116	<	#line 115 "MDTreeParser.g"
1116	>	#line 133 "MDTreeParser.g"
1117		currAtomStamp->setPosition(dvec);
1118	<	#line 972 "MDTreeParser.cpp"
1118	>	#line 1119 "MDTreeParser.cpp"
1119		break;
1120		}
1121		case ORIENTATION:
1122		{
1123	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1124	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1123	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1124	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1125		match(_t,ORIENTATION);
1126		_t = _t->getFirstChild();
1127		dvec=doubleNumberTuple(_t);
1128		_t = _retTree;
1129	<	_t = __t31;
1129	>	_t = __t43;
1130		_t = _t->getNextSibling();
1131	<	#line 116 "MDTreeParser.g"
1131	>	#line 134 "MDTreeParser.g"
1132		currAtomStamp->setOrientation(dvec);
1133	<	#line 987 "MDTreeParser.cpp"
1133	>	#line 1134 "MDTreeParser.cpp"
1134		break;
1135		}
1136		default:
#	Line 1001 \| Line 1148 \| vector<RealType> MDTreeParser::doubleNumberTuple(ANTL
1148		}
1149
1150		vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151	<	#line 253 "MDTreeParser.g"
1151	>	#line 271 "MDTreeParser.g"
1152		vector<RealType> dvec;
1153	<	#line 1007 "MDTreeParser.cpp"
1153	>	#line 1154 "MDTreeParser.cpp"
1154		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1155	<	#line 253 "MDTreeParser.g"
1155	>	#line 271 "MDTreeParser.g"
1156
1157		RealType dval;
1158
1159	<	#line 1013 "MDTreeParser.cpp"
1159	>	#line 1160 "MDTreeParser.cpp"
1160
1161		try { // for error handling
1162		{ // ( ... )+
1163	<	int _cnt75=0;
1163	>	int _cnt87=0;
1164		for (;;) {
1165		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1166		_t = ASTNULL;
1167		if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1168		dval=doubleNumber(_t);
1169		_t = _retTree;
1170	<	#line 257 "MDTreeParser.g"
1170	>	#line 275 "MDTreeParser.g"
1171		dvec.push_back(dval);
1172	<	#line 1026 "MDTreeParser.cpp"
1172	>	#line 1173 "MDTreeParser.cpp"
1173		}
1174		else {
1175	<	if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1175	>	if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1176		}
1177
1178	<	_cnt75++;
1178	>	_cnt87++;
1179		}
1180	<	_loop75:;
1180	>	_loop87:;
1181		} // ( ... )+
1182		}
1183		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1044 \| Line 1191 \| void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1191
1192		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1193		ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1194	<	#line 129 "MDTreeParser.g"
1194	>	#line 147 "MDTreeParser.g"
1195
1196		vector<int> ivec;
1197		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1198
1199	<	#line 1053 "MDTreeParser.cpp"
1199	>	#line 1200 "MDTreeParser.cpp"
1200
1201		try { // for error handling
1202		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1063 \| Line 1210 \| void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1210		}
1211		case MEMBERS:
1212		{
1213	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1214	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1213	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1214	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1215		match(_t,MEMBERS);
1216		_t = _t->getFirstChild();
1217		ivec=inttuple(_t);
1218		_t = _retTree;
1219	<	_t = __t37;
1219	>	_t = __t49;
1220		_t = _t->getNextSibling();
1221	<	#line 135 "MDTreeParser.g"
1221	>	#line 153 "MDTreeParser.g"
1222		currBondStamp->setMembers(ivec);
1223	<	#line 1077 "MDTreeParser.cpp"
1223	>	#line 1224 "MDTreeParser.cpp"
1224		break;
1225		}
1226		default:
#	Line 1091 \| Line 1238 \| vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1238		}
1239
1240		vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1241	<	#line 260 "MDTreeParser.g"
1241	>	#line 278 "MDTreeParser.g"
1242		vector<int> ivec;
1243	<	#line 1097 "MDTreeParser.cpp"
1243	>	#line 1244 "MDTreeParser.cpp"
1244		ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1245	<	#line 260 "MDTreeParser.g"
1245	>	#line 278 "MDTreeParser.g"
1246
1247		int ival;
1248
1249	<	#line 1103 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250
1251		try { // for error handling
1252		{ // ( ... )+
1253	<	int _cnt78=0;
1253	>	int _cnt90=0;
1254		for (;;) {
1255		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1256		_t = ASTNULL;
1257		if ((_t->getType() == NUM_INT \|\| _t->getType() == NUM_LONG)) {
1258		ival=intConst(_t);
1259		_t = _retTree;
1260	<	#line 264 "MDTreeParser.g"
1260	>	#line 282 "MDTreeParser.g"
1261		ivec.push_back(ival);
1262	<	#line 1116 "MDTreeParser.cpp"
1262	>	#line 1263 "MDTreeParser.cpp"
1263		}
1264		else {
1265	<	if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1265	>	if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1266		}
1267
1268	<	_cnt78++;
1268	>	_cnt90++;
1269		}
1270	<	_loop78:;
1270	>	_loop90:;
1271		} // ( ... )+
1272		}
1273		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
#	Line 1134 \| Line 1281 \| void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1281
1282		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1283		ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1284	<	#line 148 "MDTreeParser.g"
1284	>	#line 166 "MDTreeParser.g"
1285
1286		vector<int> ivec;
1287		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1288
1289	<	#line 1143 "MDTreeParser.cpp"
1289	>	#line 1290 "MDTreeParser.cpp"
1290
1291		try { // for error handling
1292		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1153 \| Line 1300 \| void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1300		}
1301		case MEMBERS:
1302		{
1303	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1304	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1303	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1304	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1305		match(_t,MEMBERS);
1306		_t = _t->getFirstChild();
1307		ivec=inttuple(_t);
1308		_t = _retTree;
1309	<	_t = __t43;
1309	>	_t = __t55;
1310		_t = _t->getNextSibling();
1311	<	#line 154 "MDTreeParser.g"
1311	>	#line 172 "MDTreeParser.g"
1312		currBendStamp->setMembers(ivec);
1313	<	#line 1167 "MDTreeParser.cpp"
1313	>	#line 1314 "MDTreeParser.cpp"
1314		break;
1315		}
1316		default:
#	Line 1182 \| Line 1329 \| void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1329
1330		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1331		ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1332	<	#line 167 "MDTreeParser.g"
1332	>	#line 185 "MDTreeParser.g"
1333
1334		vector<int> ivec;
1335		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1336
1337	<	#line 1191 "MDTreeParser.cpp"
1337	>	#line 1338 "MDTreeParser.cpp"
1338
1339		try { // for error handling
1340		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1201 \| Line 1348 \| void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1348		}
1349		case MEMBERS:
1350		{
1351	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1352	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1351	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1352	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1353		match(_t,MEMBERS);
1354		_t = _t->getFirstChild();
1355		ivec=inttuple(_t);
1356		_t = _retTree;
1357	<	_t = __t49;
1357	>	_t = __t61;
1358		_t = _t->getNextSibling();
1359	<	#line 173 "MDTreeParser.g"
1359	>	#line 191 "MDTreeParser.g"
1360		currTorsionStamp->setMembers(ivec);
1361	<	#line 1215 "MDTreeParser.cpp"
1361	>	#line 1362 "MDTreeParser.cpp"
1362		break;
1363		}
1364		default:
#	Line 1230 \| Line 1377 \| void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1377
1378		void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1379		ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380	<	#line 186 "MDTreeParser.g"
1380	>	#line 204 "MDTreeParser.g"
1381
1382		int icent;
1383		InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1384
1385	<	#line 1239 "MDTreeParser.cpp"
1385	>	#line 1386 "MDTreeParser.cpp"
1386
1387		try { // for error handling
1388		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1249 \| Line 1396 \| void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1396		}
1397		case CENTER:
1398		{
1399	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1400	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1399	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1400	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1401		match(_t,CENTER);
1402		_t = _t->getFirstChild();
1403		icent=intConst(_t);
1404		_t = _retTree;
1405	<	_t = __t55;
1405	>	_t = __t67;
1406		_t = _t->getNextSibling();
1407	<	#line 192 "MDTreeParser.g"
1407	>	#line 210 "MDTreeParser.g"
1408		currInversionStamp->setCenter(icent);
1409	<	#line 1263 "MDTreeParser.cpp"
1409	>	#line 1410 "MDTreeParser.cpp"
1410		break;
1411		}
1412		default:
#	Line 1278 \| Line 1425 \| void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1425
1426		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1427		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1428	<	#line 209 "MDTreeParser.g"
1428	>	#line 227 "MDTreeParser.g"
1429
1430		vector<int> ivec;
1431		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1432
1433	<	#line 1287 "MDTreeParser.cpp"
1433	>	#line 1434 "MDTreeParser.cpp"
1434
1435		try { // for error handling
1436		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1297 \| Line 1444 \| void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1444		}
1445		case MEMBERS:
1446		{
1447	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1448	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1447	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t73 = _t;
1448	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1449		match(_t,MEMBERS);
1450		_t = _t->getFirstChild();
1451		ivec=inttuple(_t);
1452		_t = _retTree;
1453	<	_t = __t61;
1453	>	_t = __t73;
1454		_t = _t->getNextSibling();
1455	<	#line 215 "MDTreeParser.g"
1455	>	#line 233 "MDTreeParser.g"
1456		currRigidBodyStamp->setMembers(ivec);
1457	<	#line 1311 "MDTreeParser.cpp"
1457	>	#line 1458 "MDTreeParser.cpp"
1458		break;
1459		}
1460		default:
#	Line 1326 \| Line 1473 \| void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1473
1474		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1475		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1476	<	#line 228 "MDTreeParser.g"
1476	>	#line 246 "MDTreeParser.g"
1477
1478		vector<int> ivec;
1479		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1480
1481	<	#line 1335 "MDTreeParser.cpp"
1481	>	#line 1482 "MDTreeParser.cpp"
1482
1483		try { // for error handling
1484		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1345 \| Line 1492 \| void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1492		}
1493		case MEMBERS:
1494		{
1495	<	ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1496	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1495	>	ANTLR_USE_NAMESPACE(antlr)RefAST __t79 = _t;
1496	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1497		match(_t,MEMBERS);
1498		_t = _t->getFirstChild();
1499		ivec=inttuple(_t);
1500		_t = _retTree;
1501	<	_t = __t67;
1501	>	_t = __t79;
1502		_t = _t->getNextSibling();
1503	<	#line 234 "MDTreeParser.g"
1503	>	#line 252 "MDTreeParser.g"
1504		currCutoffGroupStamp->setMembers(ivec);
1505	<	#line 1359 "MDTreeParser.cpp"
1505	>	#line 1506 "MDTreeParser.cpp"
1506		break;
1507		}
1508		default:
#	Line 1388 \| Line 1535 \| RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1535		}
1536
1537		RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538	<	#line 274 "MDTreeParser.g"
1538	>	#line 292 "MDTreeParser.g"
1539		RealType dval;
1540	<	#line 1394 "MDTreeParser.cpp"
1540	>	#line 1541 "MDTreeParser.cpp"
1541		ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1542		ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1543		ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 1405 \| Line 1552 \| RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1552		ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1553		intConst(_t);
1554		_t = _retTree;
1555	<	#line 276 "MDTreeParser.g"
1555	>	#line 294 "MDTreeParser.g"
1556		dval = lexi_cast<RealType>(ic->getText());
1557	<	#line 1411 "MDTreeParser.cpp"
1557	>	#line 1558 "MDTreeParser.cpp"
1558		break;
1559		}
1560		case NUM_FLOAT:
#	Line 1416 \| Line 1563 \| RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1563		fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1564		floatConst(_t);
1565		_t = _retTree;
1566	<	#line 277 "MDTreeParser.g"
1566	>	#line 295 "MDTreeParser.g"
1567		dval = lexi_cast<RealType>(fc->getText());
1568	<	#line 1422 "MDTreeParser.cpp"
1568	>	#line 1569 "MDTreeParser.cpp"
1569		break;
1570		}
1571		default:
#	Line 1460 \| Line 1607 \| *const char MDTreeParser::tokenNames[] = {**
1607		"\"center\"",
1608		"\"position\"",
1609		"\"orientation\"",
1610	+	"\"flucQ\"",
1611	+	"\"RNEMD\"",
1612	+	"\"minimizer\"",
1613		"ENDBLOCK",
1614		"ID",
1615		"ASSIGNEQUAL",
#	Line 1497 \| Line 1647 \| *const char MDTreeParser::tokenNames[] = {**
1647		0
1648		};
1649
1650	<	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1651	<	// "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL
1650	>	const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1651	>	// "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1652	>	// ASSIGNEQUAL
1653		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1654	<	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
1654	>	const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1655		// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1656		// "fragment" ASSIGNEQUAL
1657		const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Diff Legend

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

Comparing branches/development/src/mdParser/MDTreeParser.cpp (file contents): Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs. Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

Diff Legend

Comparing branches/development/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC