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 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20110725): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 100 | Line 100 | void MDParser::statement() {
100                          statement_AST = currentAST.root;
101                          break;
102                  }
103 +                case FLUCQ:
104 +                {
105 +                        flucqblock();
106 +                        astFactory->addASTChild( currentAST, returnAST );
107 +                        statement_AST = currentAST.root;
108 +                        break;
109 +                }
110 +                case RNEMD:
111 +                {
112 +                        rnemdblock();
113 +                        astFactory->addASTChild( currentAST, returnAST );
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 167 | Line 188 | void MDParser::componentblock() {
188                  tmp6_AST = astFactory->create(LT(1));
189                  astFactory->addASTChild(currentAST, tmp6_AST);
190                  match(RCURLY);
191 < #line 67 "MDParser.g"
191 > #line 73 "MDParser.g"
192                  tmp6_AST->setType(ENDBLOCK);
193 < #line 173 "MDParser.cpp"
193 > #line 194 "MDParser.cpp"
194                  componentblock_AST = currentAST.root;
195          }
196          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 197 | Line 218 | void MDParser::moleculeblock() {
218                                  astFactory->addASTChild( currentAST, returnAST );
219                          }
220                          else {
221 <                                goto _loop18;
221 >                                goto _loop27;
222                          }
223                          
224                  }
225 <                _loop18:;
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 76 "MDParser.g"
231 > #line 91 "MDParser.g"
232                  tmp9_AST->setType(ENDBLOCK);
233 < #line 213 "MDParser.cpp"
233 > #line 234 "MDParser.cpp"
234                  moleculeblock_AST = currentAST.root;
235          }
236          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 247 | Line 268 | void MDParser::zconstraintblock() {
268                  tmp12_AST = astFactory->create(LT(1));
269                  astFactory->addASTChild(currentAST, tmp12_AST);
270                  match(RCURLY);
271 < #line 70 "MDParser.g"
271 > #line 76 "MDParser.g"
272                  tmp12_AST->setType(ENDBLOCK);
273 < #line 253 "MDParser.cpp"
273 > #line 274 "MDParser.cpp"
274                  zconstraintblock_AST = currentAST.root;
275          }
276          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 287 | Line 308 | void MDParser::restraintblock() {
308                  tmp15_AST = astFactory->create(LT(1));
309                  astFactory->addASTChild(currentAST, tmp15_AST);
310                  match(RCURLY);
311 < #line 73 "MDParser.g"
311 > #line 79 "MDParser.g"
312                  tmp15_AST->setType(ENDBLOCK);
313 < #line 293 "MDParser.cpp"
313 > #line 314 "MDParser.cpp"
314                  restraintblock_AST = currentAST.root;
315          }
316          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 299 | Line 320 | void MDParser::restraintblock() {
320          returnAST = restraintblock_AST;
321   }
322  
323 + void MDParser::flucqblock() {
324 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
325 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
326 +        ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
327 +        
328 +        try {      // for error handling
329 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
330 +                tmp16_AST = astFactory->create(LT(1));
331 +                astFactory->makeASTRoot(currentAST, tmp16_AST);
332 +                match(FLUCQ);
333 +                match(LCURLY);
334 +                { // ( ... )*
335 +                for (;;) {
336 +                        if ((LA(1) == ID)) {
337 +                                assignment();
338 +                                astFactory->addASTChild( currentAST, returnAST );
339 +                        }
340 +                        else {
341 +                                goto _loop18;
342 +                        }
343 +                        
344 +                }
345 +                _loop18:;
346 +                } // ( ... )*
347 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
348 +                tmp18_AST = astFactory->create(LT(1));
349 +                astFactory->addASTChild(currentAST, tmp18_AST);
350 +                match(RCURLY);
351 + #line 82 "MDParser.g"
352 +                tmp18_AST->setType(ENDBLOCK);
353 + #line 354 "MDParser.cpp"
354 +                flucqblock_AST = currentAST.root;
355 +        }
356 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
357 +                reportError(ex);
358 +                recover(ex,_tokenSet_2);
359 +        }
360 +        returnAST = flucqblock_AST;
361 + }
362 +
363 + void MDParser::rnemdblock() {
364 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
365 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
366 +        ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
367 +        
368 +        try {      // for error handling
369 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
370 +                tmp19_AST = astFactory->create(LT(1));
371 +                astFactory->makeASTRoot(currentAST, tmp19_AST);
372 +                match(RNEMD);
373 +                match(LCURLY);
374 +                { // ( ... )*
375 +                for (;;) {
376 +                        if ((LA(1) == ID)) {
377 +                                assignment();
378 +                                astFactory->addASTChild( currentAST, returnAST );
379 +                        }
380 +                        else {
381 +                                goto _loop21;
382 +                        }
383 +                        
384 +                }
385 +                _loop21:;
386 +                } // ( ... )*
387 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
388 +                tmp21_AST = astFactory->create(LT(1));
389 +                astFactory->addASTChild(currentAST, tmp21_AST);
390 +                match(RCURLY);
391 + #line 85 "MDParser.g"
392 +                tmp21_AST->setType(ENDBLOCK);
393 + #line 394 "MDParser.cpp"
394 +                rnemdblock_AST = currentAST.root;
395 +        }
396 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
397 +                reportError(ex);
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 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 324 | Line 465 | void MDParser::constant() {
465                  }
466                  case ID:
467                  {
468 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
469 <                        tmp16_AST = astFactory->create(LT(1));
470 <                        astFactory->addASTChild(currentAST, tmp16_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 tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
478 <                        tmp17_AST = astFactory->create(LT(1));
479 <                        astFactory->addASTChild(currentAST, tmp17_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 362 | Line 503 | void MDParser::intConst() {
503                  switch ( LA(1)) {
504                  case NUM_INT:
505                  {
506 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507 <                        tmp18_AST = astFactory->create(LT(1));
508 <                        astFactory->addASTChild(currentAST, tmp18_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 tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
516 <                        tmp19_AST = astFactory->create(LT(1));
517 <                        astFactory->addASTChild(currentAST, tmp19_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 400 | Line 541 | void MDParser::floatConst() {
541                  switch ( LA(1)) {
542                  case NUM_FLOAT:
543                  {
544 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
545 <                        tmp20_AST = astFactory->create(LT(1));
546 <                        astFactory->addASTChild(currentAST, tmp20_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 tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
554 <                        tmp21_AST = astFactory->create(LT(1));
555 <                        astFactory->addASTChild(currentAST, tmp21_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 518 | 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 tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
663 <                tmp22_AST = astFactory->create(LT(1));
664 <                astFactory->makeASTRoot(currentAST, tmp22_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 534 | Line 675 | void MDParser::atomblock() {
675                                  astFactory->addASTChild( currentAST, returnAST );
676                          }
677                          else {
678 <                                goto _loop22;
678 >                                goto _loop31;
679                          }
680                          
681                  }
682 <                _loop22:;
682 >                _loop31:;
683                  } // ( ... )*
684 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
685 <                tmp26_AST = astFactory->create(LT(1));
686 <                astFactory->addASTChild(currentAST, tmp26_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 90 "MDParser.g"
689 <                tmp26_AST->setType(ENDBLOCK);
690 < #line 550 "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 562 | 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 tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 <                tmp27_AST = astFactory->create(LT(1));
708 <                astFactory->makeASTRoot(currentAST, tmp27_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 593 | Line 734 | void MDParser::bondblock() {
734                                  astFactory->addASTChild( currentAST, returnAST );
735                          }
736                          else {
737 <                                goto _loop27;
737 >                                goto _loop36;
738                          }
739                          
740                  }
741 <                _loop27:;
741 >                _loop36:;
742                  } // ( ... )*
743 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
744 <                tmp31_AST = astFactory->create(LT(1));
745 <                astFactory->addASTChild(currentAST, tmp31_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 99 "MDParser.g"
748 <                tmp31_AST->setType(ENDBLOCK);
749 < #line 609 "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 621 | 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 tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
766 <                tmp32_AST = astFactory->create(LT(1));
767 <                astFactory->makeASTRoot(currentAST, tmp32_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 652 | Line 793 | void MDParser::bendblock() {
793                                  astFactory->addASTChild( currentAST, returnAST );
794                          }
795                          else {
796 <                                goto _loop32;
796 >                                goto _loop41;
797                          }
798                          
799                  }
800 <                _loop32:;
800 >                _loop41:;
801                  } // ( ... )*
802 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
803 <                tmp36_AST = astFactory->create(LT(1));
804 <                astFactory->addASTChild(currentAST, tmp36_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 106 "MDParser.g"
807 <                tmp36_AST->setType(ENDBLOCK);
808 < #line 668 "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 680 | 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 tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
825 <                tmp37_AST = astFactory->create(LT(1));
826 <                astFactory->makeASTRoot(currentAST, tmp37_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 711 | Line 852 | void MDParser::torsionblock() {
852                                  astFactory->addASTChild( currentAST, returnAST );
853                          }
854                          else {
855 <                                goto _loop37;
855 >                                goto _loop46;
856                          }
857                          
858                  }
859 <                _loop37:;
859 >                _loop46:;
860                  } // ( ... )*
861 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
862 <                tmp41_AST = astFactory->create(LT(1));
863 <                astFactory->addASTChild(currentAST, tmp41_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 113 "MDParser.g"
866 <                tmp41_AST->setType(ENDBLOCK);
867 < #line 727 "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 739 | 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 tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
884 <                tmp42_AST = astFactory->create(LT(1));
885 <                astFactory->makeASTRoot(currentAST, tmp42_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 770 | Line 911 | void MDParser::inversionblock() {
911                                  astFactory->addASTChild( currentAST, returnAST );
912                          }
913                          else {
914 <                                goto _loop42;
914 >                                goto _loop51;
915                          }
916                          
917                  }
918 <                _loop42:;
918 >                _loop51:;
919                  } // ( ... )*
920 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
921 <                tmp46_AST = astFactory->create(LT(1));
922 <                astFactory->addASTChild(currentAST, tmp46_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 120 "MDParser.g"
925 <                tmp46_AST->setType(ENDBLOCK);
926 < #line 786 "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 798 | 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 tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
943 <                tmp47_AST = astFactory->create(LT(1));
944 <                astFactory->makeASTRoot(currentAST, tmp47_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 814 | Line 955 | void MDParser::rigidbodyblock() {
955                                  astFactory->addASTChild( currentAST, returnAST );
956                          }
957                          else {
958 <                                goto _loop46;
958 >                                goto _loop55;
959                          }
960                          
961                  }
962 <                _loop46:;
962 >                _loop55:;
963                  } // ( ... )*
964 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 <                tmp51_AST = astFactory->create(LT(1));
966 <                astFactory->addASTChild(currentAST, tmp51_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 127 "MDParser.g"
969 <                tmp51_AST->setType(ENDBLOCK);
970 < #line 830 "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 842 | 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 tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 <                tmp52_AST = astFactory->create(LT(1));
988 <                astFactory->makeASTRoot(currentAST, tmp52_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 873 | Line 1014 | void MDParser::cutoffgroupblock() {
1014                                  astFactory->addASTChild( currentAST, returnAST );
1015                          }
1016                          else {
1017 <                                goto _loop51;
1017 >                                goto _loop60;
1018                          }
1019                          
1020                  }
1021 <                _loop51:;
1021 >                _loop60:;
1022                  } // ( ... )*
1023 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024 <                tmp56_AST = astFactory->create(LT(1));
1025 <                astFactory->addASTChild(currentAST, tmp56_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 134 "MDParser.g"
1028 <                tmp56_AST->setType(ENDBLOCK);
1029 < #line 889 "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 901 | 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 tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1046 <                tmp57_AST = astFactory->create(LT(1));
1047 <                astFactory->makeASTRoot(currentAST, tmp57_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 917 | Line 1058 | void MDParser::fragmentblock() {
1058                                  astFactory->addASTChild( currentAST, returnAST );
1059                          }
1060                          else {
1061 <                                goto _loop55;
1061 >                                goto _loop64;
1062                          }
1063                          
1064                  }
1065 <                _loop55:;
1066 <                } // ( ... )*
1067 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 <                tmp61_AST = astFactory->create(LT(1));
1069 <                astFactory->addASTChild(currentAST, tmp61_AST);
1065 >                _loop64:;
1066 >                } // ( ... )*
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 141 "MDParser.g"
1072 <                tmp61_AST->setType(ENDBLOCK);
1073 < #line 933 "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 955 | Line 1096 | void MDParser::atomstatement() {
1096                  }
1097                  case POSITION:
1098                  {
1099 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1100 <                        tmp62_AST = astFactory->create(LT(1));
1101 <                        astFactory->makeASTRoot(currentAST, tmp62_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 969 | Line 1110 | void MDParser::atomstatement() {
1110                  }
1111                  case ORIENTATION:
1112                  {
1113 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1114 <                        tmp66_AST = astFactory->create(LT(1));
1115 <                        astFactory->makeASTRoot(currentAST, tmp66_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 1010 | Line 1151 | void MDParser::doubleNumberTuple() {
1151                                  astFactory->addASTChild( currentAST, returnAST );
1152                          }
1153                          else {
1154 <                                goto _loop59;
1154 >                                goto _loop68;
1155                          }
1156                          
1157                  }
1158 <                _loop59:;
1158 >                _loop68:;
1159                  } // ( ... )*
1160                  doubleNumberTuple_AST = currentAST.root;
1161          }
# Line 1041 | Line 1182 | void MDParser::bondstatement() {
1182                  }
1183                  case MEMBERS:
1184                  {
1185 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1186 <                        tmp71_AST = astFactory->create(LT(1));
1187 <                        astFactory->makeASTRoot(currentAST, tmp71_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 1082 | Line 1223 | void MDParser::inttuple() {
1223                                  astFactory->addASTChild( currentAST, returnAST );
1224                          }
1225                          else {
1226 <                                goto _loop62;
1226 >                                goto _loop71;
1227                          }
1228                          
1229                  }
1230 <                _loop62:;
1230 >                _loop71:;
1231                  } // ( ... )*
1232                  inttuple_AST = currentAST.root;
1233          }
# Line 1113 | Line 1254 | void MDParser::bendstatement() {
1254                  }
1255                  case MEMBERS:
1256                  {
1257 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1258 <                        tmp76_AST = astFactory->create(LT(1));
1259 <                        astFactory->makeASTRoot(currentAST, tmp76_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 1154 | Line 1295 | void MDParser::torsionstatement() {
1295                  }
1296                  case MEMBERS:
1297                  {
1298 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1299 <                        tmp80_AST = astFactory->create(LT(1));
1300 <                        astFactory->makeASTRoot(currentAST, tmp80_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 1195 | Line 1336 | void MDParser::inversionstatement() {
1336                  }
1337                  case CENTER:
1338                  {
1339 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1340 <                        tmp84_AST = astFactory->create(LT(1));
1341 <                        astFactory->makeASTRoot(currentAST, tmp84_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 1236 | Line 1377 | void MDParser::rigidbodystatement() {
1377                  }
1378                  case MEMBERS:
1379                  {
1380 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1381 <                        tmp88_AST = astFactory->create(LT(1));
1382 <                        astFactory->makeASTRoot(currentAST, tmp88_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 1277 | Line 1418 | void MDParser::cutoffgroupstatement() {
1418                  }
1419                  case MEMBERS:
1420                  {
1421 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1422 <                        tmp92_AST = astFactory->create(LT(1));
1423 <                        astFactory->makeASTRoot(currentAST, tmp92_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 1358 | Line 1499 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPA
1499  
1500   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1501   {
1502 <        factory.setMaxNodeType(53);
1502 >        factory.setMaxNodeType(56);
1503   }
1504   const char* MDParser::tokenNames[] = {
1505          "<0>",
# Line 1381 | Line 1522 | const char* MDParser::tokenNames[] = {
1522          "\"center\"",
1523          "\"position\"",
1524          "\"orientation\"",
1525 +        "\"flucQ\"",
1526 +        "\"RNEMD\"",
1527 +        "\"minimizer\"",
1528          "ENDBLOCK",
1529          "ID",
1530          "ASSIGNEQUAL",
# Line 1418 | Line 1562 | const char* MDParser::tokenNames[] = {
1562          0
1563   };
1564  
1565 < const unsigned long MDParser::_tokenSet_0_data_[] = { 2097392UL, 0UL, 0UL, 0UL };
1566 < // "component" "molecule" "zconstraint" "restraint" 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_[] = { 2097394UL, 0UL, 0UL, 0UL };
1573 < // EOF "component" "molecule" "zconstraint" "restraint" ID
1572 > const unsigned long MDParser::_tokenSet_2_data_[] = { 24117490UL, 0UL, 0UL, 0UL };
1573 > // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
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_[] = { 70254578UL, 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" 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_[] = { 2162432UL, 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_[] = { 8388608UL, 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_[] = { 3498049536UL, 0UL, 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_[] = { 3229614080UL, 0UL, 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_[] = { 69271296UL, 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_[] = { 2883584UL, 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_[] = { 69992448UL, 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_[] = { 1073741824UL, 0UL, 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_[] = { 69271552UL, 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_[] = { 69337088UL, 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_[] = { 69206016UL, 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_[] = { 3221225472UL, 0UL, 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