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 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20110725): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20120725): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# 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 74 "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 92 "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 77 "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 80 "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 83 "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 86 "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 391 | Line 398 | void MDParser::rnemdblock() {
398                  recover(ex,_tokenSet_2);
399          }
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 89 "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() {
# Line 416 | Line 463 | void MDParser::constant() {
463                          constant_AST = currentAST.root;
464                          break;
465                  }
466 +                case LPAREN:
467 +                {
468 +                        vectorConst();
469 +                        astFactory->addASTChild( currentAST, returnAST );
470 +                        constant_AST = currentAST.root;
471 +                        break;
472 +                }
473                  case ID:
474                  {
475 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
476 <                        tmp22_AST = astFactory->create(LT(1));
477 <                        astFactory->addASTChild(currentAST, tmp22_AST);
475 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
476 >                        tmp25_AST = astFactory->create(LT(1));
477 >                        astFactory->addASTChild(currentAST, tmp25_AST);
478                          match(ID);
479                          constant_AST = currentAST.root;
480                          break;
481                  }
482                  case StringLiteral:
483                  {
484 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
485 <                        tmp23_AST = astFactory->create(LT(1));
486 <                        astFactory->addASTChild(currentAST, tmp23_AST);
484 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
485 >                        tmp26_AST = astFactory->create(LT(1));
486 >                        astFactory->addASTChild(currentAST, tmp26_AST);
487                          match(StringLiteral);
488                          constant_AST = currentAST.root;
489                          break;
# Line 456 | Line 510 | void MDParser::intConst() {
510                  switch ( LA(1)) {
511                  case NUM_INT:
512                  {
513 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514 <                        tmp24_AST = astFactory->create(LT(1));
515 <                        astFactory->addASTChild(currentAST, tmp24_AST);
513 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514 >                        tmp27_AST = astFactory->create(LT(1));
515 >                        astFactory->addASTChild(currentAST, tmp27_AST);
516                          match(NUM_INT);
517                          intConst_AST = currentAST.root;
518                          break;
519                  }
520                  case NUM_LONG:
521                  {
522 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 <                        tmp25_AST = astFactory->create(LT(1));
524 <                        astFactory->addASTChild(currentAST, tmp25_AST);
522 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 >                        tmp28_AST = astFactory->create(LT(1));
524 >                        astFactory->addASTChild(currentAST, tmp28_AST);
525                          match(NUM_LONG);
526                          intConst_AST = currentAST.root;
527                          break;
# Line 494 | Line 548 | void MDParser::floatConst() {
548                  switch ( LA(1)) {
549                  case NUM_FLOAT:
550                  {
551 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
552 <                        tmp26_AST = astFactory->create(LT(1));
553 <                        astFactory->addASTChild(currentAST, tmp26_AST);
551 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
552 >                        tmp29_AST = astFactory->create(LT(1));
553 >                        astFactory->addASTChild(currentAST, tmp29_AST);
554                          match(NUM_FLOAT);
555                          floatConst_AST = currentAST.root;
556                          break;
557                  }
558                  case NUM_DOUBLE:
559                  {
560 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 <                        tmp27_AST = astFactory->create(LT(1));
562 <                        astFactory->addASTChild(currentAST, tmp27_AST);
560 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 >                        tmp30_AST = astFactory->create(LT(1));
562 >                        astFactory->addASTChild(currentAST, tmp30_AST);
563                          match(NUM_DOUBLE);
564                          floatConst_AST = currentAST.root;
565                          break;
# Line 523 | Line 577 | void MDParser::floatConst() {
577          returnAST = floatConst_AST;
578   }
579  
580 + void MDParser::vectorConst() {
581 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
582 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
583 +        ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
584 +        
585 +        try {      // for error handling
586 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
587 +                tmp31_AST = astFactory->create(LT(1));
588 +                astFactory->makeASTRoot(currentAST, tmp31_AST);
589 +                match(LPAREN);
590 +                doubleNumber();
591 +                astFactory->addASTChild( currentAST, returnAST );
592 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
593 +                tmp32_AST = astFactory->create(LT(1));
594 +                astFactory->addASTChild(currentAST, tmp32_AST);
595 +                match(COMMA);
596 +                doubleNumber();
597 +                astFactory->addASTChild( currentAST, returnAST );
598 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 +                tmp33_AST = astFactory->create(LT(1));
600 +                astFactory->addASTChild(currentAST, tmp33_AST);
601 +                match(COMMA);
602 +                doubleNumber();
603 +                astFactory->addASTChild( currentAST, returnAST );
604 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
605 +                tmp34_AST = astFactory->create(LT(1));
606 +                astFactory->addASTChild(currentAST, tmp34_AST);
607 +                match(RPAREN);
608 +                vectorConst_AST = currentAST.root;
609 +        }
610 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
611 +                reportError(ex);
612 +                recover(ex,_tokenSet_5);
613 +        }
614 +        returnAST = vectorConst_AST;
615 + }
616 +
617   void MDParser::moleculestatement() {
618          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
619          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 612 | Line 703 | void MDParser::atomblock() {
703          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
704          
705          try {      // for error handling
706 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 <                tmp28_AST = astFactory->create(LT(1));
708 <                astFactory->makeASTRoot(currentAST, tmp28_AST);
706 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 >                tmp35_AST = astFactory->create(LT(1));
708 >                astFactory->makeASTRoot(currentAST, tmp35_AST);
709                  match(ATOM);
710                  match(LBRACKET);
711                  intConst();
# Line 628 | Line 719 | void MDParser::atomblock() {
719                                  astFactory->addASTChild( currentAST, returnAST );
720                          }
721                          else {
722 <                                goto _loop28;
722 >                                goto _loop31;
723                          }
724                          
725                  }
726 <                _loop28:;
726 >                _loop31:;
727                  } // ( ... )*
728 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 <                tmp32_AST = astFactory->create(LT(1));
730 <                astFactory->addASTChild(currentAST, tmp32_AST);
728 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 >                tmp39_AST = astFactory->create(LT(1));
730 >                astFactory->addASTChild(currentAST, tmp39_AST);
731                  match(RCURLY);
732 < #line 100 "MDParser.g"
733 <                tmp32_AST->setType(ENDBLOCK);
734 < #line 644 "MDParser.cpp"
732 > #line 106 "MDParser.g"
733 >                tmp39_AST->setType(ENDBLOCK);
734 > #line 735 "MDParser.cpp"
735                  atomblock_AST = currentAST.root;
736          }
737          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 656 | Line 747 | void MDParser::bondblock() {
747          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
748          
749          try {      // for error handling
750 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 <                tmp33_AST = astFactory->create(LT(1));
752 <                astFactory->makeASTRoot(currentAST, tmp33_AST);
750 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 >                tmp40_AST = astFactory->create(LT(1));
752 >                astFactory->makeASTRoot(currentAST, tmp40_AST);
753                  match(BOND);
754                  {
755                  switch ( LA(1)) {
# Line 687 | Line 778 | void MDParser::bondblock() {
778                                  astFactory->addASTChild( currentAST, returnAST );
779                          }
780                          else {
781 <                                goto _loop33;
781 >                                goto _loop36;
782                          }
783                          
784                  }
785 <                _loop33:;
785 >                _loop36:;
786                  } // ( ... )*
787 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 <                tmp37_AST = astFactory->create(LT(1));
789 <                astFactory->addASTChild(currentAST, tmp37_AST);
787 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 >                tmp44_AST = astFactory->create(LT(1));
789 >                astFactory->addASTChild(currentAST, tmp44_AST);
790                  match(RCURLY);
791 < #line 109 "MDParser.g"
792 <                tmp37_AST->setType(ENDBLOCK);
793 < #line 703 "MDParser.cpp"
791 > #line 115 "MDParser.g"
792 >                tmp44_AST->setType(ENDBLOCK);
793 > #line 794 "MDParser.cpp"
794                  bondblock_AST = currentAST.root;
795          }
796          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 715 | Line 806 | void MDParser::bendblock() {
806          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
807          
808          try {      // for error handling
809 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 <                tmp38_AST = astFactory->create(LT(1));
811 <                astFactory->makeASTRoot(currentAST, tmp38_AST);
809 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 >                tmp45_AST = astFactory->create(LT(1));
811 >                astFactory->makeASTRoot(currentAST, tmp45_AST);
812                  match(BEND);
813                  {
814                  switch ( LA(1)) {
# Line 746 | Line 837 | void MDParser::bendblock() {
837                                  astFactory->addASTChild( currentAST, returnAST );
838                          }
839                          else {
840 <                                goto _loop38;
840 >                                goto _loop41;
841                          }
842                          
843                  }
844 <                _loop38:;
844 >                _loop41:;
845                  } // ( ... )*
846 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 <                tmp42_AST = astFactory->create(LT(1));
848 <                astFactory->addASTChild(currentAST, tmp42_AST);
846 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 >                tmp49_AST = astFactory->create(LT(1));
848 >                astFactory->addASTChild(currentAST, tmp49_AST);
849                  match(RCURLY);
850 < #line 116 "MDParser.g"
851 <                tmp42_AST->setType(ENDBLOCK);
852 < #line 762 "MDParser.cpp"
850 > #line 122 "MDParser.g"
851 >                tmp49_AST->setType(ENDBLOCK);
852 > #line 853 "MDParser.cpp"
853                  bendblock_AST = currentAST.root;
854          }
855          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 774 | Line 865 | void MDParser::torsionblock() {
865          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
866          
867          try {      // for error handling
868 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 <                tmp43_AST = astFactory->create(LT(1));
870 <                astFactory->makeASTRoot(currentAST, tmp43_AST);
868 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 >                tmp50_AST = astFactory->create(LT(1));
870 >                astFactory->makeASTRoot(currentAST, tmp50_AST);
871                  match(TORSION);
872                  {
873                  switch ( LA(1)) {
# Line 805 | Line 896 | void MDParser::torsionblock() {
896                                  astFactory->addASTChild( currentAST, returnAST );
897                          }
898                          else {
899 <                                goto _loop43;
899 >                                goto _loop46;
900                          }
901                          
902                  }
903 <                _loop43:;
903 >                _loop46:;
904                  } // ( ... )*
905 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 <                tmp47_AST = astFactory->create(LT(1));
907 <                astFactory->addASTChild(currentAST, tmp47_AST);
905 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 >                tmp54_AST = astFactory->create(LT(1));
907 >                astFactory->addASTChild(currentAST, tmp54_AST);
908                  match(RCURLY);
909 < #line 123 "MDParser.g"
910 <                tmp47_AST->setType(ENDBLOCK);
911 < #line 821 "MDParser.cpp"
909 > #line 129 "MDParser.g"
910 >                tmp54_AST->setType(ENDBLOCK);
911 > #line 912 "MDParser.cpp"
912                  torsionblock_AST = currentAST.root;
913          }
914          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 833 | Line 924 | void MDParser::inversionblock() {
924          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
925          
926          try {      // for error handling
927 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 <                tmp48_AST = astFactory->create(LT(1));
929 <                astFactory->makeASTRoot(currentAST, tmp48_AST);
927 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 >                tmp55_AST = astFactory->create(LT(1));
929 >                astFactory->makeASTRoot(currentAST, tmp55_AST);
930                  match(INVERSION);
931                  {
932                  switch ( LA(1)) {
# Line 864 | Line 955 | void MDParser::inversionblock() {
955                                  astFactory->addASTChild( currentAST, returnAST );
956                          }
957                          else {
958 <                                goto _loop48;
958 >                                goto _loop51;
959                          }
960                          
961                  }
962 <                _loop48:;
962 >                _loop51:;
963                  } // ( ... )*
964 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 <                tmp52_AST = astFactory->create(LT(1));
966 <                astFactory->addASTChild(currentAST, tmp52_AST);
964 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 >                tmp59_AST = astFactory->create(LT(1));
966 >                astFactory->addASTChild(currentAST, tmp59_AST);
967                  match(RCURLY);
968 < #line 130 "MDParser.g"
969 <                tmp52_AST->setType(ENDBLOCK);
970 < #line 880 "MDParser.cpp"
968 > #line 136 "MDParser.g"
969 >                tmp59_AST->setType(ENDBLOCK);
970 > #line 971 "MDParser.cpp"
971                  inversionblock_AST = currentAST.root;
972          }
973          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 892 | Line 983 | void MDParser::rigidbodyblock() {
983          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
984          
985          try {      // for error handling
986 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 <                tmp53_AST = astFactory->create(LT(1));
988 <                astFactory->makeASTRoot(currentAST, tmp53_AST);
986 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 >                tmp60_AST = astFactory->create(LT(1));
988 >                astFactory->makeASTRoot(currentAST, tmp60_AST);
989                  match(RIGIDBODY);
990                  match(LBRACKET);
991                  intConst();
# Line 908 | Line 999 | void MDParser::rigidbodyblock() {
999                                  astFactory->addASTChild( currentAST, returnAST );
1000                          }
1001                          else {
1002 <                                goto _loop52;
1002 >                                goto _loop55;
1003                          }
1004                          
1005                  }
1006 <                _loop52:;
1006 >                _loop55:;
1007                  } // ( ... )*
1008 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 <                tmp57_AST = astFactory->create(LT(1));
1010 <                astFactory->addASTChild(currentAST, tmp57_AST);
1008 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 >                tmp64_AST = astFactory->create(LT(1));
1010 >                astFactory->addASTChild(currentAST, tmp64_AST);
1011                  match(RCURLY);
1012 < #line 137 "MDParser.g"
1013 <                tmp57_AST->setType(ENDBLOCK);
1014 < #line 924 "MDParser.cpp"
1012 > #line 143 "MDParser.g"
1013 >                tmp64_AST->setType(ENDBLOCK);
1014 > #line 1015 "MDParser.cpp"
1015                  rigidbodyblock_AST = currentAST.root;
1016          }
1017          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 936 | Line 1027 | void MDParser::cutoffgroupblock() {
1027          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1028          
1029          try {      // for error handling
1030 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 <                tmp58_AST = astFactory->create(LT(1));
1032 <                astFactory->makeASTRoot(currentAST, tmp58_AST);
1030 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 >                tmp65_AST = astFactory->create(LT(1));
1032 >                astFactory->makeASTRoot(currentAST, tmp65_AST);
1033                  match(CUTOFFGROUP);
1034                  {
1035                  switch ( LA(1)) {
# Line 967 | Line 1058 | void MDParser::cutoffgroupblock() {
1058                                  astFactory->addASTChild( currentAST, returnAST );
1059                          }
1060                          else {
1061 <                                goto _loop57;
1061 >                                goto _loop60;
1062                          }
1063                          
1064                  }
1065 <                _loop57:;
1065 >                _loop60:;
1066                  } // ( ... )*
1067 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 <                tmp62_AST = astFactory->create(LT(1));
1069 <                astFactory->addASTChild(currentAST, tmp62_AST);
1067 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 >                tmp69_AST = astFactory->create(LT(1));
1069 >                astFactory->addASTChild(currentAST, tmp69_AST);
1070                  match(RCURLY);
1071 < #line 144 "MDParser.g"
1072 <                tmp62_AST->setType(ENDBLOCK);
1073 < #line 983 "MDParser.cpp"
1071 > #line 150 "MDParser.g"
1072 >                tmp69_AST->setType(ENDBLOCK);
1073 > #line 1074 "MDParser.cpp"
1074                  cutoffgroupblock_AST = currentAST.root;
1075          }
1076          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 995 | Line 1086 | void MDParser::fragmentblock() {
1086          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1087          
1088          try {      // for error handling
1089 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 <                tmp63_AST = astFactory->create(LT(1));
1091 <                astFactory->makeASTRoot(currentAST, tmp63_AST);
1089 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 >                tmp70_AST = astFactory->create(LT(1));
1091 >                astFactory->makeASTRoot(currentAST, tmp70_AST);
1092                  match(FRAGMENT);
1093                  match(LBRACKET);
1094                  intConst();
# Line 1011 | Line 1102 | void MDParser::fragmentblock() {
1102                                  astFactory->addASTChild( currentAST, returnAST );
1103                          }
1104                          else {
1105 <                                goto _loop61;
1105 >                                goto _loop64;
1106                          }
1107                          
1108                  }
1109 <                _loop61:;
1109 >                _loop64:;
1110                  } // ( ... )*
1111 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 <                tmp67_AST = astFactory->create(LT(1));
1113 <                astFactory->addASTChild(currentAST, tmp67_AST);
1111 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 >                tmp74_AST = astFactory->create(LT(1));
1113 >                astFactory->addASTChild(currentAST, tmp74_AST);
1114                  match(RCURLY);
1115 < #line 151 "MDParser.g"
1116 <                tmp67_AST->setType(ENDBLOCK);
1117 < #line 1027 "MDParser.cpp"
1115 > #line 157 "MDParser.g"
1116 >                tmp74_AST->setType(ENDBLOCK);
1117 > #line 1118 "MDParser.cpp"
1118                  fragmentblock_AST = currentAST.root;
1119          }
1120          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1049 | Line 1140 | void MDParser::atomstatement() {
1140                  }
1141                  case POSITION:
1142                  {
1143 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 <                        tmp68_AST = astFactory->create(LT(1));
1145 <                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1143 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 >                        tmp75_AST = astFactory->create(LT(1));
1145 >                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1146                          match(POSITION);
1147                          match(LPAREN);
1148                          doubleNumberTuple();
# Line 1063 | Line 1154 | void MDParser::atomstatement() {
1154                  }
1155                  case ORIENTATION:
1156                  {
1157 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 <                        tmp72_AST = astFactory->create(LT(1));
1159 <                        astFactory->makeASTRoot(currentAST, tmp72_AST);
1157 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 >                        tmp79_AST = astFactory->create(LT(1));
1159 >                        astFactory->makeASTRoot(currentAST, tmp79_AST);
1160                          match(ORIENTATION);
1161                          match(LPAREN);
1162                          doubleNumberTuple();
# Line 1104 | Line 1195 | void MDParser::doubleNumberTuple() {
1195                                  astFactory->addASTChild( currentAST, returnAST );
1196                          }
1197                          else {
1198 <                                goto _loop65;
1198 >                                goto _loop68;
1199                          }
1200                          
1201                  }
1202 <                _loop65:;
1202 >                _loop68:;
1203                  } // ( ... )*
1204                  doubleNumberTuple_AST = currentAST.root;
1205          }
# Line 1135 | Line 1226 | void MDParser::bondstatement() {
1226                  }
1227                  case MEMBERS:
1228                  {
1229 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 <                        tmp77_AST = astFactory->create(LT(1));
1231 <                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1229 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 >                        tmp84_AST = astFactory->create(LT(1));
1231 >                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1232                          match(MEMBERS);
1233                          match(LPAREN);
1234                          inttuple();
# Line 1176 | Line 1267 | void MDParser::inttuple() {
1267                                  astFactory->addASTChild( currentAST, returnAST );
1268                          }
1269                          else {
1270 <                                goto _loop68;
1270 >                                goto _loop71;
1271                          }
1272                          
1273                  }
1274 <                _loop68:;
1274 >                _loop71:;
1275                  } // ( ... )*
1276                  inttuple_AST = currentAST.root;
1277          }
# Line 1207 | Line 1298 | void MDParser::bendstatement() {
1298                  }
1299                  case MEMBERS:
1300                  {
1301 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 <                        tmp82_AST = astFactory->create(LT(1));
1303 <                        astFactory->makeASTRoot(currentAST, tmp82_AST);
1301 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 >                        tmp89_AST = astFactory->create(LT(1));
1303 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1304                          match(MEMBERS);
1305                          match(LPAREN);
1306                          inttuple();
# Line 1248 | Line 1339 | void MDParser::torsionstatement() {
1339                  }
1340                  case MEMBERS:
1341                  {
1342 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 <                        tmp86_AST = astFactory->create(LT(1));
1344 <                        astFactory->makeASTRoot(currentAST, tmp86_AST);
1342 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 >                        tmp93_AST = astFactory->create(LT(1));
1344 >                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1345                          match(MEMBERS);
1346                          match(LPAREN);
1347                          inttuple();
# Line 1289 | Line 1380 | void MDParser::inversionstatement() {
1380                  }
1381                  case CENTER:
1382                  {
1383 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 <                        tmp90_AST = astFactory->create(LT(1));
1385 <                        astFactory->makeASTRoot(currentAST, tmp90_AST);
1383 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 >                        tmp97_AST = astFactory->create(LT(1));
1385 >                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1386                          match(CENTER);
1387                          match(LPAREN);
1388                          intConst();
# Line 1330 | Line 1421 | void MDParser::rigidbodystatement() {
1421                  }
1422                  case MEMBERS:
1423                  {
1424 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1425 <                        tmp94_AST = astFactory->create(LT(1));
1426 <                        astFactory->makeASTRoot(currentAST, tmp94_AST);
1424 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1425 >                        tmp101_AST = astFactory->create(LT(1));
1426 >                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1427                          match(MEMBERS);
1428                          match(LPAREN);
1429                          inttuple();
# Line 1371 | Line 1462 | void MDParser::cutoffgroupstatement() {
1462                  }
1463                  case MEMBERS:
1464                  {
1465 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1466 <                        tmp98_AST = astFactory->create(LT(1));
1467 <                        astFactory->makeASTRoot(currentAST, tmp98_AST);
1465 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1466 >                        tmp105_AST = astFactory->create(LT(1));
1467 >                        astFactory->makeASTRoot(currentAST, tmp105_AST);
1468                          match(MEMBERS);
1469                          match(LPAREN);
1470                          inttuple();
# Line 1452 | Line 1543 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPA
1543  
1544   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1545   {
1546 <        factory.setMaxNodeType(55);
1546 >        factory.setMaxNodeType(56);
1547   }
1548   const char* MDParser::tokenNames[] = {
1549          "<0>",
# Line 1477 | Line 1568 | const char* MDParser::tokenNames[] = {
1568          "\"orientation\"",
1569          "\"flucQ\"",
1570          "\"RNEMD\"",
1571 +        "\"minimizer\"",
1572          "ENDBLOCK",
1573          "ID",
1574          "ASSIGNEQUAL",
# Line 1514 | Line 1606 | const char* MDParser::tokenNames[] = {
1606          0
1607   };
1608  
1609 < const unsigned long MDParser::_tokenSet_0_data_[] = { 11534576UL, 0UL, 0UL, 0UL };
1610 < // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ID
1609 > const unsigned long MDParser::_tokenSet_0_data_[] = { 24117488UL, 0UL, 0UL, 0UL };
1610 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1611 > // ID
1612   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1613   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1614   // EOF
1615   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1616 < const unsigned long MDParser::_tokenSet_2_data_[] = { 11534578UL, 0UL, 0UL, 0UL };
1616 > const unsigned long MDParser::_tokenSet_2_data_[] = { 24117490UL, 0UL, 0UL, 0UL };
1617   // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1618 < // ID
1618 > // "minimizer" ID
1619   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1620 < const unsigned long MDParser::_tokenSet_3_data_[] = { 281018354UL, 0UL, 0UL, 0UL };
1620 > const unsigned long MDParser::_tokenSet_3_data_[] = { 562036722UL, 0UL, 0UL, 0UL };
1621   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1622   // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1623 < // "center" "position" "orientation" "flucQ" "RNEMD" ID RCURLY
1623 > // "center" "position" "orientation" "flucQ" "RNEMD" "minimizer" ID RCURLY
1624   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1625 < const unsigned long MDParser::_tokenSet_4_data_[] = { 8453888UL, 0UL, 0UL, 0UL };
1625 > const unsigned long MDParser::_tokenSet_4_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1626   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1627   // "fragment" ID
1628   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1629 < const unsigned long MDParser::_tokenSet_5_data_[] = { 33554432UL, 0UL, 0UL, 0UL };
1629 > const unsigned long MDParser::_tokenSet_5_data_[] = { 67108864UL, 0UL, 0UL, 0UL };
1630   // SEMICOLON
1631   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1632 < const unsigned long MDParser::_tokenSet_6_data_[] = { 1107296256UL, 3UL, 0UL, 0UL };
1632 > const unsigned long MDParser::_tokenSet_6_data_[] = { 2214592512UL, 6UL, 0UL, 0UL };
1633   // SEMICOLON RBRACKET RPAREN COMMA
1634   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1635 < const unsigned long MDParser::_tokenSet_7_data_[] = { 33554432UL, 3UL, 0UL, 0UL };
1635 > const unsigned long MDParser::_tokenSet_7_data_[] = { 67108864UL, 6UL, 0UL, 0UL };
1636   // SEMICOLON RPAREN COMMA
1637   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1638 < const unsigned long MDParser::_tokenSet_8_data_[] = { 276889344UL, 0UL, 0UL, 0UL };
1638 > const unsigned long MDParser::_tokenSet_8_data_[] = { 553713408UL, 0UL, 0UL, 0UL };
1639   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1640   // "fragment" ID RCURLY
1641   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1642 < const unsigned long MDParser::_tokenSet_9_data_[] = { 9175040UL, 0UL, 0UL, 0UL };
1642 > const unsigned long MDParser::_tokenSet_9_data_[] = { 17563648UL, 0UL, 0UL, 0UL };
1643   // "position" "orientation" ID
1644   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1645 < const unsigned long MDParser::_tokenSet_10_data_[] = { 277610496UL, 0UL, 0UL, 0UL };
1645 > const unsigned long MDParser::_tokenSet_10_data_[] = { 554434560UL, 0UL, 0UL, 0UL };
1646   // "position" "orientation" ID RCURLY
1647   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1648 < const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 1UL, 0UL, 0UL };
1648 > const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 2UL, 0UL, 0UL };
1649   // RPAREN
1650   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1651 < const unsigned long MDParser::_tokenSet_12_data_[] = { 276889600UL, 0UL, 0UL, 0UL };
1651 > const unsigned long MDParser::_tokenSet_12_data_[] = { 553713664UL, 0UL, 0UL, 0UL };
1652   // "members" ID RCURLY
1653   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1654 < const unsigned long MDParser::_tokenSet_13_data_[] = { 276955136UL, 0UL, 0UL, 0UL };
1654 > const unsigned long MDParser::_tokenSet_13_data_[] = { 553779200UL, 0UL, 0UL, 0UL };
1655   // "center" ID RCURLY
1656   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1657 < const unsigned long MDParser::_tokenSet_14_data_[] = { 276824064UL, 0UL, 0UL, 0UL };
1657 > const unsigned long MDParser::_tokenSet_14_data_[] = { 553648128UL, 0UL, 0UL, 0UL };
1658   // ID RCURLY
1659   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1660 < const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 3UL, 0UL, 0UL };
1660 > const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 6UL, 0UL, 0UL };
1661   // RPAREN COMMA
1662   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1663  

Diff Legend

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