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 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.4: "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 251 | Line 251 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
251   #line 47 "MDTreeParser.g"
252          
253          int ival;
254 <        double dval;
254 >        RealType dval;
255          
256   #line 257 "MDTreeParser.cpp"
257          
# Line 317 | Line 317 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
317   }
318  
319   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
320 < #line 242 "MDTreeParser.g"
320 > #line 262 "MDTreeParser.g"
321          int ival;
322   #line 323 "MDTreeParser.cpp"
323          ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
# Line 333 | Line 333 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
333                          i1 = _t;
334                          match(_t,NUM_INT);
335                          _t = _t->getNextSibling();
336 < #line 243 "MDTreeParser.g"
336 > #line 263 "MDTreeParser.g"
337                          ival = lexi_cast<int>(i1->getText());
338   #line 339 "MDTreeParser.cpp"
339                          break;
# Line 343 | Line 343 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
343                          i2 = _t;
344                          match(_t,NUM_LONG);
345                          _t = _t->getNextSibling();
346 < #line 244 "MDTreeParser.g"
346 > #line 264 "MDTreeParser.g"
347                          ival = lexi_cast<int>(i2->getText());
348   #line 349 "MDTreeParser.cpp"
349                          break;
# Line 363 | Line 363 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
363          return ival;
364   }
365  
366 < double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 < #line 256 "MDTreeParser.g"
368 <        double dval;
366 > RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 > #line 276 "MDTreeParser.g"
368 >        RealType dval;
369   #line 370 "MDTreeParser.cpp"
370          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
371          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 380 | Line 380 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
380                          d1 = _t;
381                          match(_t,NUM_FLOAT);
382                          _t = _t->getNextSibling();
383 < #line 257 "MDTreeParser.g"
384 <                        dval = lexi_cast<double>(d1->getText());
383 > #line 277 "MDTreeParser.g"
384 >                        dval = lexi_cast<RealType>(d1->getText());
385   #line 386 "MDTreeParser.cpp"
386                          break;
387                  }
# Line 390 | Line 390 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
390                          d2 = _t;
391                          match(_t,NUM_DOUBLE);
392                          _t = _t->getNextSibling();
393 < #line 258 "MDTreeParser.g"
394 <                        dval = lexi_cast<double>(d2->getText());
393 > #line 278 "MDTreeParser.g"
394 >                        dval = lexi_cast<RealType>(d2->getText());
395   #line 396 "MDTreeParser.cpp"
396                          break;
397                  }
# Line 447 | Line 447 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
447                          _t = _retTree;
448                          break;
449                  }
450 +                case INVERSION:
451 +                {
452 +                        inversionblock(_t);
453 +                        _t = _retTree;
454 +                        break;
455 +                }
456                  case RIGIDBODY:
457                  {
458                          rigidbodyblock(_t);
# Line 481 | Line 487 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
487  
488   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
489          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
490 < #line 87 "MDTreeParser.g"
490 > #line 88 "MDTreeParser.g"
491          
492          int index;
493          
494 < #line 489 "MDTreeParser.cpp"
494 > #line 495 "MDTreeParser.cpp"
495          
496          try {      // for error handling
497                  ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
# Line 494 | Line 500 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
500                  _t = _t->getFirstChild();
501                  index=intConst(_t);
502                  _t = _retTree;
503 < #line 91 "MDTreeParser.g"
503 > #line 92 "MDTreeParser.g"
504                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
505 < #line 500 "MDTreeParser.cpp"
505 > #line 506 "MDTreeParser.cpp"
506                  { // ( ... )*
507                  for (;;) {
508                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 517 | Line 523 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
523                  _t = _t->getNextSibling();
524                  _t = __t22;
525                  _t = _t->getNextSibling();
526 < #line 93 "MDTreeParser.g"
526 > #line 94 "MDTreeParser.g"
527                  
528                  blockStack.top()->validate();
529                  blockStack.pop();
530                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
531                  currMoleculeStamp->addAtomStamp(currAtomStamp);
532                  
533 < #line 528 "MDTreeParser.cpp"
533 > #line 534 "MDTreeParser.cpp"
534          }
535          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
536                  reportError(ex);
# Line 542 | Line 548 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
548                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
549                  match(_t,BOND);
550                  _t = _t->getFirstChild();
551 < #line 113 "MDTreeParser.g"
551 > #line 114 "MDTreeParser.g"
552                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
553 < #line 548 "MDTreeParser.cpp"
553 > #line 554 "MDTreeParser.cpp"
554                  { // ( ... )*
555                  for (;;) {
556                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 565 | Line 571 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
571                  _t = _t->getNextSibling();
572                  _t = __t29;
573                  _t = _t->getNextSibling();
574 < #line 115 "MDTreeParser.g"
574 > #line 116 "MDTreeParser.g"
575                  
576                  blockStack.pop();
577                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
578                  currMoleculeStamp->addBondStamp(currBondStamp);
579                  
580 < #line 575 "MDTreeParser.cpp"
580 > #line 581 "MDTreeParser.cpp"
581          }
582          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
583                  reportError(ex);
# Line 589 | Line 595 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
595                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
596                  match(_t,BEND);
597                  _t = _t->getFirstChild();
598 < #line 131 "MDTreeParser.g"
598 > #line 132 "MDTreeParser.g"
599                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
600 < #line 595 "MDTreeParser.cpp"
600 > #line 601 "MDTreeParser.cpp"
601                  { // ( ... )*
602                  for (;;) {
603                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 612 | Line 618 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
618                  _t = _t->getNextSibling();
619                  _t = __t35;
620                  _t = _t->getNextSibling();
621 < #line 133 "MDTreeParser.g"
621 > #line 134 "MDTreeParser.g"
622                  
623                  blockStack.top()->validate();
624                  blockStack.pop();
625                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
626                  currMoleculeStamp->addBendStamp(currBendStamp);
627                  
628 < #line 623 "MDTreeParser.cpp"
628 > #line 629 "MDTreeParser.cpp"
629          }
630          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
631                  reportError(ex);
# Line 637 | Line 643 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
643                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
644                  match(_t,TORSION);
645                  _t = _t->getFirstChild();
646 < #line 150 "MDTreeParser.g"
646 > #line 151 "MDTreeParser.g"
647                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
648 < #line 643 "MDTreeParser.cpp"
648 > #line 649 "MDTreeParser.cpp"
649                  { // ( ... )*
650                  for (;;) {
651                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 660 | Line 666 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
666                  _t = _t->getNextSibling();
667                  _t = __t41;
668                  _t = _t->getNextSibling();
669 < #line 152 "MDTreeParser.g"
669 > #line 153 "MDTreeParser.g"
670                  
671                  blockStack.top()->validate();
672                  blockStack.pop();
673                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
674                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
675                  
676 < #line 671 "MDTreeParser.cpp"
676 > #line 677 "MDTreeParser.cpp"
677          }
678          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
679                  reportError(ex);
# Line 677 | Line 683 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
683          _retTree = _t;
684   }
685  
686 < void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
687 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
682 < #line 169 "MDTreeParser.g"
686 > void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
687 >        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
688          
684 –        int index;
685 –        
686 – #line 687 "MDTreeParser.cpp"
687 –        
689          try {      // for error handling
690                  ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
691                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
692 <                match(_t,RIGIDBODY);
692 >                match(_t,INVERSION);
693                  _t = _t->getFirstChild();
694 <                index=intConst(_t);
695 <                _t = _retTree;
696 < #line 173 "MDTreeParser.g"
696 <                RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
697 < #line 698 "MDTreeParser.cpp"
694 > #line 170 "MDTreeParser.g"
695 >                InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
696 > #line 697 "MDTreeParser.cpp"
697                  { // ( ... )*
698                  for (;;) {
699                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
700                                  _t = ASTNULL;
701 <                        if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
702 <                                rigidbodystatement(_t);
701 >                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
702 >                                inversionstatement(_t);
703                                  _t = _retTree;
704                          }
705                          else {
# Line 715 | Line 714 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
714                  _t = _t->getNextSibling();
715                  _t = __t47;
716                  _t = _t->getNextSibling();
717 < #line 175 "MDTreeParser.g"
717 > #line 172 "MDTreeParser.g"
718                  
719                  blockStack.top()->validate();
720                  blockStack.pop();
721                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
722 <                currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
722 >                currMoleculeStamp->addInversionStamp(currInversionStamp);
723                  
724 < #line 726 "MDTreeParser.cpp"
724 > #line 725 "MDTreeParser.cpp"
725          }
726          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
727                  reportError(ex);
# Line 732 | Line 731 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
731          _retTree = _t;
732   }
733  
734 < void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
735 <        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
734 > void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
735 >        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
736 > #line 189 "MDTreeParser.g"
737          
738 +        int index;
739 +        
740 + #line 741 "MDTreeParser.cpp"
741 +        
742          try {      // for error handling
743                  ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
744                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745 <                match(_t,CUTOFFGROUP);
745 >                match(_t,RIGIDBODY);
746                  _t = _t->getFirstChild();
747 < #line 192 "MDTreeParser.g"
748 <                CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
749 < #line 746 "MDTreeParser.cpp"
747 >                index=intConst(_t);
748 >                _t = _retTree;
749 > #line 193 "MDTreeParser.g"
750 >                RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
751 > #line 752 "MDTreeParser.cpp"
752                  { // ( ... )*
753                  for (;;) {
754                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
755                                  _t = ASTNULL;
756                          if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
757 <                                cutoffgroupstatement(_t);
757 >                                rigidbodystatement(_t);
758                                  _t = _retTree;
759                          }
760                          else {
# Line 763 | Line 769 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
769                  _t = _t->getNextSibling();
770                  _t = __t53;
771                  _t = _t->getNextSibling();
772 < #line 194 "MDTreeParser.g"
772 > #line 195 "MDTreeParser.g"
773                  
774                  blockStack.top()->validate();
775                  blockStack.pop();
776                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
777 +                currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
778 +                
779 + #line 780 "MDTreeParser.cpp"
780 +        }
781 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
782 +                reportError(ex);
783 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
784 +                        _t = _t->getNextSibling();
785 +        }
786 +        _retTree = _t;
787 + }
788 +
789 + void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
790 +        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
791 +        
792 +        try {      // for error handling
793 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
794 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
795 +                match(_t,CUTOFFGROUP);
796 +                _t = _t->getFirstChild();
797 + #line 212 "MDTreeParser.g"
798 +                CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
799 + #line 800 "MDTreeParser.cpp"
800 +                { // ( ... )*
801 +                for (;;) {
802 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
803 +                                _t = ASTNULL;
804 +                        if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
805 +                                cutoffgroupstatement(_t);
806 +                                _t = _retTree;
807 +                        }
808 +                        else {
809 +                                goto _loop61;
810 +                        }
811 +                        
812 +                }
813 +                _loop61:;
814 +                } // ( ... )*
815 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
816 +                match(_t,ENDBLOCK);
817 +                _t = _t->getNextSibling();
818 +                _t = __t59;
819 +                _t = _t->getNextSibling();
820 + #line 214 "MDTreeParser.g"
821 +                
822 +                blockStack.top()->validate();
823 +                blockStack.pop();
824 +                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
825                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
826                  
827 < #line 774 "MDTreeParser.cpp"
827 > #line 828 "MDTreeParser.cpp"
828          }
829          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
830                  reportError(ex);
# Line 782 | Line 836 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
836  
837   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
838          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
839 < #line 211 "MDTreeParser.g"
839 > #line 231 "MDTreeParser.g"
840          int ival;
841 < #line 788 "MDTreeParser.cpp"
841 > #line 842 "MDTreeParser.cpp"
842          
843          try {      // for error handling
844 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
845 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
844 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
845 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
846                  match(_t,FRAGMENT);
847                  _t = _t->getFirstChild();
848                  ival=intConst(_t);
849                  _t = _retTree;
850 < #line 212 "MDTreeParser.g"
850 > #line 232 "MDTreeParser.g"
851                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
852 < #line 799 "MDTreeParser.cpp"
852 > #line 853 "MDTreeParser.cpp"
853                  { // ( ... )*
854                  for (;;) {
855                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 805 | Line 859 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
859                                  _t = _retTree;
860                          }
861                          else {
862 <                                goto _loop61;
862 >                                goto _loop67;
863                          }
864                          
865                  }
866 <                _loop61:;
866 >                _loop67:;
867                  } // ( ... )*
868 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
868 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
869                  match(_t,ENDBLOCK);
870                  _t = _t->getNextSibling();
871 <                _t = __t59;
871 >                _t = __t65;
872                  _t = _t->getNextSibling();
873 < #line 214 "MDTreeParser.g"
873 > #line 234 "MDTreeParser.g"
874                  
875                  blockStack.top()->validate();
876                  blockStack.pop();
877                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
878                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
879                  
880 < #line 827 "MDTreeParser.cpp"
880 > #line 881 "MDTreeParser.cpp"
881          }
882          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
883                  reportError(ex);
# Line 835 | Line 889 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
889  
890   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
891          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
892 < #line 101 "MDTreeParser.g"
892 > #line 102 "MDTreeParser.g"
893          
894 <        vector<double> dvec;
894 >        vector<RealType> dvec;
895          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
896          
897          
898 < #line 845 "MDTreeParser.cpp"
898 > #line 899 "MDTreeParser.cpp"
899          
900          try {      // for error handling
901                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 856 | Line 910 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
910                  case POSITION:
911                  {
912                          ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
913 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
913 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
914                          match(_t,POSITION);
915                          _t = _t->getFirstChild();
916                          dvec=doubleNumberTuple(_t);
917                          _t = _retTree;
918                          _t = __t26;
919                          _t = _t->getNextSibling();
920 < #line 108 "MDTreeParser.g"
920 > #line 109 "MDTreeParser.g"
921                          currAtomStamp->setPosition(dvec);
922 < #line 869 "MDTreeParser.cpp"
922 > #line 923 "MDTreeParser.cpp"
923                          break;
924                  }
925                  case ORIENTATION:
926                  {
927                          ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
928 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
928 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
929                          match(_t,ORIENTATION);
930                          _t = _t->getFirstChild();
931                          dvec=doubleNumberTuple(_t);
932                          _t = _retTree;
933                          _t = __t27;
934                          _t = _t->getNextSibling();
935 < #line 109 "MDTreeParser.g"
935 > #line 110 "MDTreeParser.g"
936                          currAtomStamp->setOrientation(dvec);
937 < #line 884 "MDTreeParser.cpp"
937 > #line 938 "MDTreeParser.cpp"
938                          break;
939                  }
940                  default:
# Line 897 | Line 951 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
951          _retTree = _t;
952   }
953  
954 < vector<double>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
955 < #line 227 "MDTreeParser.g"
956 <        vector<double> dvec;
957 < #line 904 "MDTreeParser.cpp"
958 <        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
959 < #line 227 "MDTreeParser.g"
954 > vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
955 > #line 247 "MDTreeParser.g"
956 >        vector<RealType> dvec;
957 > #line 958 "MDTreeParser.cpp"
958 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
959 > #line 247 "MDTreeParser.g"
960          
961 <        double dval;
961 >        RealType dval;
962          
963 < #line 910 "MDTreeParser.cpp"
963 > #line 964 "MDTreeParser.cpp"
964          
965          try {      // for error handling
966                  { // ( ... )+
967 <                int _cnt65=0;
967 >                int _cnt71=0;
968                  for (;;) {
969                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
970                                  _t = ASTNULL;
971                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
972                                  dval=doubleNumber(_t);
973                                  _t = _retTree;
974 < #line 231 "MDTreeParser.g"
974 > #line 251 "MDTreeParser.g"
975                                  dvec.push_back(dval);
976 < #line 923 "MDTreeParser.cpp"
976 > #line 977 "MDTreeParser.cpp"
977                          }
978                          else {
979 <                                if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
979 >                                if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
980                          }
981                          
982 <                        _cnt65++;
982 >                        _cnt71++;
983                  }
984 <                _loop65:;
984 >                _loop71:;
985                  }  // ( ... )+
986          }
987          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 941 | Line 995 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
995  
996   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
997          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
998 < #line 122 "MDTreeParser.g"
998 > #line 123 "MDTreeParser.g"
999          
1000          vector<int> ivec;
1001          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1002          
1003 < #line 950 "MDTreeParser.cpp"
1003 > #line 1004 "MDTreeParser.cpp"
1004          
1005          try {      // for error handling
1006                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 961 | Line 1015 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1015                  case MEMBERS:
1016                  {
1017                          ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1018 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1018 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1019                          match(_t,MEMBERS);
1020                          _t = _t->getFirstChild();
1021                          ivec=inttuple(_t);
1022                          _t = _retTree;
1023                          _t = __t33;
1024                          _t = _t->getNextSibling();
1025 < #line 128 "MDTreeParser.g"
1025 > #line 129 "MDTreeParser.g"
1026                          currBondStamp->setMembers(ivec);
1027 < #line 974 "MDTreeParser.cpp"
1027 > #line 1028 "MDTreeParser.cpp"
1028                          break;
1029                  }
1030                  default:
# Line 988 | Line 1042 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1042   }
1043  
1044   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1045 < #line 234 "MDTreeParser.g"
1045 > #line 254 "MDTreeParser.g"
1046          vector<int> ivec;
1047 < #line 994 "MDTreeParser.cpp"
1047 > #line 1048 "MDTreeParser.cpp"
1048          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1049 < #line 234 "MDTreeParser.g"
1049 > #line 254 "MDTreeParser.g"
1050          
1051          int ival;
1052          
1053 < #line 1000 "MDTreeParser.cpp"
1053 > #line 1054 "MDTreeParser.cpp"
1054          
1055          try {      // for error handling
1056                  { // ( ... )+
1057 <                int _cnt68=0;
1057 >                int _cnt74=0;
1058                  for (;;) {
1059                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1060                                  _t = ASTNULL;
1061                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1062                                  ival=intConst(_t);
1063                                  _t = _retTree;
1064 < #line 238 "MDTreeParser.g"
1064 > #line 258 "MDTreeParser.g"
1065                                  ivec.push_back(ival);
1066 < #line 1013 "MDTreeParser.cpp"
1066 > #line 1067 "MDTreeParser.cpp"
1067                          }
1068                          else {
1069 <                                if ( _cnt68>=1 ) { goto _loop68; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1069 >                                if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1070                          }
1071                          
1072 <                        _cnt68++;
1072 >                        _cnt74++;
1073                  }
1074 <                _loop68:;
1074 >                _loop74:;
1075                  }  // ( ... )+
1076          }
1077          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1031 | Line 1085 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1085  
1086   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1087          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088 < #line 141 "MDTreeParser.g"
1088 > #line 142 "MDTreeParser.g"
1089          
1090          vector<int> ivec;
1091          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1092          
1093 < #line 1040 "MDTreeParser.cpp"
1093 > #line 1094 "MDTreeParser.cpp"
1094          
1095          try {      // for error handling
1096                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1051 | Line 1105 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1105                  case MEMBERS:
1106                  {
1107                          ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1108 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1108 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1109                          match(_t,MEMBERS);
1110                          _t = _t->getFirstChild();
1111                          ivec=inttuple(_t);
1112                          _t = _retTree;
1113                          _t = __t39;
1114                          _t = _t->getNextSibling();
1115 < #line 147 "MDTreeParser.g"
1115 > #line 148 "MDTreeParser.g"
1116                          currBendStamp->setMembers(ivec);
1117 < #line 1064 "MDTreeParser.cpp"
1117 > #line 1118 "MDTreeParser.cpp"
1118                          break;
1119                  }
1120                  default:
# Line 1079 | Line 1133 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1133  
1134   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1135          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1136 < #line 160 "MDTreeParser.g"
1136 > #line 161 "MDTreeParser.g"
1137          
1138          vector<int> ivec;
1139          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1140          
1141 < #line 1088 "MDTreeParser.cpp"
1141 > #line 1142 "MDTreeParser.cpp"
1142          
1143          try {      // for error handling
1144                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1099 | Line 1153 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1153                  case MEMBERS:
1154                  {
1155                          ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1156 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1156 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1157                          match(_t,MEMBERS);
1158                          _t = _t->getFirstChild();
1159                          ivec=inttuple(_t);
1160                          _t = _retTree;
1161                          _t = __t45;
1162                          _t = _t->getNextSibling();
1163 < #line 166 "MDTreeParser.g"
1163 > #line 167 "MDTreeParser.g"
1164                          currTorsionStamp->setMembers(ivec);
1165 < #line 1112 "MDTreeParser.cpp"
1165 > #line 1166 "MDTreeParser.cpp"
1166                          break;
1167                  }
1168                  default:
# Line 1125 | Line 1179 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1179          _retTree = _t;
1180   }
1181  
1182 + void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1183 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1184 + #line 180 "MDTreeParser.g"
1185 +        
1186 +        int icent;
1187 +        InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1188 +        
1189 + #line 1190 "MDTreeParser.cpp"
1190 +        
1191 +        try {      // for error handling
1192 +                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1193 +                        _t = ASTNULL;
1194 +                switch ( _t->getType()) {
1195 +                case ASSIGNEQUAL:
1196 +                {
1197 +                        assignment(_t);
1198 +                        _t = _retTree;
1199 +                        break;
1200 +                }
1201 +                case CENTER:
1202 +                {
1203 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1204 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1205 +                        match(_t,CENTER);
1206 +                        _t = _t->getFirstChild();
1207 +                        icent=intConst(_t);
1208 +                        _t = _retTree;
1209 +                        _t = __t51;
1210 +                        _t = _t->getNextSibling();
1211 + #line 186 "MDTreeParser.g"
1212 +                        currInversionStamp->setCenter(icent);
1213 + #line 1214 "MDTreeParser.cpp"
1214 +                        break;
1215 +                }
1216 +                default:
1217 +                {
1218 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1219 +                }
1220 +                }
1221 +        }
1222 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1223 +                reportError(ex);
1224 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1225 +                        _t = _t->getNextSibling();
1226 +        }
1227 +        _retTree = _t;
1228 + }
1229 +
1230   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1231          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1232 < #line 183 "MDTreeParser.g"
1232 > #line 203 "MDTreeParser.g"
1233          
1234          vector<int> ivec;
1235          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1236          
1237 < #line 1136 "MDTreeParser.cpp"
1237 > #line 1238 "MDTreeParser.cpp"
1238          
1239          try {      // for error handling
1240                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1146 | Line 1248 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1248                  }
1249                  case MEMBERS:
1250                  {
1251 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1252 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1251 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1252 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1253                          match(_t,MEMBERS);
1254                          _t = _t->getFirstChild();
1255                          ivec=inttuple(_t);
1256                          _t = _retTree;
1257 <                        _t = __t51;
1257 >                        _t = __t57;
1258                          _t = _t->getNextSibling();
1259 < #line 189 "MDTreeParser.g"
1259 > #line 209 "MDTreeParser.g"
1260                          currRigidBodyStamp->setMembers(ivec);
1261 < #line 1160 "MDTreeParser.cpp"
1261 > #line 1262 "MDTreeParser.cpp"
1262                          break;
1263                  }
1264                  default:
# Line 1175 | Line 1277 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1277  
1278   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1279          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1280 < #line 202 "MDTreeParser.g"
1280 > #line 222 "MDTreeParser.g"
1281          
1282          vector<int> ivec;
1283          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1284          
1285 < #line 1184 "MDTreeParser.cpp"
1285 > #line 1286 "MDTreeParser.cpp"
1286          
1287          try {      // for error handling
1288                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1194 | Line 1296 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1296                  }
1297                  case MEMBERS:
1298                  {
1299 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1300 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1299 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1300 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1301                          match(_t,MEMBERS);
1302                          _t = _t->getFirstChild();
1303                          ivec=inttuple(_t);
1304                          _t = _retTree;
1305 <                        _t = __t57;
1305 >                        _t = __t63;
1306                          _t = _t->getNextSibling();
1307 < #line 208 "MDTreeParser.g"
1307 > #line 228 "MDTreeParser.g"
1308                          currCutoffGroupStamp->setMembers(ivec);
1309 < #line 1208 "MDTreeParser.cpp"
1309 > #line 1310 "MDTreeParser.cpp"
1310                          break;
1311                  }
1312                  default:
# Line 1236 | Line 1338 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1338          _retTree = _t;
1339   }
1340  
1341 < double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342 < #line 248 "MDTreeParser.g"
1343 <        double dval;
1344 < #line 1243 "MDTreeParser.cpp"
1341 > RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342 > #line 268 "MDTreeParser.g"
1343 >        RealType dval;
1344 > #line 1345 "MDTreeParser.cpp"
1345          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1346          ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1347          ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 1254 | Line 1356 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1356                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357                          intConst(_t);
1358                          _t = _retTree;
1359 < #line 250 "MDTreeParser.g"
1360 <                        dval = lexi_cast<double>(ic->getText());
1361 < #line 1260 "MDTreeParser.cpp"
1359 > #line 270 "MDTreeParser.g"
1360 >                        dval = lexi_cast<RealType>(ic->getText());
1361 > #line 1362 "MDTreeParser.cpp"
1362                          break;
1363                  }
1364                  case NUM_FLOAT:
# Line 1265 | Line 1367 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1367                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1368                          floatConst(_t);
1369                          _t = _retTree;
1370 < #line 251 "MDTreeParser.g"
1371 <                        dval = lexi_cast<double>(fc->getText());
1372 < #line 1271 "MDTreeParser.cpp"
1370 > #line 271 "MDTreeParser.g"
1371 >                        dval = lexi_cast<RealType>(fc->getText());
1372 > #line 1373 "MDTreeParser.cpp"
1373                          break;
1374                  }
1375                  default:
# Line 1300 | Line 1402 | const char* MDTreeParser::tokenNames[] = {
1402          "\"bond\"",
1403          "\"bend\"",
1404          "\"torsion\"",
1405 +        "\"inversion\"",
1406          "\"rigidBody\"",
1407          "\"cutoffGroup\"",
1408          "\"fragment\"",
1409          "\"members\"",
1410 +        "\"center\"",
1411          "\"position\"",
1412          "\"orientation\"",
1413          "ENDBLOCK",
# Line 1343 | Line 1447 | const char* MDTreeParser::tokenNames[] = {
1447          0
1448   };
1449  
1450 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1450 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1451   // "component" "molecule" "zconstraint" ASSIGNEQUAL
1452   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1453 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1454 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1455 < // ASSIGNEQUAL
1453 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1454 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1455 > // "fragment" ASSIGNEQUAL
1456   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1457  
1458  

Diff Legend

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