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

Comparing branches/development/src/mdParser/MDParser.cpp (file contents):
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC vs.
Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

# Line 114 | Line 114 | void MDParser::statement() {
114                          statement_AST = currentAST.root;
115                          break;
116                  }
117 +                case MINIMIZER:
118 +                {
119 +                        minimizerblock();
120 +                        astFactory->addASTChild( currentAST, returnAST );
121 +                        statement_AST = currentAST.root;
122 +                        break;
123 +                }
124                  default:
125                  {
126                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 181 | Line 188 | void MDParser::componentblock() {
188                  tmp6_AST = astFactory->create(LT(1));
189                  astFactory->addASTChild(currentAST, tmp6_AST);
190                  match(RCURLY);
191 < #line 71 "MDParser.g"
191 > #line 73 "MDParser.g"
192                  tmp6_AST->setType(ENDBLOCK);
193 < #line 187 "MDParser.cpp"
193 > #line 194 "MDParser.cpp"
194                  componentblock_AST = currentAST.root;
195          }
196          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 211 | Line 218 | void MDParser::moleculeblock() {
218                                  astFactory->addASTChild( currentAST, returnAST );
219                          }
220                          else {
221 <                                goto _loop24;
221 >                                goto _loop27;
222                          }
223                          
224                  }
225 <                _loop24:;
225 >                _loop27:;
226                  } // ( ... )*
227                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
228                  tmp9_AST = astFactory->create(LT(1));
229                  astFactory->addASTChild(currentAST, tmp9_AST);
230                  match(RCURLY);
231 < #line 86 "MDParser.g"
231 > #line 91 "MDParser.g"
232                  tmp9_AST->setType(ENDBLOCK);
233 < #line 227 "MDParser.cpp"
233 > #line 234 "MDParser.cpp"
234                  moleculeblock_AST = currentAST.root;
235          }
236          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 261 | Line 268 | void MDParser::zconstraintblock() {
268                  tmp12_AST = astFactory->create(LT(1));
269                  astFactory->addASTChild(currentAST, tmp12_AST);
270                  match(RCURLY);
271 < #line 74 "MDParser.g"
271 > #line 76 "MDParser.g"
272                  tmp12_AST->setType(ENDBLOCK);
273 < #line 267 "MDParser.cpp"
273 > #line 274 "MDParser.cpp"
274                  zconstraintblock_AST = currentAST.root;
275          }
276          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 301 | Line 308 | void MDParser::restraintblock() {
308                  tmp15_AST = astFactory->create(LT(1));
309                  astFactory->addASTChild(currentAST, tmp15_AST);
310                  match(RCURLY);
311 < #line 77 "MDParser.g"
311 > #line 79 "MDParser.g"
312                  tmp15_AST->setType(ENDBLOCK);
313 < #line 307 "MDParser.cpp"
313 > #line 314 "MDParser.cpp"
314                  restraintblock_AST = currentAST.root;
315          }
316          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 341 | Line 348 | void MDParser::flucqblock() {
348                  tmp18_AST = astFactory->create(LT(1));
349                  astFactory->addASTChild(currentAST, tmp18_AST);
350                  match(RCURLY);
351 < #line 80 "MDParser.g"
351 > #line 82 "MDParser.g"
352                  tmp18_AST->setType(ENDBLOCK);
353 < #line 347 "MDParser.cpp"
353 > #line 354 "MDParser.cpp"
354                  flucqblock_AST = currentAST.root;
355          }
356          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 381 | Line 388 | void MDParser::rnemdblock() {
388                  tmp21_AST = astFactory->create(LT(1));
389                  astFactory->addASTChild(currentAST, tmp21_AST);
390                  match(RCURLY);
391 < #line 83 "MDParser.g"
391 > #line 85 "MDParser.g"
392                  tmp21_AST->setType(ENDBLOCK);
393 < #line 387 "MDParser.cpp"
393 > #line 394 "MDParser.cpp"
394                  rnemdblock_AST = currentAST.root;
395          }
396          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 393 | Line 400 | void MDParser::rnemdblock() {
400          returnAST = rnemdblock_AST;
401   }
402  
403 + void MDParser::minimizerblock() {
404 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
405 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
406 +        ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
407 +        
408 +        try {      // for error handling
409 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
410 +                tmp22_AST = astFactory->create(LT(1));
411 +                astFactory->makeASTRoot(currentAST, tmp22_AST);
412 +                match(MINIMIZER);
413 +                match(LCURLY);
414 +                { // ( ... )*
415 +                for (;;) {
416 +                        if ((LA(1) == ID)) {
417 +                                assignment();
418 +                                astFactory->addASTChild( currentAST, returnAST );
419 +                        }
420 +                        else {
421 +                                goto _loop24;
422 +                        }
423 +                        
424 +                }
425 +                _loop24:;
426 +                } // ( ... )*
427 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
428 +                tmp24_AST = astFactory->create(LT(1));
429 +                astFactory->addASTChild(currentAST, tmp24_AST);
430 +                match(RCURLY);
431 + #line 88 "MDParser.g"
432 +                tmp24_AST->setType(ENDBLOCK);
433 + #line 434 "MDParser.cpp"
434 +                minimizerblock_AST = currentAST.root;
435 +        }
436 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
437 +                reportError(ex);
438 +                recover(ex,_tokenSet_2);
439 +        }
440 +        returnAST = minimizerblock_AST;
441 + }
442 +
443   void MDParser::constant() {
444          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
445          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 418 | Line 465 | void MDParser::constant() {
465                  }
466                  case ID:
467                  {
468 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
469 <                        tmp22_AST = astFactory->create(LT(1));
470 <                        astFactory->addASTChild(currentAST, tmp22_AST);
468 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
469 >                        tmp25_AST = astFactory->create(LT(1));
470 >                        astFactory->addASTChild(currentAST, tmp25_AST);
471                          match(ID);
472                          constant_AST = currentAST.root;
473                          break;
474                  }
475                  case StringLiteral:
476                  {
477 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
478 <                        tmp23_AST = astFactory->create(LT(1));
479 <                        astFactory->addASTChild(currentAST, tmp23_AST);
477 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
478 >                        tmp26_AST = astFactory->create(LT(1));
479 >                        astFactory->addASTChild(currentAST, tmp26_AST);
480                          match(StringLiteral);
481                          constant_AST = currentAST.root;
482                          break;
# Line 456 | Line 503 | void MDParser::intConst() {
503                  switch ( LA(1)) {
504                  case NUM_INT:
505                  {
506 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507 <                        tmp24_AST = astFactory->create(LT(1));
508 <                        astFactory->addASTChild(currentAST, tmp24_AST);
506 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507 >                        tmp27_AST = astFactory->create(LT(1));
508 >                        astFactory->addASTChild(currentAST, tmp27_AST);
509                          match(NUM_INT);
510                          intConst_AST = currentAST.root;
511                          break;
512                  }
513                  case NUM_LONG:
514                  {
515 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
516 <                        tmp25_AST = astFactory->create(LT(1));
517 <                        astFactory->addASTChild(currentAST, tmp25_AST);
515 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
516 >                        tmp28_AST = astFactory->create(LT(1));
517 >                        astFactory->addASTChild(currentAST, tmp28_AST);
518                          match(NUM_LONG);
519                          intConst_AST = currentAST.root;
520                          break;
# Line 494 | Line 541 | void MDParser::floatConst() {
541                  switch ( LA(1)) {
542                  case NUM_FLOAT:
543                  {
544 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
545 <                        tmp26_AST = astFactory->create(LT(1));
546 <                        astFactory->addASTChild(currentAST, tmp26_AST);
544 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
545 >                        tmp29_AST = astFactory->create(LT(1));
546 >                        astFactory->addASTChild(currentAST, tmp29_AST);
547                          match(NUM_FLOAT);
548                          floatConst_AST = currentAST.root;
549                          break;
550                  }
551                  case NUM_DOUBLE:
552                  {
553 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
554 <                        tmp27_AST = astFactory->create(LT(1));
555 <                        astFactory->addASTChild(currentAST, tmp27_AST);
553 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
554 >                        tmp30_AST = astFactory->create(LT(1));
555 >                        astFactory->addASTChild(currentAST, tmp30_AST);
556                          match(NUM_DOUBLE);
557                          floatConst_AST = currentAST.root;
558                          break;
# Line 612 | Line 659 | void MDParser::atomblock() {
659          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
660          
661          try {      // for error handling
662 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
663 <                tmp28_AST = astFactory->create(LT(1));
664 <                astFactory->makeASTRoot(currentAST, tmp28_AST);
662 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
663 >                tmp31_AST = astFactory->create(LT(1));
664 >                astFactory->makeASTRoot(currentAST, tmp31_AST);
665                  match(ATOM);
666                  match(LBRACKET);
667                  intConst();
# Line 628 | Line 675 | void MDParser::atomblock() {
675                                  astFactory->addASTChild( currentAST, returnAST );
676                          }
677                          else {
678 <                                goto _loop28;
678 >                                goto _loop31;
679                          }
680                          
681                  }
682 <                _loop28:;
682 >                _loop31:;
683                  } // ( ... )*
684 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
685 <                tmp32_AST = astFactory->create(LT(1));
686 <                astFactory->addASTChild(currentAST, tmp32_AST);
684 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
685 >                tmp35_AST = astFactory->create(LT(1));
686 >                astFactory->addASTChild(currentAST, tmp35_AST);
687                  match(RCURLY);
688 < #line 100 "MDParser.g"
689 <                tmp32_AST->setType(ENDBLOCK);
690 < #line 644 "MDParser.cpp"
688 > #line 105 "MDParser.g"
689 >                tmp35_AST->setType(ENDBLOCK);
690 > #line 691 "MDParser.cpp"
691                  atomblock_AST = currentAST.root;
692          }
693          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 656 | Line 703 | void MDParser::bondblock() {
703          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
704          
705          try {      // for error handling
706 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 <                tmp33_AST = astFactory->create(LT(1));
708 <                astFactory->makeASTRoot(currentAST, tmp33_AST);
706 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 >                tmp36_AST = astFactory->create(LT(1));
708 >                astFactory->makeASTRoot(currentAST, tmp36_AST);
709                  match(BOND);
710                  {
711                  switch ( LA(1)) {
# Line 687 | Line 734 | void MDParser::bondblock() {
734                                  astFactory->addASTChild( currentAST, returnAST );
735                          }
736                          else {
737 <                                goto _loop33;
737 >                                goto _loop36;
738                          }
739                          
740                  }
741 <                _loop33:;
741 >                _loop36:;
742                  } // ( ... )*
743 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
744 <                tmp37_AST = astFactory->create(LT(1));
745 <                astFactory->addASTChild(currentAST, tmp37_AST);
743 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
744 >                tmp40_AST = astFactory->create(LT(1));
745 >                astFactory->addASTChild(currentAST, tmp40_AST);
746                  match(RCURLY);
747 < #line 109 "MDParser.g"
748 <                tmp37_AST->setType(ENDBLOCK);
749 < #line 703 "MDParser.cpp"
747 > #line 114 "MDParser.g"
748 >                tmp40_AST->setType(ENDBLOCK);
749 > #line 750 "MDParser.cpp"
750                  bondblock_AST = currentAST.root;
751          }
752          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 715 | Line 762 | void MDParser::bendblock() {
762          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
763          
764          try {      // for error handling
765 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
766 <                tmp38_AST = astFactory->create(LT(1));
767 <                astFactory->makeASTRoot(currentAST, tmp38_AST);
765 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
766 >                tmp41_AST = astFactory->create(LT(1));
767 >                astFactory->makeASTRoot(currentAST, tmp41_AST);
768                  match(BEND);
769                  {
770                  switch ( LA(1)) {
# Line 746 | Line 793 | void MDParser::bendblock() {
793                                  astFactory->addASTChild( currentAST, returnAST );
794                          }
795                          else {
796 <                                goto _loop38;
796 >                                goto _loop41;
797                          }
798                          
799                  }
800 <                _loop38:;
800 >                _loop41:;
801                  } // ( ... )*
802 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
803 <                tmp42_AST = astFactory->create(LT(1));
804 <                astFactory->addASTChild(currentAST, tmp42_AST);
802 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
803 >                tmp45_AST = astFactory->create(LT(1));
804 >                astFactory->addASTChild(currentAST, tmp45_AST);
805                  match(RCURLY);
806 < #line 116 "MDParser.g"
807 <                tmp42_AST->setType(ENDBLOCK);
808 < #line 762 "MDParser.cpp"
806 > #line 121 "MDParser.g"
807 >                tmp45_AST->setType(ENDBLOCK);
808 > #line 809 "MDParser.cpp"
809                  bendblock_AST = currentAST.root;
810          }
811          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 774 | Line 821 | void MDParser::torsionblock() {
821          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
822          
823          try {      // for error handling
824 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
825 <                tmp43_AST = astFactory->create(LT(1));
826 <                astFactory->makeASTRoot(currentAST, tmp43_AST);
824 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
825 >                tmp46_AST = astFactory->create(LT(1));
826 >                astFactory->makeASTRoot(currentAST, tmp46_AST);
827                  match(TORSION);
828                  {
829                  switch ( LA(1)) {
# Line 805 | Line 852 | void MDParser::torsionblock() {
852                                  astFactory->addASTChild( currentAST, returnAST );
853                          }
854                          else {
855 <                                goto _loop43;
855 >                                goto _loop46;
856                          }
857                          
858                  }
859 <                _loop43:;
859 >                _loop46:;
860                  } // ( ... )*
861 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
862 <                tmp47_AST = astFactory->create(LT(1));
863 <                astFactory->addASTChild(currentAST, tmp47_AST);
861 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
862 >                tmp50_AST = astFactory->create(LT(1));
863 >                astFactory->addASTChild(currentAST, tmp50_AST);
864                  match(RCURLY);
865 < #line 123 "MDParser.g"
866 <                tmp47_AST->setType(ENDBLOCK);
867 < #line 821 "MDParser.cpp"
865 > #line 128 "MDParser.g"
866 >                tmp50_AST->setType(ENDBLOCK);
867 > #line 868 "MDParser.cpp"
868                  torsionblock_AST = currentAST.root;
869          }
870          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 833 | Line 880 | void MDParser::inversionblock() {
880          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
881          
882          try {      // for error handling
883 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
884 <                tmp48_AST = astFactory->create(LT(1));
885 <                astFactory->makeASTRoot(currentAST, tmp48_AST);
883 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
884 >                tmp51_AST = astFactory->create(LT(1));
885 >                astFactory->makeASTRoot(currentAST, tmp51_AST);
886                  match(INVERSION);
887                  {
888                  switch ( LA(1)) {
# Line 864 | Line 911 | void MDParser::inversionblock() {
911                                  astFactory->addASTChild( currentAST, returnAST );
912                          }
913                          else {
914 <                                goto _loop48;
914 >                                goto _loop51;
915                          }
916                          
917                  }
918 <                _loop48:;
918 >                _loop51:;
919                  } // ( ... )*
920 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
921 <                tmp52_AST = astFactory->create(LT(1));
922 <                astFactory->addASTChild(currentAST, tmp52_AST);
920 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
921 >                tmp55_AST = astFactory->create(LT(1));
922 >                astFactory->addASTChild(currentAST, tmp55_AST);
923                  match(RCURLY);
924 < #line 130 "MDParser.g"
925 <                tmp52_AST->setType(ENDBLOCK);
926 < #line 880 "MDParser.cpp"
924 > #line 135 "MDParser.g"
925 >                tmp55_AST->setType(ENDBLOCK);
926 > #line 927 "MDParser.cpp"
927                  inversionblock_AST = currentAST.root;
928          }
929          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 892 | Line 939 | void MDParser::rigidbodyblock() {
939          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
940          
941          try {      // for error handling
942 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
943 <                tmp53_AST = astFactory->create(LT(1));
944 <                astFactory->makeASTRoot(currentAST, tmp53_AST);
942 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
943 >                tmp56_AST = astFactory->create(LT(1));
944 >                astFactory->makeASTRoot(currentAST, tmp56_AST);
945                  match(RIGIDBODY);
946                  match(LBRACKET);
947                  intConst();
# Line 908 | Line 955 | void MDParser::rigidbodyblock() {
955                                  astFactory->addASTChild( currentAST, returnAST );
956                          }
957                          else {
958 <                                goto _loop52;
958 >                                goto _loop55;
959                          }
960                          
961                  }
962 <                _loop52:;
962 >                _loop55:;
963                  } // ( ... )*
964 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 <                tmp57_AST = astFactory->create(LT(1));
966 <                astFactory->addASTChild(currentAST, tmp57_AST);
964 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 >                tmp60_AST = astFactory->create(LT(1));
966 >                astFactory->addASTChild(currentAST, tmp60_AST);
967                  match(RCURLY);
968 < #line 137 "MDParser.g"
969 <                tmp57_AST->setType(ENDBLOCK);
970 < #line 924 "MDParser.cpp"
968 > #line 142 "MDParser.g"
969 >                tmp60_AST->setType(ENDBLOCK);
970 > #line 971 "MDParser.cpp"
971                  rigidbodyblock_AST = currentAST.root;
972          }
973          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 936 | Line 983 | void MDParser::cutoffgroupblock() {
983          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
984          
985          try {      // for error handling
986 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 <                tmp58_AST = astFactory->create(LT(1));
988 <                astFactory->makeASTRoot(currentAST, tmp58_AST);
986 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 >                tmp61_AST = astFactory->create(LT(1));
988 >                astFactory->makeASTRoot(currentAST, tmp61_AST);
989                  match(CUTOFFGROUP);
990                  {
991                  switch ( LA(1)) {
# Line 967 | Line 1014 | void MDParser::cutoffgroupblock() {
1014                                  astFactory->addASTChild( currentAST, returnAST );
1015                          }
1016                          else {
1017 <                                goto _loop57;
1017 >                                goto _loop60;
1018                          }
1019                          
1020                  }
1021 <                _loop57:;
1021 >                _loop60:;
1022                  } // ( ... )*
1023 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024 <                tmp62_AST = astFactory->create(LT(1));
1025 <                astFactory->addASTChild(currentAST, tmp62_AST);
1023 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024 >                tmp65_AST = astFactory->create(LT(1));
1025 >                astFactory->addASTChild(currentAST, tmp65_AST);
1026                  match(RCURLY);
1027 < #line 144 "MDParser.g"
1028 <                tmp62_AST->setType(ENDBLOCK);
1029 < #line 983 "MDParser.cpp"
1027 > #line 149 "MDParser.g"
1028 >                tmp65_AST->setType(ENDBLOCK);
1029 > #line 1030 "MDParser.cpp"
1030                  cutoffgroupblock_AST = currentAST.root;
1031          }
1032          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 995 | Line 1042 | void MDParser::fragmentblock() {
1042          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1043          
1044          try {      // for error handling
1045 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1046 <                tmp63_AST = astFactory->create(LT(1));
1047 <                astFactory->makeASTRoot(currentAST, tmp63_AST);
1045 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1046 >                tmp66_AST = astFactory->create(LT(1));
1047 >                astFactory->makeASTRoot(currentAST, tmp66_AST);
1048                  match(FRAGMENT);
1049                  match(LBRACKET);
1050                  intConst();
# Line 1011 | Line 1058 | void MDParser::fragmentblock() {
1058                                  astFactory->addASTChild( currentAST, returnAST );
1059                          }
1060                          else {
1061 <                                goto _loop61;
1061 >                                goto _loop64;
1062                          }
1063                          
1064                  }
1065 <                _loop61:;
1065 >                _loop64:;
1066                  } // ( ... )*
1067 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 <                tmp67_AST = astFactory->create(LT(1));
1069 <                astFactory->addASTChild(currentAST, tmp67_AST);
1067 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 >                tmp70_AST = astFactory->create(LT(1));
1069 >                astFactory->addASTChild(currentAST, tmp70_AST);
1070                  match(RCURLY);
1071 < #line 151 "MDParser.g"
1072 <                tmp67_AST->setType(ENDBLOCK);
1073 < #line 1027 "MDParser.cpp"
1071 > #line 156 "MDParser.g"
1072 >                tmp70_AST->setType(ENDBLOCK);
1073 > #line 1074 "MDParser.cpp"
1074                  fragmentblock_AST = currentAST.root;
1075          }
1076          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1049 | Line 1096 | void MDParser::atomstatement() {
1096                  }
1097                  case POSITION:
1098                  {
1099 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1100 <                        tmp68_AST = astFactory->create(LT(1));
1101 <                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1099 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1100 >                        tmp71_AST = astFactory->create(LT(1));
1101 >                        astFactory->makeASTRoot(currentAST, tmp71_AST);
1102                          match(POSITION);
1103                          match(LPAREN);
1104                          doubleNumberTuple();
# Line 1063 | Line 1110 | void MDParser::atomstatement() {
1110                  }
1111                  case ORIENTATION:
1112                  {
1113 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1114 <                        tmp72_AST = astFactory->create(LT(1));
1115 <                        astFactory->makeASTRoot(currentAST, tmp72_AST);
1113 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1114 >                        tmp75_AST = astFactory->create(LT(1));
1115 >                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1116                          match(ORIENTATION);
1117                          match(LPAREN);
1118                          doubleNumberTuple();
# Line 1104 | Line 1151 | void MDParser::doubleNumberTuple() {
1151                                  astFactory->addASTChild( currentAST, returnAST );
1152                          }
1153                          else {
1154 <                                goto _loop65;
1154 >                                goto _loop68;
1155                          }
1156                          
1157                  }
1158 <                _loop65:;
1158 >                _loop68:;
1159                  } // ( ... )*
1160                  doubleNumberTuple_AST = currentAST.root;
1161          }
# Line 1135 | Line 1182 | void MDParser::bondstatement() {
1182                  }
1183                  case MEMBERS:
1184                  {
1185 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1186 <                        tmp77_AST = astFactory->create(LT(1));
1187 <                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1185 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1186 >                        tmp80_AST = astFactory->create(LT(1));
1187 >                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1188                          match(MEMBERS);
1189                          match(LPAREN);
1190                          inttuple();
# Line 1176 | Line 1223 | void MDParser::inttuple() {
1223                                  astFactory->addASTChild( currentAST, returnAST );
1224                          }
1225                          else {
1226 <                                goto _loop68;
1226 >                                goto _loop71;
1227                          }
1228                          
1229                  }
1230 <                _loop68:;
1230 >                _loop71:;
1231                  } // ( ... )*
1232                  inttuple_AST = currentAST.root;
1233          }
# Line 1207 | Line 1254 | void MDParser::bendstatement() {
1254                  }
1255                  case MEMBERS:
1256                  {
1257 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1258 <                        tmp82_AST = astFactory->create(LT(1));
1259 <                        astFactory->makeASTRoot(currentAST, tmp82_AST);
1257 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1258 >                        tmp85_AST = astFactory->create(LT(1));
1259 >                        astFactory->makeASTRoot(currentAST, tmp85_AST);
1260                          match(MEMBERS);
1261                          match(LPAREN);
1262                          inttuple();
# Line 1248 | Line 1295 | void MDParser::torsionstatement() {
1295                  }
1296                  case MEMBERS:
1297                  {
1298 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1299 <                        tmp86_AST = astFactory->create(LT(1));
1300 <                        astFactory->makeASTRoot(currentAST, tmp86_AST);
1298 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1299 >                        tmp89_AST = astFactory->create(LT(1));
1300 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1301                          match(MEMBERS);
1302                          match(LPAREN);
1303                          inttuple();
# Line 1289 | Line 1336 | void MDParser::inversionstatement() {
1336                  }
1337                  case CENTER:
1338                  {
1339 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1340 <                        tmp90_AST = astFactory->create(LT(1));
1341 <                        astFactory->makeASTRoot(currentAST, tmp90_AST);
1339 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1340 >                        tmp93_AST = astFactory->create(LT(1));
1341 >                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1342                          match(CENTER);
1343                          match(LPAREN);
1344                          intConst();
# Line 1330 | Line 1377 | void MDParser::rigidbodystatement() {
1377                  }
1378                  case MEMBERS:
1379                  {
1380 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1381 <                        tmp94_AST = astFactory->create(LT(1));
1382 <                        astFactory->makeASTRoot(currentAST, tmp94_AST);
1380 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1381 >                        tmp97_AST = astFactory->create(LT(1));
1382 >                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1383                          match(MEMBERS);
1384                          match(LPAREN);
1385                          inttuple();
# Line 1371 | Line 1418 | void MDParser::cutoffgroupstatement() {
1418                  }
1419                  case MEMBERS:
1420                  {
1421 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1422 <                        tmp98_AST = astFactory->create(LT(1));
1423 <                        astFactory->makeASTRoot(currentAST, tmp98_AST);
1421 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1422 >                        tmp101_AST = astFactory->create(LT(1));
1423 >                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1424                          match(MEMBERS);
1425                          match(LPAREN);
1426                          inttuple();
# Line 1452 | Line 1499 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPA
1499  
1500   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1501   {
1502 <        factory.setMaxNodeType(55);
1502 >        factory.setMaxNodeType(56);
1503   }
1504   const char* MDParser::tokenNames[] = {
1505          "<0>",
# Line 1477 | Line 1524 | const char* MDParser::tokenNames[] = {
1524          "\"orientation\"",
1525          "\"flucQ\"",
1526          "\"RNEMD\"",
1527 +        "\"minimizer\"",
1528          "ENDBLOCK",
1529          "ID",
1530          "ASSIGNEQUAL",
# Line 1514 | Line 1562 | const char* MDParser::tokenNames[] = {
1562          0
1563   };
1564  
1565 < const unsigned long MDParser::_tokenSet_0_data_[] = { 11534576UL, 0UL, 0UL, 0UL };
1566 < // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ID
1565 > const unsigned long MDParser::_tokenSet_0_data_[] = { 24117488UL, 0UL, 0UL, 0UL };
1566 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1567 > // ID
1568   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1569   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1570   // EOF
1571   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1572 < const unsigned long MDParser::_tokenSet_2_data_[] = { 11534578UL, 0UL, 0UL, 0UL };
1572 > const unsigned long MDParser::_tokenSet_2_data_[] = { 24117490UL, 0UL, 0UL, 0UL };
1573   // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1574 < // ID
1574 > // "minimizer" ID
1575   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1576 < const unsigned long MDParser::_tokenSet_3_data_[] = { 281018354UL, 0UL, 0UL, 0UL };
1576 > const unsigned long MDParser::_tokenSet_3_data_[] = { 562036722UL, 0UL, 0UL, 0UL };
1577   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1578   // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1579 < // "center" "position" "orientation" "flucQ" "RNEMD" ID RCURLY
1579 > // "center" "position" "orientation" "flucQ" "RNEMD" "minimizer" ID RCURLY
1580   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1581 < const unsigned long MDParser::_tokenSet_4_data_[] = { 8453888UL, 0UL, 0UL, 0UL };
1581 > const unsigned long MDParser::_tokenSet_4_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1582   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1583   // "fragment" ID
1584   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1585 < const unsigned long MDParser::_tokenSet_5_data_[] = { 33554432UL, 0UL, 0UL, 0UL };
1585 > const unsigned long MDParser::_tokenSet_5_data_[] = { 67108864UL, 0UL, 0UL, 0UL };
1586   // SEMICOLON
1587   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1588 < const unsigned long MDParser::_tokenSet_6_data_[] = { 1107296256UL, 3UL, 0UL, 0UL };
1588 > const unsigned long MDParser::_tokenSet_6_data_[] = { 2214592512UL, 6UL, 0UL, 0UL };
1589   // SEMICOLON RBRACKET RPAREN COMMA
1590   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1591 < const unsigned long MDParser::_tokenSet_7_data_[] = { 33554432UL, 3UL, 0UL, 0UL };
1591 > const unsigned long MDParser::_tokenSet_7_data_[] = { 67108864UL, 6UL, 0UL, 0UL };
1592   // SEMICOLON RPAREN COMMA
1593   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1594 < const unsigned long MDParser::_tokenSet_8_data_[] = { 276889344UL, 0UL, 0UL, 0UL };
1594 > const unsigned long MDParser::_tokenSet_8_data_[] = { 553713408UL, 0UL, 0UL, 0UL };
1595   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1596   // "fragment" ID RCURLY
1597   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1598 < const unsigned long MDParser::_tokenSet_9_data_[] = { 9175040UL, 0UL, 0UL, 0UL };
1598 > const unsigned long MDParser::_tokenSet_9_data_[] = { 17563648UL, 0UL, 0UL, 0UL };
1599   // "position" "orientation" ID
1600   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1601 < const unsigned long MDParser::_tokenSet_10_data_[] = { 277610496UL, 0UL, 0UL, 0UL };
1601 > const unsigned long MDParser::_tokenSet_10_data_[] = { 554434560UL, 0UL, 0UL, 0UL };
1602   // "position" "orientation" ID RCURLY
1603   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1604 < const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 1UL, 0UL, 0UL };
1604 > const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 2UL, 0UL, 0UL };
1605   // RPAREN
1606   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1607 < const unsigned long MDParser::_tokenSet_12_data_[] = { 276889600UL, 0UL, 0UL, 0UL };
1607 > const unsigned long MDParser::_tokenSet_12_data_[] = { 553713664UL, 0UL, 0UL, 0UL };
1608   // "members" ID RCURLY
1609   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1610 < const unsigned long MDParser::_tokenSet_13_data_[] = { 276955136UL, 0UL, 0UL, 0UL };
1610 > const unsigned long MDParser::_tokenSet_13_data_[] = { 553779200UL, 0UL, 0UL, 0UL };
1611   // "center" ID RCURLY
1612   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1613 < const unsigned long MDParser::_tokenSet_14_data_[] = { 276824064UL, 0UL, 0UL, 0UL };
1613 > const unsigned long MDParser::_tokenSet_14_data_[] = { 553648128UL, 0UL, 0UL, 0UL };
1614   // ID RCURLY
1615   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1616 < const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 3UL, 0UL, 0UL };
1616 > const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 6UL, 0UL, 0UL };
1617   // RPAREN COMMA
1618   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1619  

Diff Legend

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