ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
(Generate patch)

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1782 by gezelter, Wed Aug 22 02:28:28 2012 UTC vs.
Revision 2040 by gezelter, Thu Nov 13 17:49:44 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20120725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20141024): "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 294 "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 295 "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 296 "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 306 "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 307 "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 308 "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 300 "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 301 "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 302 "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 749 | Line 730 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
730                          _t = _retTree;
731                          break;
732                  }
733 +                case CONSTRAINT:
734 +                {
735 +                        constraintblock(_t);
736 +                        _t = _retTree;
737 +                        break;
738 +                }
739                  default:
740                  {
741                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 765 | 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 119 "MDTreeParser.g"
755 > #line 118 "MDTreeParser.g"
756          
757          int index;
758          
759 < #line 773 "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 123 "MDTreeParser.g"
768 > #line 122 "MDTreeParser.g"
769                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
770 < #line 784 "MDTreeParser.cpp"
770 > #line 771 "MDTreeParser.cpp"
771                  { // ( ... )*
772                  for (;;) {
773                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 796 | 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 125 "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 812 "MDTreeParser.cpp"
798 > #line 799 "MDTreeParser.cpp"
799          }
800          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
801                  reportError(ex);
# Line 823 | 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 145 "MDTreeParser.g"
816 > #line 144 "MDTreeParser.g"
817                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
818 < #line 832 "MDTreeParser.cpp"
818 > #line 819 "MDTreeParser.cpp"
819                  { // ( ... )*
820                  for (;;) {
821                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 844 | 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 147 "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 859 "MDTreeParser.cpp"
845 > #line 846 "MDTreeParser.cpp"
846          }
847          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
848                  reportError(ex);
# Line 870 | 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 163 "MDTreeParser.g"
863 > #line 162 "MDTreeParser.g"
864                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
865 < #line 879 "MDTreeParser.cpp"
865 > #line 866 "MDTreeParser.cpp"
866                  { // ( ... )*
867                  for (;;) {
868                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 891 | 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 165 "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 907 "MDTreeParser.cpp"
893 > #line 894 "MDTreeParser.cpp"
894          }
895          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
896                  reportError(ex);
# Line 918 | 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 182 "MDTreeParser.g"
911 > #line 181 "MDTreeParser.g"
912                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
913 < #line 927 "MDTreeParser.cpp"
913 > #line 914 "MDTreeParser.cpp"
914                  { // ( ... )*
915                  for (;;) {
916                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 939 | 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 184 "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 955 "MDTreeParser.cpp"
941 > #line 942 "MDTreeParser.cpp"
942          }
943          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944                  reportError(ex);
# Line 966 | 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 201 "MDTreeParser.g"
959 > #line 200 "MDTreeParser.g"
960                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
961 < #line 975 "MDTreeParser.cpp"
961 > #line 962 "MDTreeParser.cpp"
962                  { // ( ... )*
963                  for (;;) {
964                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
965                                  _t = ASTNULL;
966 <                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
966 >                        if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
967                                  inversionstatement(_t);
968                                  _t = _retTree;
969                          }
# Line 987 | 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 203 "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 1003 "MDTreeParser.cpp"
989 > #line 990 "MDTreeParser.cpp"
990          }
991          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
992                  reportError(ex);
# Line 1011 | 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 220 "MDTreeParser.g"
1001 > #line 221 "MDTreeParser.g"
1002          
1003          int index;
1004          
1005 < #line 1019 "MDTreeParser.cpp"
1005 > #line 1006 "MDTreeParser.cpp"
1006          
1007          try {      // for error handling
1008 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1009 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1008 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _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 224 "MDTreeParser.g"
1014 > #line 225 "MDTreeParser.g"
1015                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1016 < #line 1030 "MDTreeParser.cpp"
1016 > #line 1017 "MDTreeParser.cpp"
1017                  { // ( ... )*
1018                  for (;;) {
1019                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1036 | Line 1023 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1023                                  _t = _retTree;
1024                          }
1025                          else {
1026 <                                goto _loop72;
1026 >                                goto _loop73;
1027                          }
1028                          
1029                  }
1030 <                _loop72:;
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 = __t70;
1035 >                _t = __t71;
1036                  _t = _t->getNextSibling();
1037 < #line 226 "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 1058 "MDTreeParser.cpp"
1044 > #line 1045 "MDTreeParser.cpp"
1045          }
1046          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047                  reportError(ex);
# Line 1068 | Line 1055 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1055          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1056          
1057          try {      // for error handling
1058 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1059 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1058 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1059 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1060                  match(_t,CUTOFFGROUP);
1061                  _t = _t->getFirstChild();
1062 < #line 243 "MDTreeParser.g"
1062 > #line 244 "MDTreeParser.g"
1063                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1064 < #line 1078 "MDTreeParser.cpp"
1064 > #line 1065 "MDTreeParser.cpp"
1065                  { // ( ... )*
1066                  for (;;) {
1067                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1084 | Line 1071 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1071                                  _t = _retTree;
1072                          }
1073                          else {
1074 <                                goto _loop78;
1074 >                                goto _loop79;
1075                          }
1076                          
1077                  }
1078 <                _loop78:;
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 = __t76;
1083 >                _t = __t77;
1084                  _t = _t->getNextSibling();
1085 < #line 245 "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 1106 "MDTreeParser.cpp"
1092 > #line 1093 "MDTreeParser.cpp"
1093          }
1094          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1095                  reportError(ex);
# Line 1114 | 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 262 "MDTreeParser.g"
1104 > #line 263 "MDTreeParser.g"
1105          int ival;
1106 < #line 1120 "MDTreeParser.cpp"
1106 > #line 1107 "MDTreeParser.cpp"
1107          
1108          try {      // for error handling
1109 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1110 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1109 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _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 263 "MDTreeParser.g"
1115 > #line 264 "MDTreeParser.g"
1116                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1117 < #line 1131 "MDTreeParser.cpp"
1117 > #line 1118 "MDTreeParser.cpp"
1118                  { // ( ... )*
1119                  for (;;) {
1120                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1137 | Line 1124 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1124                                  _t = _retTree;
1125                          }
1126                          else {
1127 <                                goto _loop84;
1127 >                                goto _loop85;
1128                          }
1129                          
1130                  }
1131 <                _loop84:;
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 = __t82;
1136 >                _t = __t83;
1137                  _t = _t->getNextSibling();
1138 < #line 265 "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 1159 "MDTreeParser.cpp"
1145 > #line 1146 "MDTreeParser.cpp"
1146 >        }
1147 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1148 >                reportError(ex);
1149 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1150 >                        _t = _t->getNextSibling();
1151          }
1152 +        _retTree = _t;
1153 + }
1154 +
1155 + void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1156 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1157 +        
1158 +        try {      // for error handling
1159 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1160 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1161 +                match(_t,CONSTRAINT);
1162 +                _t = _t->getFirstChild();
1163 + #line 277 "MDTreeParser.g"
1164 +                ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1165 + #line 1166 "MDTreeParser.cpp"
1166 +                { // ( ... )*
1167 +                for (;;) {
1168 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1169 +                                _t = ASTNULL;
1170 +                        if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1171 +                                constraintstatement(_t);
1172 +                                _t = _retTree;
1173 +                        }
1174 +                        else {
1175 +                                goto _loop90;
1176 +                        }
1177 +                        
1178 +                }
1179 +                _loop90:;
1180 +                } // ( ... )*
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 279 "MDTreeParser.g"
1187 +                
1188 +                blockStack.pop();
1189 +                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1190 +                currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1191 +                
1192 + #line 1193 "MDTreeParser.cpp"
1193 +        }
1194          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1195                  reportError(ex);
1196                  if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1167 | 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 133 "MDTreeParser.g"
1204 > #line 132 "MDTreeParser.g"
1205          
1206          vector<RealType> dvec;
1207          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1208          
1209          
1210 < #line 1177 "MDTreeParser.cpp"
1210 > #line 1211 "MDTreeParser.cpp"
1211          
1212          try {      // for error handling
1213                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1195 | Line 1229 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1229                          _t = _retTree;
1230                          _t = __t43;
1231                          _t = _t->getNextSibling();
1232 < #line 140 "MDTreeParser.g"
1232 > #line 139 "MDTreeParser.g"
1233                          currAtomStamp->setPosition(dvec);
1234 < #line 1201 "MDTreeParser.cpp"
1234 > #line 1235 "MDTreeParser.cpp"
1235                          break;
1236                  }
1237                  case ORIENTATION:
# Line 1210 | Line 1244 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1244                          _t = _retTree;
1245                          _t = __t44;
1246                          _t = _t->getNextSibling();
1247 < #line 141 "MDTreeParser.g"
1247 > #line 140 "MDTreeParser.g"
1248                          currAtomStamp->setOrientation(dvec);
1249 < #line 1216 "MDTreeParser.cpp"
1249 > #line 1250 "MDTreeParser.cpp"
1250                          break;
1251                  }
1252                  default:
# Line 1229 | Line 1263 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1263          _retTree = _t;
1264   }
1265  
1232 – vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 – #line 278 "MDTreeParser.g"
1234 –        vector<RealType> dvec;
1235 – #line 1236 "MDTreeParser.cpp"
1236 –        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237 – #line 278 "MDTreeParser.g"
1238 –        
1239 –        RealType dval;
1240 –        
1241 – #line 1242 "MDTreeParser.cpp"
1242 –        
1243 –        try {      // for error handling
1244 –                { // ( ... )+
1245 –                int _cnt88=0;
1246 –                for (;;) {
1247 –                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248 –                                _t = ASTNULL;
1249 –                        if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250 –                                dval=doubleNumber(_t);
1251 –                                _t = _retTree;
1252 – #line 282 "MDTreeParser.g"
1253 –                                dvec.push_back(dval);
1254 – #line 1255 "MDTreeParser.cpp"
1255 –                        }
1256 –                        else {
1257 –                                if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258 –                        }
1259 –                        
1260 –                        _cnt88++;
1261 –                }
1262 –                _loop88:;
1263 –                }  // ( ... )+
1264 –        }
1265 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1266 –                reportError(ex);
1267 –                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1268 –                        _t = _t->getNextSibling();
1269 –        }
1270 –        _retTree = _t;
1271 –        return dvec;
1272 – }
1273 –
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 154 "MDTreeParser.g"
1268 > #line 153 "MDTreeParser.g"
1269          
1270          vector<int> ivec;
1271          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1272          
1273 < #line 1282 "MDTreeParser.cpp"
1273 > #line 1274 "MDTreeParser.cpp"
1274          
1275          try {      // for error handling
1276                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1300 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292                          _t = _retTree;
1293                          _t = __t50;
1294                          _t = _t->getNextSibling();
1295 < #line 160 "MDTreeParser.g"
1295 > #line 159 "MDTreeParser.g"
1296                          currBondStamp->setMembers(ivec);
1297 < #line 1306 "MDTreeParser.cpp"
1297 > #line 1298 "MDTreeParser.cpp"
1298                          break;
1299                  }
1300                  default:
# Line 1320 | Line 1312 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1312   }
1313  
1314   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1315 < #line 286 "MDTreeParser.g"
1315 > #line 304 "MDTreeParser.g"
1316          vector<int> ivec;
1317 < #line 1326 "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 286 "MDTreeParser.g"
1319 > #line 304 "MDTreeParser.g"
1320          
1321          int ival;
1322          
1323 < #line 1332 "MDTreeParser.cpp"
1323 > #line 1324 "MDTreeParser.cpp"
1324          
1325          try {      // for error handling
1326                  { // ( ... )+
1327 <                int _cnt91=0;
1327 >                int _cnt98=0;
1328                  for (;;) {
1329                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1330                                  _t = ASTNULL;
1331                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1332                                  ival=intConst(_t);
1333                                  _t = _retTree;
1334 < #line 290 "MDTreeParser.g"
1334 > #line 308 "MDTreeParser.g"
1335                                  ivec.push_back(ival);
1336 < #line 1345 "MDTreeParser.cpp"
1336 > #line 1337 "MDTreeParser.cpp"
1337                          }
1338                          else {
1339 <                                if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1339 >                                if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1340                          }
1341                          
1342 <                        _cnt91++;
1342 >                        _cnt98++;
1343                  }
1344 <                _loop91:;
1344 >                _loop98:;
1345                  }  // ( ... )+
1346          }
1347          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1363 | 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 173 "MDTreeParser.g"
1358 > #line 172 "MDTreeParser.g"
1359          
1360          vector<int> ivec;
1361          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1362          
1363 < #line 1372 "MDTreeParser.cpp"
1363 > #line 1364 "MDTreeParser.cpp"
1364          
1365          try {      // for error handling
1366                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1390 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382                          _t = _retTree;
1383                          _t = __t56;
1384                          _t = _t->getNextSibling();
1385 < #line 179 "MDTreeParser.g"
1385 > #line 178 "MDTreeParser.g"
1386                          currBendStamp->setMembers(ivec);
1387 < #line 1396 "MDTreeParser.cpp"
1387 > #line 1388 "MDTreeParser.cpp"
1388                          break;
1389                  }
1390                  default:
# Line 1411 | 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 192 "MDTreeParser.g"
1406 > #line 191 "MDTreeParser.g"
1407          
1408          vector<int> ivec;
1409          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1410          
1411 < #line 1420 "MDTreeParser.cpp"
1411 > #line 1412 "MDTreeParser.cpp"
1412          
1413          try {      // for error handling
1414                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1438 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430                          _t = _retTree;
1431                          _t = __t62;
1432                          _t = _t->getNextSibling();
1433 < #line 198 "MDTreeParser.g"
1433 > #line 197 "MDTreeParser.g"
1434                          currTorsionStamp->setMembers(ivec);
1435 < #line 1444 "MDTreeParser.cpp"
1435 > #line 1436 "MDTreeParser.cpp"
1436                          break;
1437                  }
1438                  default:
# Line 1459 | 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 211 "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 1468 "MDTreeParser.cpp"
1460 > #line 1461 "MDTreeParser.cpp"
1461          
1462          try {      // for error handling
1463                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1488 | Line 1481 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1481                          _t = _t->getNextSibling();
1482   #line 217 "MDTreeParser.g"
1483                          currInversionStamp->setCenter(icent);
1484 < #line 1492 "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 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 218 "MDTreeParser.g"
1498 >                        currInversionStamp->setSatellites(ivec);
1499 > #line 1500 "MDTreeParser.cpp"
1500                          break;
1501                  }
1502                  default:
# Line 1507 | 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 234 "MDTreeParser.g"
1518 > #line 235 "MDTreeParser.g"
1519          
1520          vector<int> ivec;
1521          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1522          
1523 < #line 1516 "MDTreeParser.cpp"
1523 > #line 1524 "MDTreeParser.cpp"
1524          
1525          try {      // for error handling
1526                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1526 | Line 1534 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1534                  }
1535                  case MEMBERS:
1536                  {
1537 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1538 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1537 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _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 = __t74;
1543 >                        _t = __t75;
1544                          _t = _t->getNextSibling();
1545 < #line 240 "MDTreeParser.g"
1545 > #line 241 "MDTreeParser.g"
1546                          currRigidBodyStamp->setMembers(ivec);
1547 < #line 1540 "MDTreeParser.cpp"
1547 > #line 1548 "MDTreeParser.cpp"
1548                          break;
1549                  }
1550                  default:
# Line 1555 | 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 253 "MDTreeParser.g"
1566 > #line 254 "MDTreeParser.g"
1567          
1568          vector<int> ivec;
1569          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1570          
1571 < #line 1564 "MDTreeParser.cpp"
1571 > #line 1572 "MDTreeParser.cpp"
1572          
1573          try {      // for error handling
1574                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1574 | Line 1582 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1582                  }
1583                  case MEMBERS:
1584                  {
1585 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1586 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1585 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _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 = __t80;
1591 >                        _t = __t81;
1592                          _t = _t->getNextSibling();
1593 < #line 259 "MDTreeParser.g"
1593 > #line 260 "MDTreeParser.g"
1594                          currCutoffGroupStamp->setMembers(ivec);
1595 < #line 1588 "MDTreeParser.cpp"
1595 > #line 1596 "MDTreeParser.cpp"
1596                          break;
1597                  }
1598                  default:
# Line 1616 | Line 1624 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1624          _retTree = _t;
1625   }
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 286 "MDTreeParser.g"
1630 +        
1631 +        vector<int> ivec;
1632 +        ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1633 +        
1634 + #line 1635 "MDTreeParser.cpp"
1635 +        
1636 +        try {      // for error handling
1637 +                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1638 +                        _t = ASTNULL;
1639 +                switch ( _t->getType()) {
1640 +                case ASSIGNEQUAL:
1641 +                {
1642 +                        assignment(_t);
1643 +                        _t = _retTree;
1644 +                        break;
1645 +                }
1646 +                case MEMBERS:
1647 +                {
1648 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _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 292 "MDTreeParser.g"
1657 +                        currConstraintStamp->setMembers(ivec);
1658 + #line 1659 "MDTreeParser.cpp"
1659 +                        break;
1660 +                }
1661 +                default:
1662 +                {
1663 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1664 +                }
1665 +                }
1666 +        }
1667 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1668 +                reportError(ex);
1669 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1670 +                        _t = _t->getNextSibling();
1671 +        }
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   }
# Line 1635 | Line 1740 | const char* MDTreeParser::tokenNames[] = {
1740          "\"inversion\"",
1741          "\"rigidBody\"",
1742          "\"cutoffGroup\"",
1743 +        "\"constraint\"",
1744 +        "\"distance\"",
1745          "\"fragment\"",
1746          "\"members\"",
1747          "\"center\"",
1748 +        "\"satellites\"",
1749          "\"position\"",
1750          "\"orientation\"",
1751          "\"flucQ\"",
# Line 1680 | Line 1788 | const char* MDTreeParser::tokenNames[] = {
1788          0
1789   };
1790  
1791 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1791 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1792   // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1793   // ASSIGNEQUAL
1794   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1795 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1795 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1796   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1797 < // "fragment" ASSIGNEQUAL
1797 > // "constraint" "fragment" ASSIGNEQUAL
1798   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1799  
1800  

Diff Legend

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