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

Comparing trunk/src/mdParser/MDParser.cpp (file contents):
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.4: "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20080702): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 53 | Line 53 | void MDParser::mdfile() {
53          }
54          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
55                  reportError(ex);
56 <                consume();
57 <                consumeUntil(_tokenSet_1);
56 >                recover(ex,_tokenSet_1);
57          }
58          returnAST = mdfile_AST;
59   }
# Line 102 | Line 101 | void MDParser::statement() {
101          }
102          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
103                  reportError(ex);
104 <                consume();
106 <                consumeUntil(_tokenSet_2);
104 >                recover(ex,_tokenSet_2);
105          }
106          returnAST = statement_AST;
107   }
# Line 129 | Line 127 | void MDParser::assignment() {
127          }
128          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
129                  reportError(ex);
130 <                consume();
133 <                consumeUntil(_tokenSet_3);
130 >                recover(ex,_tokenSet_3);
131          }
132          returnAST = assignment_AST;
133   }
# Line 165 | Line 162 | void MDParser::componentblock() {
162                  match(RCURLY);
163   #line 65 "MDParser.g"
164                  tmp6_AST->setType(ENDBLOCK);
165 < #line 169 "MDParser.cpp"
165 > #line 166 "MDParser.cpp"
166                  componentblock_AST = currentAST.root;
167          }
168          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
169                  reportError(ex);
170 <                consume();
174 <                consumeUntil(_tokenSet_2);
170 >                recover(ex,_tokenSet_2);
171          }
172          returnAST = componentblock_AST;
173   }
# Line 206 | Line 202 | void MDParser::moleculeblock() {
202                  match(RCURLY);
203   #line 71 "MDParser.g"
204                  tmp9_AST->setType(ENDBLOCK);
205 < #line 210 "MDParser.cpp"
205 > #line 206 "MDParser.cpp"
206                  moleculeblock_AST = currentAST.root;
207          }
208          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
209                  reportError(ex);
210 <                consume();
215 <                consumeUntil(_tokenSet_2);
210 >                recover(ex,_tokenSet_2);
211          }
212          returnAST = moleculeblock_AST;
213   }
# Line 247 | Line 242 | void MDParser::zconstraintblock() {
242                  match(RCURLY);
243   #line 68 "MDParser.g"
244                  tmp12_AST->setType(ENDBLOCK);
245 < #line 251 "MDParser.cpp"
245 > #line 246 "MDParser.cpp"
246                  zconstraintblock_AST = currentAST.root;
247          }
248          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
249                  reportError(ex);
250 <                consume();
256 <                consumeUntil(_tokenSet_2);
250 >                recover(ex,_tokenSet_2);
251          }
252          returnAST = zconstraintblock_AST;
253   }
# Line 307 | Line 301 | void MDParser::constant() {
301          }
302          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
303                  reportError(ex);
304 <                consume();
311 <                consumeUntil(_tokenSet_5);
304 >                recover(ex,_tokenSet_5);
305          }
306          returnAST = constant_AST;
307   }
# Line 346 | Line 339 | void MDParser::intConst() {
339          }
340          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
341                  reportError(ex);
342 <                consume();
350 <                consumeUntil(_tokenSet_6);
342 >                recover(ex,_tokenSet_6);
343          }
344          returnAST = intConst_AST;
345   }
# Line 385 | Line 377 | void MDParser::floatConst() {
377          }
378          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
379                  reportError(ex);
380 <                consume();
389 <                consumeUntil(_tokenSet_7);
380 >                recover(ex,_tokenSet_7);
381          }
382          returnAST = floatConst_AST;
383   }
# Line 433 | Line 424 | void MDParser::moleculestatement() {
424                          moleculestatement_AST = currentAST.root;
425                          break;
426                  }
427 +                case INVERSION:
428 +                {
429 +                        inversionblock();
430 +                        astFactory->addASTChild( currentAST, returnAST );
431 +                        moleculestatement_AST = currentAST.root;
432 +                        break;
433 +                }
434                  case RIGIDBODY:
435                  {
436                          rigidbodyblock();
# Line 462 | Line 460 | void MDParser::moleculestatement() {
460          }
461          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
462                  reportError(ex);
463 <                consume();
466 <                consumeUntil(_tokenSet_8);
463 >                recover(ex,_tokenSet_8);
464          }
465          returnAST = moleculestatement_AST;
466   }
# Line 500 | Line 497 | void MDParser::atomblock() {
497                  tmp23_AST = astFactory->create(LT(1));
498                  astFactory->addASTChild(currentAST, tmp23_AST);
499                  match(RCURLY);
500 < #line 84 "MDParser.g"
500 > #line 85 "MDParser.g"
501                  tmp23_AST->setType(ENDBLOCK);
502 < #line 506 "MDParser.cpp"
502 > #line 503 "MDParser.cpp"
503                  atomblock_AST = currentAST.root;
504          }
505          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
506                  reportError(ex);
507 <                consume();
511 <                consumeUntil(_tokenSet_8);
507 >                recover(ex,_tokenSet_8);
508          }
509          returnAST = atomblock_AST;
510   }
# Line 560 | Line 556 | void MDParser::bondblock() {
556                  tmp28_AST = astFactory->create(LT(1));
557                  astFactory->addASTChild(currentAST, tmp28_AST);
558                  match(RCURLY);
559 < #line 93 "MDParser.g"
559 > #line 94 "MDParser.g"
560                  tmp28_AST->setType(ENDBLOCK);
561 < #line 566 "MDParser.cpp"
561 > #line 562 "MDParser.cpp"
562                  bondblock_AST = currentAST.root;
563          }
564          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
565                  reportError(ex);
566 <                consume();
571 <                consumeUntil(_tokenSet_8);
566 >                recover(ex,_tokenSet_8);
567          }
568          returnAST = bondblock_AST;
569   }
# Line 620 | Line 615 | void MDParser::bendblock() {
615                  tmp33_AST = astFactory->create(LT(1));
616                  astFactory->addASTChild(currentAST, tmp33_AST);
617                  match(RCURLY);
618 < #line 100 "MDParser.g"
618 > #line 101 "MDParser.g"
619                  tmp33_AST->setType(ENDBLOCK);
620 < #line 626 "MDParser.cpp"
620 > #line 621 "MDParser.cpp"
621                  bendblock_AST = currentAST.root;
622          }
623          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
624                  reportError(ex);
625 <                consume();
631 <                consumeUntil(_tokenSet_8);
625 >                recover(ex,_tokenSet_8);
626          }
627          returnAST = bendblock_AST;
628   }
# Line 680 | Line 674 | void MDParser::torsionblock() {
674                  tmp38_AST = astFactory->create(LT(1));
675                  astFactory->addASTChild(currentAST, tmp38_AST);
676                  match(RCURLY);
677 < #line 107 "MDParser.g"
677 > #line 108 "MDParser.g"
678                  tmp38_AST->setType(ENDBLOCK);
679 < #line 686 "MDParser.cpp"
679 > #line 680 "MDParser.cpp"
680                  torsionblock_AST = currentAST.root;
681          }
682          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683                  reportError(ex);
684 <                consume();
691 <                consumeUntil(_tokenSet_8);
684 >                recover(ex,_tokenSet_8);
685          }
686          returnAST = torsionblock_AST;
687   }
688  
689 < void MDParser::rigidbodyblock() {
689 > void MDParser::inversionblock() {
690          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
691          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
692 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
692 >        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
693          
694          try {      // for error handling
695                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
696                  tmp39_AST = astFactory->create(LT(1));
697                  astFactory->makeASTRoot(currentAST, tmp39_AST);
698 +                match(INVERSION);
699 +                {
700 +                switch ( LA(1)) {
701 +                case LBRACKET:
702 +                {
703 +                        match(LBRACKET);
704 +                        intConst();
705 +                        match(RBRACKET);
706 +                        break;
707 +                }
708 +                case LCURLY:
709 +                {
710 +                        break;
711 +                }
712 +                default:
713 +                {
714 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
715 +                }
716 +                }
717 +                }
718 +                match(LCURLY);
719 +                { // ( ... )*
720 +                for (;;) {
721 +                        if ((LA(1) == CENTER || LA(1) == ID)) {
722 +                                inversionstatement();
723 +                                astFactory->addASTChild( currentAST, returnAST );
724 +                        }
725 +                        else {
726 +                                goto _loop39;
727 +                        }
728 +                        
729 +                }
730 +                _loop39:;
731 +                } // ( ... )*
732 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
733 +                tmp43_AST = astFactory->create(LT(1));
734 +                astFactory->addASTChild(currentAST, tmp43_AST);
735 +                match(RCURLY);
736 + #line 115 "MDParser.g"
737 +                tmp43_AST->setType(ENDBLOCK);
738 + #line 739 "MDParser.cpp"
739 +                inversionblock_AST = currentAST.root;
740 +        }
741 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
742 +                reportError(ex);
743 +                recover(ex,_tokenSet_8);
744 +        }
745 +        returnAST = inversionblock_AST;
746 + }
747 +
748 + void MDParser::rigidbodyblock() {
749 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
750 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
751 +        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
752 +        
753 +        try {      // for error handling
754 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755 +                tmp44_AST = astFactory->create(LT(1));
756 +                astFactory->makeASTRoot(currentAST, tmp44_AST);
757                  match(RIGIDBODY);
758                  match(LBRACKET);
759                  intConst();
# Line 721 | Line 773 | void MDParser::rigidbodyblock() {
773                  }
774                  _loop43:;
775                  } // ( ... )*
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 <                tmp43_AST = astFactory->create(LT(1));
778 <                astFactory->addASTChild(currentAST, tmp43_AST);
776 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 >                tmp48_AST = astFactory->create(LT(1));
778 >                astFactory->addASTChild(currentAST, tmp48_AST);
779                  match(RCURLY);
780 < #line 121 "MDParser.g"
781 <                tmp43_AST->setType(ENDBLOCK);
782 < #line 731 "MDParser.cpp"
780 > #line 122 "MDParser.g"
781 >                tmp48_AST->setType(ENDBLOCK);
782 > #line 783 "MDParser.cpp"
783                  rigidbodyblock_AST = currentAST.root;
784          }
785          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
786                  reportError(ex);
787 <                consume();
736 <                consumeUntil(_tokenSet_8);
787 >                recover(ex,_tokenSet_8);
788          }
789          returnAST = rigidbodyblock_AST;
790   }
# Line 744 | Line 795 | void MDParser::cutoffgroupblock() {
795          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
796          
797          try {      // for error handling
798 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 <                tmp44_AST = astFactory->create(LT(1));
800 <                astFactory->makeASTRoot(currentAST, tmp44_AST);
798 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 >                tmp49_AST = astFactory->create(LT(1));
800 >                astFactory->makeASTRoot(currentAST, tmp49_AST);
801                  match(CUTOFFGROUP);
802                  {
803                  switch ( LA(1)) {
# Line 781 | Line 832 | void MDParser::cutoffgroupblock() {
832                  }
833                  _loop48:;
834                  } // ( ... )*
835 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 <                tmp48_AST = astFactory->create(LT(1));
837 <                astFactory->addASTChild(currentAST, tmp48_AST);
835 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 >                tmp53_AST = astFactory->create(LT(1));
837 >                astFactory->addASTChild(currentAST, tmp53_AST);
838                  match(RCURLY);
839 < #line 128 "MDParser.g"
840 <                tmp48_AST->setType(ENDBLOCK);
841 < #line 791 "MDParser.cpp"
839 > #line 129 "MDParser.g"
840 >                tmp53_AST->setType(ENDBLOCK);
841 > #line 842 "MDParser.cpp"
842                  cutoffgroupblock_AST = currentAST.root;
843          }
844          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
845                  reportError(ex);
846 <                consume();
796 <                consumeUntil(_tokenSet_8);
846 >                recover(ex,_tokenSet_8);
847          }
848          returnAST = cutoffgroupblock_AST;
849   }
# Line 804 | Line 854 | void MDParser::fragmentblock() {
854          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
855          
856          try {      // for error handling
857 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 <                tmp49_AST = astFactory->create(LT(1));
859 <                astFactory->makeASTRoot(currentAST, tmp49_AST);
857 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 >                tmp54_AST = astFactory->create(LT(1));
859 >                astFactory->makeASTRoot(currentAST, tmp54_AST);
860                  match(FRAGMENT);
861                  match(LBRACKET);
862                  intConst();
# Line 826 | Line 876 | void MDParser::fragmentblock() {
876                  }
877                  _loop52:;
878                  } // ( ... )*
879 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 <                tmp53_AST = astFactory->create(LT(1));
881 <                astFactory->addASTChild(currentAST, tmp53_AST);
879 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 >                tmp58_AST = astFactory->create(LT(1));
881 >                astFactory->addASTChild(currentAST, tmp58_AST);
882                  match(RCURLY);
883 < #line 135 "MDParser.g"
884 <                tmp53_AST->setType(ENDBLOCK);
885 < #line 836 "MDParser.cpp"
883 > #line 136 "MDParser.g"
884 >                tmp58_AST->setType(ENDBLOCK);
885 > #line 886 "MDParser.cpp"
886                  fragmentblock_AST = currentAST.root;
887          }
888          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
889                  reportError(ex);
890 <                consume();
841 <                consumeUntil(_tokenSet_8);
890 >                recover(ex,_tokenSet_8);
891          }
892          returnAST = fragmentblock_AST;
893   }
# Line 859 | Line 908 | void MDParser::atomstatement() {
908                  }
909                  case POSITION:
910                  {
911 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 <                        tmp54_AST = astFactory->create(LT(1));
913 <                        astFactory->makeASTRoot(currentAST, tmp54_AST);
911 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 >                        tmp59_AST = astFactory->create(LT(1));
913 >                        astFactory->makeASTRoot(currentAST, tmp59_AST);
914                          match(POSITION);
915                          match(LPAREN);
916                          doubleNumberTuple();
# Line 873 | Line 922 | void MDParser::atomstatement() {
922                  }
923                  case ORIENTATION:
924                  {
925 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 <                        tmp58_AST = astFactory->create(LT(1));
927 <                        astFactory->makeASTRoot(currentAST, tmp58_AST);
925 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 >                        tmp63_AST = astFactory->create(LT(1));
927 >                        astFactory->makeASTRoot(currentAST, tmp63_AST);
928                          match(ORIENTATION);
929                          match(LPAREN);
930                          doubleNumberTuple();
# Line 893 | Line 942 | void MDParser::atomstatement() {
942          }
943          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944                  reportError(ex);
945 <                consume();
897 <                consumeUntil(_tokenSet_10);
945 >                recover(ex,_tokenSet_10);
946          }
947          returnAST = atomstatement_AST;
948   }
# Line 925 | Line 973 | void MDParser::doubleNumberTuple() {
973          }
974          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
975                  reportError(ex);
976 <                consume();
929 <                consumeUntil(_tokenSet_11);
976 >                recover(ex,_tokenSet_11);
977          }
978          returnAST = doubleNumberTuple_AST;
979   }
# Line 947 | Line 994 | void MDParser::bondstatement() {
994                  }
995                  case MEMBERS:
996                  {
997 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 <                        tmp63_AST = astFactory->create(LT(1));
999 <                        astFactory->makeASTRoot(currentAST, tmp63_AST);
997 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 >                        tmp68_AST = astFactory->create(LT(1));
999 >                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1000                          match(MEMBERS);
1001                          match(LPAREN);
1002                          inttuple();
# Line 967 | Line 1014 | void MDParser::bondstatement() {
1014          }
1015          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1016                  reportError(ex);
1017 <                consume();
971 <                consumeUntil(_tokenSet_12);
1017 >                recover(ex,_tokenSet_12);
1018          }
1019          returnAST = bondstatement_AST;
1020   }
# Line 999 | Line 1045 | void MDParser::inttuple() {
1045          }
1046          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047                  reportError(ex);
1048 <                consume();
1003 <                consumeUntil(_tokenSet_11);
1048 >                recover(ex,_tokenSet_11);
1049          }
1050          returnAST = inttuple_AST;
1051   }
# Line 1021 | Line 1066 | void MDParser::bendstatement() {
1066                  }
1067                  case MEMBERS:
1068                  {
1069 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 <                        tmp68_AST = astFactory->create(LT(1));
1071 <                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1069 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 >                        tmp73_AST = astFactory->create(LT(1));
1071 >                        astFactory->makeASTRoot(currentAST, tmp73_AST);
1072                          match(MEMBERS);
1073                          match(LPAREN);
1074                          inttuple();
# Line 1041 | Line 1086 | void MDParser::bendstatement() {
1086          }
1087          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1088                  reportError(ex);
1089 <                consume();
1045 <                consumeUntil(_tokenSet_12);
1089 >                recover(ex,_tokenSet_12);
1090          }
1091          returnAST = bendstatement_AST;
1092   }
# Line 1063 | Line 1107 | void MDParser::torsionstatement() {
1107                  }
1108                  case MEMBERS:
1109                  {
1110 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 <                        tmp72_AST = astFactory->create(LT(1));
1112 <                        astFactory->makeASTRoot(currentAST, tmp72_AST);
1110 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 >                        tmp77_AST = astFactory->create(LT(1));
1112 >                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1113                          match(MEMBERS);
1114                          match(LPAREN);
1115                          inttuple();
# Line 1083 | Line 1127 | void MDParser::torsionstatement() {
1127          }
1128          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1129                  reportError(ex);
1130 <                consume();
1087 <                consumeUntil(_tokenSet_12);
1130 >                recover(ex,_tokenSet_12);
1131          }
1132          returnAST = torsionstatement_AST;
1133   }
1134  
1092 – void MDParser::inversionblock() {
1093 –        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1094 –        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1095 –        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1096 –        
1097 –        try {      // for error handling
1098 –                ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1099 –                tmp76_AST = astFactory->create(LT(1));
1100 –                astFactory->makeASTRoot(currentAST, tmp76_AST);
1101 –                match(INVERSION);
1102 –                {
1103 –                switch ( LA(1)) {
1104 –                case LBRACKET:
1105 –                {
1106 –                        match(LBRACKET);
1107 –                        intConst();
1108 –                        match(RBRACKET);
1109 –                        break;
1110 –                }
1111 –                case LCURLY:
1112 –                {
1113 –                        break;
1114 –                }
1115 –                default:
1116 –                {
1117 –                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1118 –                }
1119 –                }
1120 –                }
1121 –                match(LCURLY);
1122 –                { // ( ... )*
1123 –                for (;;) {
1124 –                        if ((LA(1) == CENTER || LA(1) == ID)) {
1125 –                                inversionstatement();
1126 –                                astFactory->addASTChild( currentAST, returnAST );
1127 –                        }
1128 –                        else {
1129 –                                goto _loop39;
1130 –                        }
1131 –                        
1132 –                }
1133 –                _loop39:;
1134 –                } // ( ... )*
1135 –                ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1136 –                tmp80_AST = astFactory->create(LT(1));
1137 –                astFactory->addASTChild(currentAST, tmp80_AST);
1138 –                match(RCURLY);
1139 – #line 114 "MDParser.g"
1140 –                tmp80_AST->setType(ENDBLOCK);
1141 – #line 1142 "MDParser.cpp"
1142 –                inversionblock_AST = currentAST.root;
1143 –        }
1144 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1145 –                reportError(ex);
1146 –                consume();
1147 –                consumeUntil(_tokenSet_1);
1148 –        }
1149 –        returnAST = inversionblock_AST;
1150 – }
1151 –
1135   void MDParser::inversionstatement() {
1136          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1137          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 1185 | Line 1168 | void MDParser::inversionstatement() {
1168          }
1169          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1170                  reportError(ex);
1171 <                consume();
1189 <                consumeUntil(_tokenSet_13);
1171 >                recover(ex,_tokenSet_13);
1172          }
1173          returnAST = inversionstatement_AST;
1174   }
# Line 1227 | Line 1209 | void MDParser::rigidbodystatement() {
1209          }
1210          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1211                  reportError(ex);
1212 <                consume();
1231 <                consumeUntil(_tokenSet_12);
1212 >                recover(ex,_tokenSet_12);
1213          }
1214          returnAST = rigidbodystatement_AST;
1215   }
# Line 1269 | Line 1250 | void MDParser::cutoffgroupstatement() {
1250          }
1251          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1252                  reportError(ex);
1253 <                consume();
1273 <                consumeUntil(_tokenSet_12);
1253 >                recover(ex,_tokenSet_12);
1254          }
1255          returnAST = cutoffgroupstatement_AST;
1256   }
# Line 1287 | Line 1267 | void MDParser::fragmentstatement() {
1267          }
1268          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1269                  reportError(ex);
1270 <                consume();
1291 <                consumeUntil(_tokenSet_14);
1270 >                recover(ex,_tokenSet_14);
1271          }
1272          returnAST = fragmentstatement_AST;
1273   }
# Line 1325 | Line 1304 | void MDParser::doubleNumber() {
1304          }
1305          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1306                  reportError(ex);
1307 <                consume();
1329 <                consumeUntil(_tokenSet_15);
1307 >                recover(ex,_tokenSet_15);
1308          }
1309          returnAST = doubleNumber_AST;
1310   }
# Line 1401 | Line 1379 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_toke
1379   const unsigned long MDParser::_tokenSet_2_data_[] = { 1048690UL, 0UL, 0UL, 0UL };
1380   // EOF "component" "molecule" "zconstraint" ID
1381   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1382 < const unsigned long MDParser::_tokenSet_3_data_[] = { 35125234UL, 0UL, 0UL, 0UL };
1382 > const unsigned long MDParser::_tokenSet_3_data_[] = { 35127282UL, 0UL, 0UL, 0UL };
1383   // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion"
1384 < // "rigidBody" "cutoffGroup" "fragment" "members" "center" "position" "orientation"
1385 < // ID RCURLY
1384 > // "inversion" "rigidBody" "cutoffGroup" "fragment" "members" "center"
1385 > // "position" "orientation" ID RCURLY
1386   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1387 < const unsigned long MDParser::_tokenSet_4_data_[] = { 1079168UL, 0UL, 0UL, 0UL };
1388 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1389 < // ID
1387 > const unsigned long MDParser::_tokenSet_4_data_[] = { 1081216UL, 0UL, 0UL, 0UL };
1388 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1389 > // "fragment" ID
1390   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1391   const unsigned long MDParser::_tokenSet_5_data_[] = { 4194304UL, 0UL, 0UL, 0UL };
1392   // SEMICOLON
# Line 1419 | Line 1397 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_toke
1397   const unsigned long MDParser::_tokenSet_7_data_[] = { 1614807040UL, 0UL, 0UL, 0UL };
1398   // SEMICOLON RPAREN COMMA
1399   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1400 < const unsigned long MDParser::_tokenSet_8_data_[] = { 34633600UL, 0UL, 0UL, 0UL };
1401 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1402 < // ID RCURLY
1400 > const unsigned long MDParser::_tokenSet_8_data_[] = { 34635648UL, 0UL, 0UL, 0UL };
1401 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1402 > // "fragment" ID RCURLY
1403   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1404   const unsigned long MDParser::_tokenSet_9_data_[] = { 1441792UL, 0UL, 0UL, 0UL };
1405   // "position" "orientation" ID

Diff Legend

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