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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 2025 by gezelter, Sat Apr 5 20:56:01 2014 UTC vs.
Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

#	Line 1 \| Line 1
1	<	/* $ANTLR 2.7.7 (20140107): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1	>	/* $ANTLR 2.7.7 (20131114): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2		#include "MDTreeParser.hpp"
3		#include <antlr/Token.hpp>
4		#include <antlr/AST.hpp>
#	Line 145 \| 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 72 "MDTreeParser.g"
148	>	#line 70 "MDTreeParser.g"
149		Component* currComponet = new Component(); blockStack.push(currComponet);
150		#line 151 "MDTreeParser.cpp"
151		{ // ( ... )*
#	Line 168 \| Line 168 \| void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
168		_t = _t->getNextSibling();
169		_t = __t10;
170		_t = _t->getNextSibling();
171	<	#line 74 "MDTreeParser.g"
171	>	#line 72 "MDTreeParser.g"
172		blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173		#line 174 "MDTreeParser.cpp"
174		}
#	Line 188 \| Line 188 \| void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
188		ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189		match(_t,MOLECULE);
190		_t = _t->getFirstChild();
191	<	#line 103 "MDTreeParser.g"
191	>	#line 101 "MDTreeParser.g"
192		MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193		#line 194 "MDTreeParser.cpp"
194		{ // ( ... )*
#	Line 211 \| Line 211 \| void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
211		_t = _t->getNextSibling();
212		_t = __t34;
213		_t = _t->getNextSibling();
214	<	#line 105 "MDTreeParser.g"
214	>	#line 103 "MDTreeParser.g"
215		blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216		#line 217 "MDTreeParser.cpp"
217		}
#	Line 231 \| 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 77 "MDTreeParser.g"
234	>	#line 75 "MDTreeParser.g"
235		ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236		#line 237 "MDTreeParser.cpp"
237		{ // ( ... )*
#	Line 254 \| Line 254 \| void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
254		_t = _t->getNextSibling();
255		_t = __t14;
256		_t = _t->getNextSibling();
257	<	#line 79 "MDTreeParser.g"
257	>	#line 77 "MDTreeParser.g"
258		blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259		#line 260 "MDTreeParser.cpp"
260		}
#	Line 274 \| 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 82 "MDTreeParser.g"
277	>	#line 80 "MDTreeParser.g"
278		RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279		#line 280 "MDTreeParser.cpp"
280		{ // ( ... )*
#	Line 297 \| Line 297 \| void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
297		_t = _t->getNextSibling();
298		_t = __t18;
299		_t = _t->getNextSibling();
300	<	#line 84 "MDTreeParser.g"
300	>	#line 82 "MDTreeParser.g"
301		blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302		#line 303 "MDTreeParser.cpp"
303		}
#	Line 317 \| Line 317 \| void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
317		ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318		match(_t,FLUCQ);
319		_t = _t->getFirstChild();
320	<	#line 87 "MDTreeParser.g"
320	>	#line 85 "MDTreeParser.g"
321		FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322		#line 323 "MDTreeParser.cpp"
323		{ // ( ... )*
#	Line 340 \| Line 340 \| void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
340		_t = _t->getNextSibling();
341		_t = __t22;
342		_t = _t->getNextSibling();
343	<	#line 89 "MDTreeParser.g"
343	>	#line 87 "MDTreeParser.g"
344		blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345		#line 346 "MDTreeParser.cpp"
346		}
#	Line 360 \| Line 360 \| void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
360		ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361		match(_t,RNEMD);
362		_t = _t->getFirstChild();
363	<	#line 92 "MDTreeParser.g"
363	>	#line 90 "MDTreeParser.g"
364		RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365		#line 366 "MDTreeParser.cpp"
366		{ // ( ... )*
#	Line 383 \| Line 383 \| void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
383		_t = _t->getNextSibling();
384		_t = __t26;
385		_t = _t->getNextSibling();
386	<	#line 94 "MDTreeParser.g"
386	>	#line 92 "MDTreeParser.g"
387		blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388		#line 389 "MDTreeParser.cpp"
389		}
#	Line 403 \| Line 403 \| void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(
403		ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404		match(_t,MINIMIZER);
405		_t = _t->getFirstChild();
406	<	#line 97 "MDTreeParser.g"
406	>	#line 95 "MDTreeParser.g"
407		MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408		#line 409 "MDTreeParser.cpp"
409		{ // ( ... )*
#	Line 426 \| Line 426 \| void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(
426		_t = _t->getNextSibling();
427		_t = __t30;
428		_t = _t->getNextSibling();
429	<	#line 99 "MDTreeParser.g"
429	>	#line 97 "MDTreeParser.g"
430		blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431		#line 432 "MDTreeParser.cpp"
432		}
#	Line 448 \| Line 448 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
448
449		int ival;
450		RealType dval, x, y, z;
451	<	Vector3d dvec;
451	>	std::vector<RealType> dvec;
452
453		#line 454 "MDTreeParser.cpp"
454
#	Line 474 \| Line 474 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
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"
477		break;
478		}
479		case ID:
#	Line 513 \| Line 481 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
481		str1 = _t;
482		match(_t,ID);
483		_t = _t->getNextSibling();
484	<	#line 64 "MDTreeParser.g"
484	>	#line 58 "MDTreeParser.g"
485		blockStack.top()->assign(id->getText(), str1->getText());
486	<	#line 519 "MDTreeParser.cpp"
486	>	#line 487 "MDTreeParser.cpp"
487		break;
488		}
489		case StringLiteral:
#	Line 523 \| Line 491 \| void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
491		str2 = _t;
492		match(_t,StringLiteral);
493		_t = _t->getNextSibling();
494	<	#line 65 "MDTreeParser.g"
494	>	#line 59 "MDTreeParser.g"
495		std::string s = str2->getText();
496		s = s.substr(1, s.length()-2);
497		blockStack.top()->assign(id->getText(),s);
498
499	<	#line 532 "MDTreeParser.cpp"
499	>	#line 500 "MDTreeParser.cpp"
500		break;
501		}
502	+	case LPAREN:
503	+	{
504	+	ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
505	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
506	+	match(_t,LPAREN);
507	+	_t = _t->getFirstChild();
508	+	dvec=doubleNumberTuple(_t);
509	+	_t = _retTree;
510	+	ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
511	+	match(_t,RPAREN);
512	+	_t = _t->getNextSibling();
513	+	_t = __t8;
514	+	_t = _t->getNextSibling();
515	+	#line 64 "MDTreeParser.g"
516	+
517	+	blockStack.top()->assign(id->getText(), dvec);
518	+
519	+	#line 520 "MDTreeParser.cpp"
520	+	break;
521	+	}
522		default:
523		{
524		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
#	Line 546 \| Line 534 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
534		}
535
536		int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
537	<	#line 314 "MDTreeParser.g"
537	>	#line 312 "MDTreeParser.g"
538		int ival;
539	<	#line 552 "MDTreeParser.cpp"
539	>	#line 540 "MDTreeParser.cpp"
540		ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
541		ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
542		ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 562 \| Line 550 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
550		i1 = _t;
551		match(_t,NUM_INT);
552		_t = _t->getNextSibling();
553	<	#line 315 "MDTreeParser.g"
553	>	#line 313 "MDTreeParser.g"
554		ival = lexi_cast<int>(i1->getText());
555	<	#line 568 "MDTreeParser.cpp"
555	>	#line 556 "MDTreeParser.cpp"
556		break;
557		}
558		case NUM_LONG:
#	Line 572 \| Line 560 \| int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
560		i2 = _t;
561		match(_t,NUM_LONG);
562		_t = _t->getNextSibling();
563	<	#line 316 "MDTreeParser.g"
563	>	#line 314 "MDTreeParser.g"
564		ival = lexi_cast<int>(i2->getText());
565	<	#line 578 "MDTreeParser.cpp"
565	>	#line 566 "MDTreeParser.cpp"
566		break;
567		}
568		default:
#	Line 593 \| Line 581 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
581		}
582
583		RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
584	<	#line 326 "MDTreeParser.g"
584	>	#line 324 "MDTreeParser.g"
585		RealType dval;
586	<	#line 599 "MDTreeParser.cpp"
586	>	#line 587 "MDTreeParser.cpp"
587		ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
588		ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
589		ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
#	Line 609 \| Line 597 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
597		d1 = _t;
598		match(_t,NUM_FLOAT);
599		_t = _t->getNextSibling();
600	<	#line 327 "MDTreeParser.g"
600	>	#line 325 "MDTreeParser.g"
601		dval = lexi_cast<RealType>(d1->getText());
602	<	#line 615 "MDTreeParser.cpp"
602	>	#line 603 "MDTreeParser.cpp"
603		break;
604		}
605		case NUM_DOUBLE:
#	Line 619 \| Line 607 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
607		d2 = _t;
608		match(_t,NUM_DOUBLE);
609		_t = _t->getNextSibling();
610	<	#line 328 "MDTreeParser.g"
610	>	#line 326 "MDTreeParser.g"
611		dval = lexi_cast<RealType>(d2->getText());
612	<	#line 625 "MDTreeParser.cpp"
612	>	#line 613 "MDTreeParser.cpp"
613		break;
614		}
615		default:
#	Line 639 \| Line 627 \| RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
627		return dval;
628		}
629
630	<	RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
631	<	#line 320 "MDTreeParser.g"
630	>	vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
631	>	#line 296 "MDTreeParser.g"
632	>	vector<RealType> dvec;
633	>	#line 634 "MDTreeParser.cpp"
634	>	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
635	>	#line 296 "MDTreeParser.g"
636	>
637		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;
638
639	+	#line 640 "MDTreeParser.cpp"
640	+
641		try { // for error handling
642	<	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
643	<	_t = ASTNULL;
644	<	switch ( _t->getType()) {
645	<	case NUM_INT:
646	<	case NUM_LONG:
647	<	{
648	<	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
649	<	intConst(_t);
650	<	_t = _retTree;
651	<	#line 321 "MDTreeParser.g"
652	<	dval = lexi_cast<RealType>(ic->getText());
653	<	#line 663 "MDTreeParser.cpp"
654	<	break;
642	>	{ // ( ... )+
643	>	int _cnt95=0;
644	>	for (;;) {
645	>	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
646	>	_t = ASTNULL;
647	>	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
648	>	dval=doubleNumber(_t);
649	>	_t = _retTree;
650	>	#line 300 "MDTreeParser.g"
651	>	dvec.push_back(dval);
652	>	#line 653 "MDTreeParser.cpp"
653	>	}
654	>	else {
655	>	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
656	>	}
657	>
658	>	_cnt95++;
659		}
660	<	case NUM_FLOAT:
661	<	case NUM_DOUBLE:
667	<	{
668	<	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669	<	floatConst(_t);
670	<	_t = _retTree;
671	<	#line 322 "MDTreeParser.g"
672	<	dval = lexi_cast<RealType>(fc->getText());
673	<	#line 674 "MDTreeParser.cpp"
674	<	break;
675	<	}
676	<	default:
677	<	{
678	<	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
679	<	}
680	<	}
660	>	_loop95:;
661	>	} // ( ... )+
662		}
663		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
664		reportError(ex);
#	Line 685 \| Line 666 \| RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
666		_t = _t->getNextSibling();
667		}
668		_retTree = _t;
669	<	return dval;
669	>	return dvec;
670		}
671
672		void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
#	Line 771 \| Line 752 \| void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
752
753		void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
754		ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
755	<	#line 120 "MDTreeParser.g"
755	>	#line 118 "MDTreeParser.g"
756
757		int index;
758
759	<	#line 779 "MDTreeParser.cpp"
759	>	#line 760 "MDTreeParser.cpp"
760
761		try { // for error handling
762		ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
763	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
763	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
764		match(_t,ATOM);
765		_t = _t->getFirstChild();
766		index=intConst(_t);
767		_t = _retTree;
768	<	#line 124 "MDTreeParser.g"
768	>	#line 122 "MDTreeParser.g"
769		AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
770	<	#line 790 "MDTreeParser.cpp"
770	>	#line 771 "MDTreeParser.cpp"
771		{ // ( ... )*
772		for (;;) {
773		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 802 \| Line 783 \| void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
783		}
784		_loop41:;
785		} // ( ... )*
786	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
786	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
787		match(_t,ENDBLOCK);
788		_t = _t->getNextSibling();
789		_t = __t39;
790		_t = _t->getNextSibling();
791	<	#line 126 "MDTreeParser.g"
791	>	#line 124 "MDTreeParser.g"
792
793		blockStack.top()->validate();
794		blockStack.pop();
795		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
796		currMoleculeStamp->addAtomStamp(currAtomStamp);
797
798	<	#line 818 "MDTreeParser.cpp"
798	>	#line 799 "MDTreeParser.cpp"
799		}
800		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
801		reportError(ex);
#	Line 829 \| Line 810 \| void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
810
811		try { // for error handling
812		ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
813	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
813	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
814		match(_t,BOND);
815		_t = _t->getFirstChild();
816	<	#line 146 "MDTreeParser.g"
816	>	#line 144 "MDTreeParser.g"
817		BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
818	<	#line 838 "MDTreeParser.cpp"
818	>	#line 819 "MDTreeParser.cpp"
819		{ // ( ... )*
820		for (;;) {
821		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 850 \| Line 831 \| void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
831		}
832		_loop48:;
833		} // ( ... )*
834	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
834	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
835		match(_t,ENDBLOCK);
836		_t = _t->getNextSibling();
837		_t = __t46;
838		_t = _t->getNextSibling();
839	<	#line 148 "MDTreeParser.g"
839	>	#line 146 "MDTreeParser.g"
840
841		blockStack.pop();
842		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
843		currMoleculeStamp->addBondStamp(currBondStamp);
844
845	<	#line 865 "MDTreeParser.cpp"
845	>	#line 846 "MDTreeParser.cpp"
846		}
847		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
848		reportError(ex);
#	Line 876 \| Line 857 \| void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
857
858		try { // for error handling
859		ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
860	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
860	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
861		match(_t,BEND);
862		_t = _t->getFirstChild();
863	<	#line 164 "MDTreeParser.g"
863	>	#line 162 "MDTreeParser.g"
864		BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
865	<	#line 885 "MDTreeParser.cpp"
865	>	#line 866 "MDTreeParser.cpp"
866		{ // ( ... )*
867		for (;;) {
868		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 897 \| Line 878 \| void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
878		}
879		_loop54:;
880		} // ( ... )*
881	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
881	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
882		match(_t,ENDBLOCK);
883		_t = _t->getNextSibling();
884		_t = __t52;
885		_t = _t->getNextSibling();
886	<	#line 166 "MDTreeParser.g"
886	>	#line 164 "MDTreeParser.g"
887
888		blockStack.top()->validate();
889		blockStack.pop();
890		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
891		currMoleculeStamp->addBendStamp(currBendStamp);
892
893	<	#line 913 "MDTreeParser.cpp"
893	>	#line 894 "MDTreeParser.cpp"
894		}
895		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
896		reportError(ex);
#	Line 924 \| Line 905 \| void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
905
906		try { // for error handling
907		ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
908	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
908	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
909		match(_t,TORSION);
910		_t = _t->getFirstChild();
911	<	#line 183 "MDTreeParser.g"
911	>	#line 181 "MDTreeParser.g"
912		TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
913	<	#line 933 "MDTreeParser.cpp"
913	>	#line 914 "MDTreeParser.cpp"
914		{ // ( ... )*
915		for (;;) {
916		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 945 \| Line 926 \| void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
926		}
927		_loop60:;
928		} // ( ... )*
929	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
929	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
930		match(_t,ENDBLOCK);
931		_t = _t->getNextSibling();
932		_t = __t58;
933		_t = _t->getNextSibling();
934	<	#line 185 "MDTreeParser.g"
934	>	#line 183 "MDTreeParser.g"
935
936		blockStack.top()->validate();
937		blockStack.pop();
938		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
939		currMoleculeStamp->addTorsionStamp(currTorsionStamp);
940
941	<	#line 961 "MDTreeParser.cpp"
941	>	#line 942 "MDTreeParser.cpp"
942		}
943		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944		reportError(ex);
#	Line 972 \| Line 953 \| void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
953
954		try { // for error handling
955		ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
956	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
956	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
957		match(_t,INVERSION);
958		_t = _t->getFirstChild();
959	<	#line 202 "MDTreeParser.g"
959	>	#line 200 "MDTreeParser.g"
960		InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
961	<	#line 981 "MDTreeParser.cpp"
961	>	#line 962 "MDTreeParser.cpp"
962		{ // ( ... )*
963		for (;;) {
964		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 993 \| Line 974 \| void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
974		}
975		_loop66:;
976		} // ( ... )*
977	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
977	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978		match(_t,ENDBLOCK);
979		_t = _t->getNextSibling();
980		_t = __t64;
981		_t = _t->getNextSibling();
982	<	#line 204 "MDTreeParser.g"
982	>	#line 202 "MDTreeParser.g"
983
984		blockStack.top()->validate();
985		blockStack.pop();
986		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
987		currMoleculeStamp->addInversionStamp(currInversionStamp);
988
989	<	#line 1009 "MDTreeParser.cpp"
989	>	#line 990 "MDTreeParser.cpp"
990		}
991		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
992		reportError(ex);
#	Line 1017 \| Line 998 \| void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
998
999		void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1000		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1001	<	#line 223 "MDTreeParser.g"
1001	>	#line 221 "MDTreeParser.g"
1002
1003		int index;
1004
1005	<	#line 1025 "MDTreeParser.cpp"
1005	>	#line 1006 "MDTreeParser.cpp"
1006
1007		try { // for error handling
1008		ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1009	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1009	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1010		match(_t,RIGIDBODY);
1011		_t = _t->getFirstChild();
1012		index=intConst(_t);
1013		_t = _retTree;
1014	<	#line 227 "MDTreeParser.g"
1014	>	#line 225 "MDTreeParser.g"
1015		RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1016	<	#line 1036 "MDTreeParser.cpp"
1016	>	#line 1017 "MDTreeParser.cpp"
1017		{ // ( ... )*
1018		for (;;) {
1019		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1048 \| Line 1029 \| void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1029		}
1030		_loop73:;
1031		} // ( ... )*
1032	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1032	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1033		match(_t,ENDBLOCK);
1034		_t = _t->getNextSibling();
1035		_t = __t71;
1036		_t = _t->getNextSibling();
1037	<	#line 229 "MDTreeParser.g"
1037	>	#line 227 "MDTreeParser.g"
1038
1039		blockStack.top()->validate();
1040		blockStack.pop();
1041		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1042		currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1043
1044	<	#line 1064 "MDTreeParser.cpp"
1044	>	#line 1045 "MDTreeParser.cpp"
1045		}
1046		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047		reportError(ex);
#	Line 1075 \| Line 1056 \| void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1056
1057		try { // for error handling
1058		ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1059	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1059	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1060		match(_t,CUTOFFGROUP);
1061		_t = _t->getFirstChild();
1062	<	#line 246 "MDTreeParser.g"
1062	>	#line 244 "MDTreeParser.g"
1063		CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1064	<	#line 1084 "MDTreeParser.cpp"
1064	>	#line 1065 "MDTreeParser.cpp"
1065		{ // ( ... )*
1066		for (;;) {
1067		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1096 \| Line 1077 \| void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1077		}
1078		_loop79:;
1079		} // ( ... )*
1080	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1080	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1081		match(_t,ENDBLOCK);
1082		_t = _t->getNextSibling();
1083		_t = __t77;
1084		_t = _t->getNextSibling();
1085	<	#line 248 "MDTreeParser.g"
1085	>	#line 246 "MDTreeParser.g"
1086
1087		blockStack.top()->validate();
1088		blockStack.pop();
1089		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1090		currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1091
1092	<	#line 1112 "MDTreeParser.cpp"
1092	>	#line 1093 "MDTreeParser.cpp"
1093		}
1094		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1095		reportError(ex);
#	Line 1120 \| Line 1101 \| void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1101
1102		void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1103		ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1104	<	#line 265 "MDTreeParser.g"
1104	>	#line 263 "MDTreeParser.g"
1105		int ival;
1106	<	#line 1126 "MDTreeParser.cpp"
1106	>	#line 1107 "MDTreeParser.cpp"
1107
1108		try { // for error handling
1109		ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1110	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1110	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1111		match(_t,FRAGMENT);
1112		_t = _t->getFirstChild();
1113		ival=intConst(_t);
1114		_t = _retTree;
1115	<	#line 266 "MDTreeParser.g"
1115	>	#line 264 "MDTreeParser.g"
1116		FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1117	<	#line 1137 "MDTreeParser.cpp"
1117	>	#line 1118 "MDTreeParser.cpp"
1118		{ // ( ... )*
1119		for (;;) {
1120		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1149 \| Line 1130 \| void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1130		}
1131		_loop85:;
1132		} // ( ... )*
1133	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1133	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1134		match(_t,ENDBLOCK);
1135		_t = _t->getNextSibling();
1136		_t = __t83;
1137		_t = _t->getNextSibling();
1138	<	#line 268 "MDTreeParser.g"
1138	>	#line 266 "MDTreeParser.g"
1139
1140		blockStack.top()->validate();
1141		blockStack.pop();
1142		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1143		currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1144
1145	<	#line 1165 "MDTreeParser.cpp"
1145	>	#line 1146 "MDTreeParser.cpp"
1146		}
1147		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1148		reportError(ex);
#	Line 1176 \| Line 1157 \| void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE
1157
1158		try { // for error handling
1159		ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1160	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1160	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1161		match(_t,CONSTRAINT);
1162		_t = _t->getFirstChild();
1163	<	#line 279 "MDTreeParser.g"
1163	>	#line 277 "MDTreeParser.g"
1164		ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1165	<	#line 1185 "MDTreeParser.cpp"
1165	>	#line 1166 "MDTreeParser.cpp"
1166		{ // ( ... )*
1167		for (;;) {
1168		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1197 \| Line 1178 \| void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE
1178		}
1179		_loop90:;
1180		} // ( ... )*
1181	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1181	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1182		match(_t,ENDBLOCK);
1183		_t = _t->getNextSibling();
1184		_t = __t88;
1185		_t = _t->getNextSibling();
1186	<	#line 281 "MDTreeParser.g"
1186	>	#line 279 "MDTreeParser.g"
1187
1188		blockStack.pop();
1189		MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1190		currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1191
1192	<	#line 1212 "MDTreeParser.cpp"
1192	>	#line 1193 "MDTreeParser.cpp"
1193		}
1194		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1195		reportError(ex);
#	Line 1220 \| Line 1201 \| void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1201
1202		void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1203		ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1204	<	#line 134 "MDTreeParser.g"
1204	>	#line 132 "MDTreeParser.g"
1205
1206		vector<RealType> dvec;
1207		AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1208
1209
1210	<	#line 1230 "MDTreeParser.cpp"
1210	>	#line 1211 "MDTreeParser.cpp"
1211
1212		try { // for error handling
1213		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1241 \| Line 1222 \| void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1222		case POSITION:
1223		{
1224		ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1225	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1225	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1226		match(_t,POSITION);
1227		_t = _t->getFirstChild();
1228		dvec=doubleNumberTuple(_t);
1229		_t = _retTree;
1230		_t = __t43;
1231		_t = _t->getNextSibling();
1232	<	#line 141 "MDTreeParser.g"
1232	>	#line 139 "MDTreeParser.g"
1233		currAtomStamp->setPosition(dvec);
1234	<	#line 1254 "MDTreeParser.cpp"
1234	>	#line 1235 "MDTreeParser.cpp"
1235		break;
1236		}
1237		case ORIENTATION:
1238		{
1239		ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1240	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1240	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1241		match(_t,ORIENTATION);
1242		_t = _t->getFirstChild();
1243		dvec=doubleNumberTuple(_t);
1244		_t = _retTree;
1245		_t = __t44;
1246		_t = _t->getNextSibling();
1247	<	#line 142 "MDTreeParser.g"
1247	>	#line 140 "MDTreeParser.g"
1248		currAtomStamp->setOrientation(dvec);
1249	<	#line 1269 "MDTreeParser.cpp"
1249	>	#line 1250 "MDTreeParser.cpp"
1250		break;
1251		}
1252		default:
1253		{
1254		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1255		}
1275	–	}
1276	–	}
1277	–	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1278	–	reportError(ex);
1279	–	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1280	–	_t = _t->getNextSibling();
1281	–	}
1282	–	_retTree = _t;
1283	–	}
1284	–
1285	–	vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286	–	#line 298 "MDTreeParser.g"
1287	–	vector<RealType> dvec;
1288	–	#line 1289 "MDTreeParser.cpp"
1289	–	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290	–	#line 298 "MDTreeParser.g"
1291	–
1292	–	RealType dval;
1293	–
1294	–	#line 1295 "MDTreeParser.cpp"
1295	–
1296	–	try { // for error handling
1297	–	{ // ( ... )+
1298	–	int _cnt95=0;
1299	–	for (;;) {
1300	–	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1301	–	_t = ASTNULL;
1302	–	if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1303	–	dval=doubleNumber(_t);
1304	–	_t = _retTree;
1305	–	#line 302 "MDTreeParser.g"
1306	–	dvec.push_back(dval);
1307	–	#line 1308 "MDTreeParser.cpp"
1308	–	}
1309	–	else {
1310	–	if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1311	–	}
1312	–
1313	–	_cnt95++;
1256		}
1315	–	_loop95:;
1316	–	} // ( ... )+
1257		}
1258		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1259		reportError(ex);
#	Line 1321 \| Line 1261 \| vector<RealType> MDTreeParser::doubleNumberTuple(ANTL
1261		_t = _t->getNextSibling();
1262		}
1263		_retTree = _t;
1324	–	return dvec;
1264		}
1265
1266		void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1267		ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1268	<	#line 155 "MDTreeParser.g"
1268	>	#line 153 "MDTreeParser.g"
1269
1270		vector<int> ivec;
1271		BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1272
1273	<	#line 1335 "MDTreeParser.cpp"
1273	>	#line 1274 "MDTreeParser.cpp"
1274
1275		try { // for error handling
1276		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1346 \| Line 1285 \| void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1285		case MEMBERS:
1286		{
1287		ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1288	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1288	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1289		match(_t,MEMBERS);
1290		_t = _t->getFirstChild();
1291		ivec=inttuple(_t);
1292		_t = _retTree;
1293		_t = __t50;
1294		_t = _t->getNextSibling();
1295	<	#line 161 "MDTreeParser.g"
1295	>	#line 159 "MDTreeParser.g"
1296		currBondStamp->setMembers(ivec);
1297	<	#line 1359 "MDTreeParser.cpp"
1297	>	#line 1298 "MDTreeParser.cpp"
1298		break;
1299		}
1300		default:
#	Line 1373 \| Line 1312 \| vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1312		}
1313
1314		vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1315	<	#line 306 "MDTreeParser.g"
1315	>	#line 304 "MDTreeParser.g"
1316		vector<int> ivec;
1317	<	#line 1379 "MDTreeParser.cpp"
1317	>	#line 1318 "MDTreeParser.cpp"
1318		ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1319	<	#line 306 "MDTreeParser.g"
1319	>	#line 304 "MDTreeParser.g"
1320
1321		int ival;
1322
1323	<	#line 1385 "MDTreeParser.cpp"
1323	>	#line 1324 "MDTreeParser.cpp"
1324
1325		try { // for error handling
1326		{ // ( ... )+
#	Line 1392 \| Line 1331 \| vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1331		if ((_t->getType() == NUM_INT \|\| _t->getType() == NUM_LONG)) {
1332		ival=intConst(_t);
1333		_t = _retTree;
1334	<	#line 310 "MDTreeParser.g"
1334	>	#line 308 "MDTreeParser.g"
1335		ivec.push_back(ival);
1336	<	#line 1398 "MDTreeParser.cpp"
1336	>	#line 1337 "MDTreeParser.cpp"
1337		}
1338		else {
1339		if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
#	Line 1416 \| Line 1355 \| void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1355
1356		void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1357		ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1358	<	#line 174 "MDTreeParser.g"
1358	>	#line 172 "MDTreeParser.g"
1359
1360		vector<int> ivec;
1361		BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1362
1363	<	#line 1425 "MDTreeParser.cpp"
1363	>	#line 1364 "MDTreeParser.cpp"
1364
1365		try { // for error handling
1366		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1436 \| Line 1375 \| void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1375		case MEMBERS:
1376		{
1377		ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1378	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1378	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1379		match(_t,MEMBERS);
1380		_t = _t->getFirstChild();
1381		ivec=inttuple(_t);
1382		_t = _retTree;
1383		_t = __t56;
1384		_t = _t->getNextSibling();
1385	<	#line 180 "MDTreeParser.g"
1385	>	#line 178 "MDTreeParser.g"
1386		currBendStamp->setMembers(ivec);
1387	<	#line 1449 "MDTreeParser.cpp"
1387	>	#line 1388 "MDTreeParser.cpp"
1388		break;
1389		}
1390		default:
#	Line 1464 \| Line 1403 \| void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1403
1404		void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1405		ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406	<	#line 193 "MDTreeParser.g"
1406	>	#line 191 "MDTreeParser.g"
1407
1408		vector<int> ivec;
1409		TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1410
1411	<	#line 1473 "MDTreeParser.cpp"
1411	>	#line 1412 "MDTreeParser.cpp"
1412
1413		try { // for error handling
1414		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1484 \| Line 1423 \| void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1423		case MEMBERS:
1424		{
1425		ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1426	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1426	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1427		match(_t,MEMBERS);
1428		_t = _t->getFirstChild();
1429		ivec=inttuple(_t);
1430		_t = _retTree;
1431		_t = __t62;
1432		_t = _t->getNextSibling();
1433	<	#line 199 "MDTreeParser.g"
1433	>	#line 197 "MDTreeParser.g"
1434		currTorsionStamp->setMembers(ivec);
1435	<	#line 1497 "MDTreeParser.cpp"
1435	>	#line 1436 "MDTreeParser.cpp"
1436		break;
1437		}
1438		default:
#	Line 1512 \| Line 1451 \| void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1451
1452		void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1453		ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1454	<	#line 212 "MDTreeParser.g"
1454	>	#line 210 "MDTreeParser.g"
1455
1456		int icent;
1457		vector<int> ivec;
1458		InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1459
1460	<	#line 1522 "MDTreeParser.cpp"
1460	>	#line 1461 "MDTreeParser.cpp"
1461
1462		try { // for error handling
1463		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1533 \| Line 1472 \| void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1472		case CENTER:
1473		{
1474		ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1475	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1475	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1476		match(_t,CENTER);
1477		_t = _t->getFirstChild();
1478		icent=intConst(_t);
1479		_t = _retTree;
1480		_t = __t68;
1481		_t = _t->getNextSibling();
1482	<	#line 219 "MDTreeParser.g"
1482	>	#line 217 "MDTreeParser.g"
1483		currInversionStamp->setCenter(icent);
1484	<	#line 1546 "MDTreeParser.cpp"
1484	>	#line 1485 "MDTreeParser.cpp"
1485		break;
1486		}
1487		case SATELLITES:
1488		{
1489		ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1490	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1490	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1491		match(_t,SATELLITES);
1492		_t = _t->getFirstChild();
1493		ivec=inttuple(_t);
1494		_t = _retTree;
1495		_t = __t69;
1496		_t = _t->getNextSibling();
1497	<	#line 220 "MDTreeParser.g"
1497	>	#line 218 "MDTreeParser.g"
1498		currInversionStamp->setSatellites(ivec);
1499	<	#line 1561 "MDTreeParser.cpp"
1499	>	#line 1500 "MDTreeParser.cpp"
1500		break;
1501		}
1502		default:
#	Line 1576 \| Line 1515 \| void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1515
1516		void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1517		ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1518	<	#line 237 "MDTreeParser.g"
1518	>	#line 235 "MDTreeParser.g"
1519
1520		vector<int> ivec;
1521		RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1522
1523	<	#line 1585 "MDTreeParser.cpp"
1523	>	#line 1524 "MDTreeParser.cpp"
1524
1525		try { // for error handling
1526		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1596 \| Line 1535 \| void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1535		case MEMBERS:
1536		{
1537		ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1538	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1538	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1539		match(_t,MEMBERS);
1540		_t = _t->getFirstChild();
1541		ivec=inttuple(_t);
1542		_t = _retTree;
1543		_t = __t75;
1544		_t = _t->getNextSibling();
1545	<	#line 243 "MDTreeParser.g"
1545	>	#line 241 "MDTreeParser.g"
1546		currRigidBodyStamp->setMembers(ivec);
1547	<	#line 1609 "MDTreeParser.cpp"
1547	>	#line 1548 "MDTreeParser.cpp"
1548		break;
1549		}
1550		default:
#	Line 1624 \| Line 1563 \| void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1563
1564		void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1565		ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1566	<	#line 256 "MDTreeParser.g"
1566	>	#line 254 "MDTreeParser.g"
1567
1568		vector<int> ivec;
1569		CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1570
1571	<	#line 1633 "MDTreeParser.cpp"
1571	>	#line 1572 "MDTreeParser.cpp"
1572
1573		try { // for error handling
1574		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1644 \| Line 1583 \| void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1583		case MEMBERS:
1584		{
1585		ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1586	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1586	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1587		match(_t,MEMBERS);
1588		_t = _t->getFirstChild();
1589		ivec=inttuple(_t);
1590		_t = _retTree;
1591		_t = __t81;
1592		_t = _t->getNextSibling();
1593	<	#line 262 "MDTreeParser.g"
1593	>	#line 260 "MDTreeParser.g"
1594		currCutoffGroupStamp->setMembers(ivec);
1595	<	#line 1657 "MDTreeParser.cpp"
1595	>	#line 1596 "MDTreeParser.cpp"
1596		break;
1597		}
1598		default:
#	Line 1687 \| Line 1626 \| void MDTreeParser::constraintstatement(ANTLR_USE_NAMES
1626
1627		void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1628		ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1629	<	#line 288 "MDTreeParser.g"
1629	>	#line 286 "MDTreeParser.g"
1630
1631		vector<int> ivec;
1632		ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1633
1634	<	#line 1696 "MDTreeParser.cpp"
1634	>	#line 1635 "MDTreeParser.cpp"
1635
1636		try { // for error handling
1637		if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
#	Line 1707 \| Line 1646 \| void MDTreeParser::constraintstatement(ANTLR_USE_NAMES
1646		case MEMBERS:
1647		{
1648		ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1649	<	ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1649	>	ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1650		match(_t,MEMBERS);
1651		_t = _t->getFirstChild();
1652		ivec=inttuple(_t);
1653		_t = _retTree;
1654		_t = __t92;
1655		_t = _t->getNextSibling();
1656	<	#line 294 "MDTreeParser.g"
1656	>	#line 292 "MDTreeParser.g"
1657		currConstraintStamp->setMembers(ivec);
1658	<	#line 1720 "MDTreeParser.cpp"
1658	>	#line 1659 "MDTreeParser.cpp"
1659		break;
1660		}
1661		default:
#	Line 1733 \| Line 1672 \| void MDTreeParser::constraintstatement(ANTLR_USE_NAMES
1672		_retTree = _t;
1673		}
1674
1675	+	RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1676	+	#line 318 "MDTreeParser.g"
1677	+	RealType dval;
1678	+	#line 1679 "MDTreeParser.cpp"
1679	+	ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1680	+	ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1681	+	ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1682	+
1683	+	try { // for error handling
1684	+	if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1685	+	_t = ASTNULL;
1686	+	switch ( _t->getType()) {
1687	+	case NUM_INT:
1688	+	case NUM_LONG:
1689	+	{
1690	+	ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1691	+	intConst(_t);
1692	+	_t = _retTree;
1693	+	#line 319 "MDTreeParser.g"
1694	+	dval = lexi_cast<RealType>(ic->getText());
1695	+	#line 1696 "MDTreeParser.cpp"
1696	+	break;
1697	+	}
1698	+	case NUM_FLOAT:
1699	+	case NUM_DOUBLE:
1700	+	{
1701	+	fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1702	+	floatConst(_t);
1703	+	_t = _retTree;
1704	+	#line 320 "MDTreeParser.g"
1705	+	dval = lexi_cast<RealType>(fc->getText());
1706	+	#line 1707 "MDTreeParser.cpp"
1707	+	break;
1708	+	}
1709	+	default:
1710	+	{
1711	+	throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1712	+	}
1713	+	}
1714	+	}
1715	+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1716	+	reportError(ex);
1717	+	if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1718	+	_t = _t->getNextSibling();
1719	+	}
1720	+	_retTree = _t;
1721	+	return dval;
1722	+	}
1723	+
1724		void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1725		{
1726		}

Diff Legend

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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents): Revision 2025 by gezelter, Sat Apr 5 20:56:01 2014 UTC vs. Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

Diff Legend

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 2025 by gezelter, Sat Apr 5 20:56:01 2014 UTC vs.
Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC