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

Comparing trunk/src/mdParser/MDParser.cpp (file contents):
Revision 770 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 1277 by gezelter, Mon Jul 14 12:35:58 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20080702): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 259 | Line 259 | void MDParser::constant() {
259          
260          try {      // for error handling
261                  switch ( LA(1)) {
262 <                case OCTALINT:
263 <                case DECIMALINT:
264 <                case HEXADECIMALINT:
265 <                case PLUS:
266 <                case MINUS:
267 <                case FLOATONE:
268 <                case FLOATTWO:
262 >                case NUM_INT:
263 >                case NUM_LONG:
264                  {
265 <                        signedNumber();
265 >                        intConst();
266                          astFactory->addASTChild( currentAST, returnAST );
267                          constant_AST = currentAST.root;
268                          break;
269                  }
270 +                case NUM_FLOAT:
271 +                case NUM_DOUBLE:
272 +                {
273 +                        floatConst();
274 +                        astFactory->addASTChild( currentAST, returnAST );
275 +                        constant_AST = currentAST.root;
276 +                        break;
277 +                }
278                  case ID:
279                  {
280                          ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 303 | Line 306 | void MDParser::constant() {
306          returnAST = constant_AST;
307   }
308  
309 < void MDParser::signedNumber() {
309 > void MDParser::intConst() {
310          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
311          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
312 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
312 >        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
313          
314          try {      // for error handling
312 –                {
315                  switch ( LA(1)) {
316 <                case PLUS:
316 >                case NUM_INT:
317                  {
318 <                        match(PLUS);
318 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
319 >                        tmp15_AST = astFactory->create(LT(1));
320 >                        astFactory->addASTChild(currentAST, tmp15_AST);
321 >                        match(NUM_INT);
322 >                        intConst_AST = currentAST.root;
323                          break;
324                  }
325 <                case MINUS:
325 >                case NUM_LONG:
326                  {
327                          ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
328                          tmp16_AST = astFactory->create(LT(1));
329 <                        astFactory->makeASTRoot(currentAST, tmp16_AST);
330 <                        match(MINUS);
331 <                        break;
326 <                }
327 <                case OCTALINT:
328 <                case DECIMALINT:
329 <                case HEXADECIMALINT:
330 <                case FLOATONE:
331 <                case FLOATTWO:
332 <                {
329 >                        astFactory->addASTChild(currentAST, tmp16_AST);
330 >                        match(NUM_LONG);
331 >                        intConst_AST = currentAST.root;
332                          break;
333                  }
334                  default:
# Line 337 | Line 336 | void MDParser::signedNumber() {
336                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
337                  }
338                  }
339 <                }
340 <                {
339 >        }
340 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
341 >                reportError(ex);
342 >                recover(ex,_tokenSet_6);
343 >        }
344 >        returnAST = intConst_AST;
345 > }
346 >
347 > void MDParser::floatConst() {
348 >        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
349 >        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
350 >        ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
351 >        
352 >        try {      // for error handling
353                  switch ( LA(1)) {
354 <                case OCTALINT:
344 <                case DECIMALINT:
345 <                case HEXADECIMALINT:
354 >                case NUM_FLOAT:
355                  {
356 <                        intConst();
357 <                        astFactory->addASTChild( currentAST, returnAST );
356 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
357 >                        tmp17_AST = astFactory->create(LT(1));
358 >                        astFactory->addASTChild(currentAST, tmp17_AST);
359 >                        match(NUM_FLOAT);
360 >                        floatConst_AST = currentAST.root;
361                          break;
362                  }
363 <                case FLOATONE:
352 <                case FLOATTWO:
363 >                case NUM_DOUBLE:
364                  {
365 <                        floatConst();
366 <                        astFactory->addASTChild( currentAST, returnAST );
365 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
366 >                        tmp18_AST = astFactory->create(LT(1));
367 >                        astFactory->addASTChild(currentAST, tmp18_AST);
368 >                        match(NUM_DOUBLE);
369 >                        floatConst_AST = currentAST.root;
370                          break;
371                  }
372                  default:
# Line 360 | Line 374 | void MDParser::signedNumber() {
374                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
375                  }
376                  }
363 –                }
364 –                signedNumber_AST = currentAST.root;
377          }
378          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
379                  reportError(ex);
380 <                recover(ex,_tokenSet_6);
380 >                recover(ex,_tokenSet_7);
381          }
382 <        returnAST = signedNumber_AST;
382 >        returnAST = floatConst_AST;
383   }
384  
385   void MDParser::moleculestatement() {
# Line 412 | Line 424 | void MDParser::moleculestatement() {
424                          moleculestatement_AST = currentAST.root;
425                          break;
426                  }
427 +                case INVERSION:
428 +                {
429 +                        inversionblock();
430 +                        astFactory->addASTChild( currentAST, returnAST );
431 +                        moleculestatement_AST = currentAST.root;
432 +                        break;
433 +                }
434                  case RIGIDBODY:
435                  {
436                          rigidbodyblock();
# Line 441 | Line 460 | void MDParser::moleculestatement() {
460          }
461          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
462                  reportError(ex);
463 <                recover(ex,_tokenSet_7);
463 >                recover(ex,_tokenSet_8);
464          }
465          returnAST = moleculestatement_AST;
466   }
# Line 452 | Line 471 | void MDParser::atomblock() {
471          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
472          
473          try {      // for error handling
474 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
475 <                tmp17_AST = astFactory->create(LT(1));
476 <                astFactory->makeASTRoot(currentAST, tmp17_AST);
474 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
475 >                tmp19_AST = astFactory->create(LT(1));
476 >                astFactory->makeASTRoot(currentAST, tmp19_AST);
477                  match(ATOM);
478                  match(LBRACKET);
479                  intConst();
# Line 463 | Line 482 | void MDParser::atomblock() {
482                  match(LCURLY);
483                  { // ( ... )*
484                  for (;;) {
485 <                        if ((_tokenSet_8.member(LA(1)))) {
485 >                        if ((_tokenSet_9.member(LA(1)))) {
486                                  atomstatement();
487                                  astFactory->addASTChild( currentAST, returnAST );
488                          }
# Line 474 | Line 493 | void MDParser::atomblock() {
493                  }
494                  _loop19:;
495                  } // ( ... )*
496 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
497 <                tmp21_AST = astFactory->create(LT(1));
498 <                astFactory->addASTChild(currentAST, tmp21_AST);
496 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
497 >                tmp23_AST = astFactory->create(LT(1));
498 >                astFactory->addASTChild(currentAST, tmp23_AST);
499                  match(RCURLY);
500 < #line 84 "MDParser.g"
501 <                tmp21_AST->setType(ENDBLOCK);
502 < #line 484 "MDParser.cpp"
500 > #line 85 "MDParser.g"
501 >                tmp23_AST->setType(ENDBLOCK);
502 > #line 503 "MDParser.cpp"
503                  atomblock_AST = currentAST.root;
504          }
505          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
506                  reportError(ex);
507 <                recover(ex,_tokenSet_7);
507 >                recover(ex,_tokenSet_8);
508          }
509          returnAST = atomblock_AST;
510   }
# Line 496 | Line 515 | void MDParser::bondblock() {
515          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
516          
517          try {      // for error handling
518 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
519 <                tmp22_AST = astFactory->create(LT(1));
520 <                astFactory->makeASTRoot(currentAST, tmp22_AST);
518 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
519 >                tmp24_AST = astFactory->create(LT(1));
520 >                astFactory->makeASTRoot(currentAST, tmp24_AST);
521                  match(BOND);
522                  {
523                  switch ( LA(1)) {
# Line 533 | Line 552 | void MDParser::bondblock() {
552                  }
553                  _loop24:;
554                  } // ( ... )*
555 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
556 <                tmp26_AST = astFactory->create(LT(1));
557 <                astFactory->addASTChild(currentAST, tmp26_AST);
555 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
556 >                tmp28_AST = astFactory->create(LT(1));
557 >                astFactory->addASTChild(currentAST, tmp28_AST);
558                  match(RCURLY);
559 < #line 93 "MDParser.g"
560 <                tmp26_AST->setType(ENDBLOCK);
561 < #line 543 "MDParser.cpp"
559 > #line 94 "MDParser.g"
560 >                tmp28_AST->setType(ENDBLOCK);
561 > #line 562 "MDParser.cpp"
562                  bondblock_AST = currentAST.root;
563          }
564          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
565                  reportError(ex);
566 <                recover(ex,_tokenSet_7);
566 >                recover(ex,_tokenSet_8);
567          }
568          returnAST = bondblock_AST;
569   }
# Line 555 | Line 574 | void MDParser::bendblock() {
574          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
575          
576          try {      // for error handling
577 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
578 <                tmp27_AST = astFactory->create(LT(1));
579 <                astFactory->makeASTRoot(currentAST, tmp27_AST);
577 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
578 >                tmp29_AST = astFactory->create(LT(1));
579 >                astFactory->makeASTRoot(currentAST, tmp29_AST);
580                  match(BEND);
581                  {
582                  switch ( LA(1)) {
# Line 592 | Line 611 | void MDParser::bendblock() {
611                  }
612                  _loop29:;
613                  } // ( ... )*
614 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
615 <                tmp31_AST = astFactory->create(LT(1));
616 <                astFactory->addASTChild(currentAST, tmp31_AST);
614 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
615 >                tmp33_AST = astFactory->create(LT(1));
616 >                astFactory->addASTChild(currentAST, tmp33_AST);
617                  match(RCURLY);
618 < #line 100 "MDParser.g"
619 <                tmp31_AST->setType(ENDBLOCK);
620 < #line 602 "MDParser.cpp"
618 > #line 101 "MDParser.g"
619 >                tmp33_AST->setType(ENDBLOCK);
620 > #line 621 "MDParser.cpp"
621                  bendblock_AST = currentAST.root;
622          }
623          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
624                  reportError(ex);
625 <                recover(ex,_tokenSet_7);
625 >                recover(ex,_tokenSet_8);
626          }
627          returnAST = bendblock_AST;
628   }
# Line 614 | Line 633 | void MDParser::torsionblock() {
633          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
634          
635          try {      // for error handling
636 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
637 <                tmp32_AST = astFactory->create(LT(1));
638 <                astFactory->makeASTRoot(currentAST, tmp32_AST);
636 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
637 >                tmp34_AST = astFactory->create(LT(1));
638 >                astFactory->makeASTRoot(currentAST, tmp34_AST);
639                  match(TORSION);
640                  {
641                  switch ( LA(1)) {
# Line 651 | Line 670 | void MDParser::torsionblock() {
670                  }
671                  _loop34:;
672                  } // ( ... )*
673 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
674 <                tmp36_AST = astFactory->create(LT(1));
675 <                astFactory->addASTChild(currentAST, tmp36_AST);
673 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
674 >                tmp38_AST = astFactory->create(LT(1));
675 >                astFactory->addASTChild(currentAST, tmp38_AST);
676                  match(RCURLY);
677 < #line 107 "MDParser.g"
678 <                tmp36_AST->setType(ENDBLOCK);
679 < #line 661 "MDParser.cpp"
677 > #line 108 "MDParser.g"
678 >                tmp38_AST->setType(ENDBLOCK);
679 > #line 680 "MDParser.cpp"
680                  torsionblock_AST = currentAST.root;
681          }
682          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683                  reportError(ex);
684 <                recover(ex,_tokenSet_7);
684 >                recover(ex,_tokenSet_8);
685          }
686          returnAST = torsionblock_AST;
687   }
688  
689 + void MDParser::inversionblock() {
690 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
691 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
692 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
693 +        
694 +        try {      // for error handling
695 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
696 +                tmp39_AST = astFactory->create(LT(1));
697 +                astFactory->makeASTRoot(currentAST, tmp39_AST);
698 +                match(INVERSION);
699 +                {
700 +                switch ( LA(1)) {
701 +                case LBRACKET:
702 +                {
703 +                        match(LBRACKET);
704 +                        intConst();
705 +                        match(RBRACKET);
706 +                        break;
707 +                }
708 +                case LCURLY:
709 +                {
710 +                        break;
711 +                }
712 +                default:
713 +                {
714 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
715 +                }
716 +                }
717 +                }
718 +                match(LCURLY);
719 +                { // ( ... )*
720 +                for (;;) {
721 +                        if ((LA(1) == CENTER || LA(1) == ID)) {
722 +                                inversionstatement();
723 +                                astFactory->addASTChild( currentAST, returnAST );
724 +                        }
725 +                        else {
726 +                                goto _loop39;
727 +                        }
728 +                        
729 +                }
730 +                _loop39:;
731 +                } // ( ... )*
732 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
733 +                tmp43_AST = astFactory->create(LT(1));
734 +                astFactory->addASTChild(currentAST, tmp43_AST);
735 +                match(RCURLY);
736 + #line 115 "MDParser.g"
737 +                tmp43_AST->setType(ENDBLOCK);
738 + #line 739 "MDParser.cpp"
739 +                inversionblock_AST = currentAST.root;
740 +        }
741 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
742 +                reportError(ex);
743 +                recover(ex,_tokenSet_8);
744 +        }
745 +        returnAST = inversionblock_AST;
746 + }
747 +
748   void MDParser::rigidbodyblock() {
749          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
750          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
751          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
752          
753          try {      // for error handling
754 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755 <                tmp37_AST = astFactory->create(LT(1));
756 <                astFactory->makeASTRoot(currentAST, tmp37_AST);
754 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755 >                tmp44_AST = astFactory->create(LT(1));
756 >                astFactory->makeASTRoot(currentAST, tmp44_AST);
757                  match(RIGIDBODY);
758                  match(LBRACKET);
759                  intConst();
# Line 689 | Line 767 | void MDParser::rigidbodyblock() {
767                                  astFactory->addASTChild( currentAST, returnAST );
768                          }
769                          else {
770 <                                goto _loop38;
770 >                                goto _loop43;
771                          }
772                          
773                  }
774 <                _loop38:;
774 >                _loop43:;
775                  } // ( ... )*
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 <                tmp41_AST = astFactory->create(LT(1));
778 <                astFactory->addASTChild(currentAST, tmp41_AST);
776 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777 >                tmp48_AST = astFactory->create(LT(1));
778 >                astFactory->addASTChild(currentAST, tmp48_AST);
779                  match(RCURLY);
780 < #line 114 "MDParser.g"
781 <                tmp41_AST->setType(ENDBLOCK);
782 < #line 705 "MDParser.cpp"
780 > #line 122 "MDParser.g"
781 >                tmp48_AST->setType(ENDBLOCK);
782 > #line 783 "MDParser.cpp"
783                  rigidbodyblock_AST = currentAST.root;
784          }
785          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
786                  reportError(ex);
787 <                recover(ex,_tokenSet_7);
787 >                recover(ex,_tokenSet_8);
788          }
789          returnAST = rigidbodyblock_AST;
790   }
# Line 717 | Line 795 | void MDParser::cutoffgroupblock() {
795          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
796          
797          try {      // for error handling
798 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 <                tmp42_AST = astFactory->create(LT(1));
800 <                astFactory->makeASTRoot(currentAST, tmp42_AST);
798 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799 >                tmp49_AST = astFactory->create(LT(1));
800 >                astFactory->makeASTRoot(currentAST, tmp49_AST);
801                  match(CUTOFFGROUP);
802                  {
803                  switch ( LA(1)) {
# Line 748 | Line 826 | void MDParser::cutoffgroupblock() {
826                                  astFactory->addASTChild( currentAST, returnAST );
827                          }
828                          else {
829 <                                goto _loop43;
829 >                                goto _loop48;
830                          }
831                          
832                  }
833 <                _loop43:;
833 >                _loop48:;
834                  } // ( ... )*
835 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 <                tmp46_AST = astFactory->create(LT(1));
837 <                astFactory->addASTChild(currentAST, tmp46_AST);
835 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 >                tmp53_AST = astFactory->create(LT(1));
837 >                astFactory->addASTChild(currentAST, tmp53_AST);
838                  match(RCURLY);
839 < #line 121 "MDParser.g"
840 <                tmp46_AST->setType(ENDBLOCK);
841 < #line 764 "MDParser.cpp"
839 > #line 129 "MDParser.g"
840 >                tmp53_AST->setType(ENDBLOCK);
841 > #line 842 "MDParser.cpp"
842                  cutoffgroupblock_AST = currentAST.root;
843          }
844          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
845                  reportError(ex);
846 <                recover(ex,_tokenSet_7);
846 >                recover(ex,_tokenSet_8);
847          }
848          returnAST = cutoffgroupblock_AST;
849   }
# Line 776 | Line 854 | void MDParser::fragmentblock() {
854          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
855          
856          try {      // for error handling
857 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 <                tmp47_AST = astFactory->create(LT(1));
859 <                astFactory->makeASTRoot(currentAST, tmp47_AST);
857 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858 >                tmp54_AST = astFactory->create(LT(1));
859 >                astFactory->makeASTRoot(currentAST, tmp54_AST);
860                  match(FRAGMENT);
861                  match(LBRACKET);
862                  intConst();
# Line 792 | Line 870 | void MDParser::fragmentblock() {
870                                  astFactory->addASTChild( currentAST, returnAST );
871                          }
872                          else {
873 <                                goto _loop47;
873 >                                goto _loop52;
874                          }
875                          
876                  }
877 <                _loop47:;
877 >                _loop52:;
878                  } // ( ... )*
879 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 <                tmp51_AST = astFactory->create(LT(1));
881 <                astFactory->addASTChild(currentAST, tmp51_AST);
879 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880 >                tmp58_AST = astFactory->create(LT(1));
881 >                astFactory->addASTChild(currentAST, tmp58_AST);
882                  match(RCURLY);
883 < #line 128 "MDParser.g"
884 <                tmp51_AST->setType(ENDBLOCK);
885 < #line 808 "MDParser.cpp"
883 > #line 136 "MDParser.g"
884 >                tmp58_AST->setType(ENDBLOCK);
885 > #line 886 "MDParser.cpp"
886                  fragmentblock_AST = currentAST.root;
887          }
888          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
889                  reportError(ex);
890 <                recover(ex,_tokenSet_7);
890 >                recover(ex,_tokenSet_8);
891          }
892          returnAST = fragmentblock_AST;
893   }
894  
817 – void MDParser::intConst() {
818 –        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
819 –        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
820 –        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
821 –        
822 –        try {      // for error handling
823 –                switch ( LA(1)) {
824 –                case OCTALINT:
825 –                {
826 –                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
827 –                        tmp52_AST = astFactory->create(LT(1));
828 –                        astFactory->addASTChild(currentAST, tmp52_AST);
829 –                        match(OCTALINT);
830 –                        intConst_AST = currentAST.root;
831 –                        break;
832 –                }
833 –                case DECIMALINT:
834 –                {
835 –                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836 –                        tmp53_AST = astFactory->create(LT(1));
837 –                        astFactory->addASTChild(currentAST, tmp53_AST);
838 –                        match(DECIMALINT);
839 –                        intConst_AST = currentAST.root;
840 –                        break;
841 –                }
842 –                case HEXADECIMALINT:
843 –                {
844 –                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
845 –                        tmp54_AST = astFactory->create(LT(1));
846 –                        astFactory->addASTChild(currentAST, tmp54_AST);
847 –                        match(HEXADECIMALINT);
848 –                        intConst_AST = currentAST.root;
849 –                        break;
850 –                }
851 –                default:
852 –                {
853 –                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
854 –                }
855 –                }
856 –        }
857 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
858 –                reportError(ex);
859 –                recover(ex,_tokenSet_9);
860 –        }
861 –        returnAST = intConst_AST;
862 – }
863 –
895   void MDParser::atomstatement() {
896          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
897          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 877 | Line 908 | void MDParser::atomstatement() {
908                  }
909                  case POSITION:
910                  {
911 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 <                        tmp55_AST = astFactory->create(LT(1));
913 <                        astFactory->makeASTRoot(currentAST, tmp55_AST);
911 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912 >                        tmp59_AST = astFactory->create(LT(1));
913 >                        astFactory->makeASTRoot(currentAST, tmp59_AST);
914                          match(POSITION);
915                          match(LPAREN);
916 <                        signedNumberTuple();
916 >                        doubleNumberTuple();
917                          astFactory->addASTChild( currentAST, returnAST );
918                          match(RPAREN);
919                          match(SEMICOLON);
# Line 891 | Line 922 | void MDParser::atomstatement() {
922                  }
923                  case ORIENTATION:
924                  {
925 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 <                        tmp59_AST = astFactory->create(LT(1));
927 <                        astFactory->makeASTRoot(currentAST, tmp59_AST);
925 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926 >                        tmp63_AST = astFactory->create(LT(1));
927 >                        astFactory->makeASTRoot(currentAST, tmp63_AST);
928                          match(ORIENTATION);
929                          match(LPAREN);
930 <                        signedNumberTuple();
930 >                        doubleNumberTuple();
931                          astFactory->addASTChild( currentAST, returnAST );
932                          match(RPAREN);
933                          match(SEMICOLON);
# Line 916 | Line 947 | void MDParser::atomstatement() {
947          returnAST = atomstatement_AST;
948   }
949  
950 < void MDParser::signedNumberTuple() {
950 > void MDParser::doubleNumberTuple() {
951          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
952          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
953 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
953 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
954          
955          try {      // for error handling
956 <                signedNumber();
956 >                doubleNumber();
957                  astFactory->addASTChild( currentAST, returnAST );
958                  { // ( ... )*
959                  for (;;) {
960                          if ((LA(1) == COMMA)) {
961                                  match(COMMA);
962 <                                signedNumber();
962 >                                doubleNumber();
963                                  astFactory->addASTChild( currentAST, returnAST );
964                          }
965                          else {
966 <                                goto _loop51;
966 >                                goto _loop56;
967                          }
968                          
969                  }
970 <                _loop51:;
970 >                _loop56:;
971                  } // ( ... )*
972 <                signedNumberTuple_AST = currentAST.root;
972 >                doubleNumberTuple_AST = currentAST.root;
973          }
974          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
975                  reportError(ex);
976                  recover(ex,_tokenSet_11);
977          }
978 <        returnAST = signedNumberTuple_AST;
978 >        returnAST = doubleNumberTuple_AST;
979   }
980  
981   void MDParser::bondstatement() {
# Line 963 | Line 994 | void MDParser::bondstatement() {
994                  }
995                  case MEMBERS:
996                  {
997 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 <                        tmp64_AST = astFactory->create(LT(1));
999 <                        astFactory->makeASTRoot(currentAST, tmp64_AST);
997 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998 >                        tmp68_AST = astFactory->create(LT(1));
999 >                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1000                          match(MEMBERS);
1001                          match(LPAREN);
1002                          inttuple();
# Line 1004 | Line 1035 | void MDParser::inttuple() {
1035                                  astFactory->addASTChild( currentAST, returnAST );
1036                          }
1037                          else {
1038 <                                goto _loop54;
1038 >                                goto _loop59;
1039                          }
1040                          
1041                  }
1042 <                _loop54:;
1042 >                _loop59:;
1043                  } // ( ... )*
1044                  inttuple_AST = currentAST.root;
1045          }
# Line 1035 | Line 1066 | void MDParser::bendstatement() {
1066                  }
1067                  case MEMBERS:
1068                  {
1069 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 <                        tmp69_AST = astFactory->create(LT(1));
1071 <                        astFactory->makeASTRoot(currentAST, tmp69_AST);
1069 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070 >                        tmp73_AST = astFactory->create(LT(1));
1071 >                        astFactory->makeASTRoot(currentAST, tmp73_AST);
1072                          match(MEMBERS);
1073                          match(LPAREN);
1074                          inttuple();
# Line 1076 | Line 1107 | void MDParser::torsionstatement() {
1107                  }
1108                  case MEMBERS:
1109                  {
1110 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 <                        tmp73_AST = astFactory->create(LT(1));
1112 <                        astFactory->makeASTRoot(currentAST, tmp73_AST);
1110 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111 >                        tmp77_AST = astFactory->create(LT(1));
1112 >                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1113                          match(MEMBERS);
1114                          match(LPAREN);
1115                          inttuple();
# Line 1099 | Line 1130 | void MDParser::torsionstatement() {
1130                  recover(ex,_tokenSet_12);
1131          }
1132          returnAST = torsionstatement_AST;
1133 + }
1134 +
1135 + void MDParser::inversionstatement() {
1136 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1137 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1138 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1139 +        
1140 +        try {      // for error handling
1141 +                switch ( LA(1)) {
1142 +                case ID:
1143 +                {
1144 +                        assignment();
1145 +                        astFactory->addASTChild( currentAST, returnAST );
1146 +                        inversionstatement_AST = currentAST.root;
1147 +                        break;
1148 +                }
1149 +                case CENTER:
1150 +                {
1151 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1152 +                        tmp81_AST = astFactory->create(LT(1));
1153 +                        astFactory->makeASTRoot(currentAST, tmp81_AST);
1154 +                        match(CENTER);
1155 +                        match(LPAREN);
1156 +                        intConst();
1157 +                        astFactory->addASTChild( currentAST, returnAST );
1158 +                        match(RPAREN);
1159 +                        match(SEMICOLON);
1160 +                        inversionstatement_AST = currentAST.root;
1161 +                        break;
1162 +                }
1163 +                default:
1164 +                {
1165 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1166 +                }
1167 +                }
1168 +        }
1169 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1170 +                reportError(ex);
1171 +                recover(ex,_tokenSet_13);
1172 +        }
1173 +        returnAST = inversionstatement_AST;
1174   }
1175  
1176   void MDParser::rigidbodystatement() {
# Line 1117 | Line 1189 | void MDParser::rigidbodystatement() {
1189                  }
1190                  case MEMBERS:
1191                  {
1192 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1193 <                        tmp77_AST = astFactory->create(LT(1));
1194 <                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1192 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1193 >                        tmp85_AST = astFactory->create(LT(1));
1194 >                        astFactory->makeASTRoot(currentAST, tmp85_AST);
1195                          match(MEMBERS);
1196                          match(LPAREN);
1197                          inttuple();
# Line 1158 | Line 1230 | void MDParser::cutoffgroupstatement() {
1230                  }
1231                  case MEMBERS:
1232                  {
1233 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1234 <                        tmp81_AST = astFactory->create(LT(1));
1235 <                        astFactory->makeASTRoot(currentAST, tmp81_AST);
1233 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1234 >                        tmp89_AST = astFactory->create(LT(1));
1235 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1236                          match(MEMBERS);
1237                          match(LPAREN);
1238                          inttuple();
# Line 1195 | Line 1267 | void MDParser::fragmentstatement() {
1267          }
1268          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1269                  reportError(ex);
1270 <                recover(ex,_tokenSet_13);
1270 >                recover(ex,_tokenSet_14);
1271          }
1272          returnAST = fragmentstatement_AST;
1273   }
1274  
1275 < void MDParser::floatConst() {
1275 > void MDParser::doubleNumber() {
1276          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1277          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1278 <        ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1278 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1279          
1280          try {      // for error handling
1281 +                {
1282                  switch ( LA(1)) {
1283 <                case FLOATONE:
1283 >                case NUM_INT:
1284 >                case NUM_LONG:
1285                  {
1286 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1287 <                        tmp85_AST = astFactory->create(LT(1));
1214 <                        astFactory->addASTChild(currentAST, tmp85_AST);
1215 <                        match(FLOATONE);
1216 <                        floatConst_AST = currentAST.root;
1286 >                        intConst();
1287 >                        astFactory->addASTChild( currentAST, returnAST );
1288                          break;
1289                  }
1290 <                case FLOATTWO:
1290 >                case NUM_FLOAT:
1291 >                case NUM_DOUBLE:
1292                  {
1293 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1294 <                        tmp86_AST = astFactory->create(LT(1));
1223 <                        astFactory->addASTChild(currentAST, tmp86_AST);
1224 <                        match(FLOATTWO);
1225 <                        floatConst_AST = currentAST.root;
1293 >                        floatConst();
1294 >                        astFactory->addASTChild( currentAST, returnAST );
1295                          break;
1296                  }
1297                  default:
# Line 1230 | Line 1299 | void MDParser::floatConst() {
1299                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1300                  }
1301                  }
1302 +                }
1303 +                doubleNumber_AST = currentAST.root;
1304          }
1305          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1306                  reportError(ex);
1307 <                recover(ex,_tokenSet_6);
1307 >                recover(ex,_tokenSet_15);
1308          }
1309 <        returnAST = floatConst_AST;
1309 >        returnAST = doubleNumber_AST;
1310   }
1311  
1312   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1313   {
1314 <        factory.setMaxNodeType(55);
1314 >        factory.setMaxNodeType(52);
1315   }
1316   const char* MDParser::tokenNames[] = {
1317          "<0>",
# Line 1254 | Line 1325 | const char* MDParser::tokenNames[] = {
1325          "\"bond\"",
1326          "\"bend\"",
1327          "\"torsion\"",
1328 +        "\"inversion\"",
1329          "\"rigidBody\"",
1330          "\"cutoffGroup\"",
1331          "\"fragment\"",
1332          "\"members\"",
1333 +        "\"center\"",
1334          "\"position\"",
1335          "\"orientation\"",
1336          "ENDBLOCK",
# Line 1272 | Line 1345 | const char* MDParser::tokenNames[] = {
1345          "LPAREN",
1346          "RPAREN",
1347          "COMMA",
1348 <        "OCTALINT",
1349 <        "DECIMALINT",
1350 <        "HEXADECIMALINT",
1351 <        "PLUS",
1279 <        "MINUS",
1280 <        "FLOATONE",
1281 <        "FLOATTWO",
1348 >        "NUM_INT",
1349 >        "NUM_LONG",
1350 >        "NUM_FLOAT",
1351 >        "NUM_DOUBLE",
1352          "DOT",
1353          "COLON",
1354          "QUESTIONMARK",
# Line 1291 | Line 1361 | const char* MDParser::tokenNames[] = {
1361          "CharLiteral",
1362          "EndOfLine",
1363          "Escape",
1364 +        "Vocabulary",
1365          "Digit",
1366          "Decimal",
1367 <        "LongSuffix",
1368 <        "UnsignedSuffix",
1369 <        "FloatSuffix",
1299 <        "Exponent",
1300 <        "Vocabulary",
1301 <        "Number",
1367 >        "HEX_DIGIT",
1368 >        "EXPONENT",
1369 >        "FLOAT_SUFFIX",
1370          0
1371   };
1372  
1373 < const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL };
1373 > const unsigned long MDParser::_tokenSet_0_data_[] = { 1048688UL, 0UL, 0UL, 0UL };
1374   // "component" "molecule" "zconstraint" ID
1375   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1376   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1377   // EOF
1378   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1379 < const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL };
1379 > const unsigned long MDParser::_tokenSet_2_data_[] = { 1048690UL, 0UL, 0UL, 0UL };
1380   // EOF "component" "molecule" "zconstraint" ID
1381   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1382 < const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL };
1382 > const unsigned long MDParser::_tokenSet_3_data_[] = { 35127282UL, 0UL, 0UL, 0UL };
1383   // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion"
1384 < // "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation"
1385 < // ID RCURLY
1384 > // "inversion" "rigidBody" "cutoffGroup" "fragment" "members" "center"
1385 > // "position" "orientation" ID RCURLY
1386   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1387 < const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL };
1388 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1389 < // ID
1387 > const unsigned long MDParser::_tokenSet_4_data_[] = { 1081216UL, 0UL, 0UL, 0UL };
1388 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1389 > // "fragment" ID
1390   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1391 < const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL };
1391 > const unsigned long MDParser::_tokenSet_5_data_[] = { 4194304UL, 0UL, 0UL, 0UL };
1392   // SEMICOLON
1393   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1394 < const unsigned long MDParser::_tokenSet_6_data_[] = { 403701760UL, 0UL, 0UL, 0UL };
1395 < // SEMICOLON RPAREN COMMA
1394 > const unsigned long MDParser::_tokenSet_6_data_[] = { 1749024768UL, 0UL, 0UL, 0UL };
1395 > // SEMICOLON RBRACKET RPAREN COMMA
1396   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1397 < const unsigned long MDParser::_tokenSet_7_data_[] = { 8667008UL, 0UL, 0UL, 0UL };
1398 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1331 < // ID RCURLY
1397 > const unsigned long MDParser::_tokenSet_7_data_[] = { 1614807040UL, 0UL, 0UL, 0UL };
1398 > // SEMICOLON RPAREN COMMA
1399   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1400 < const unsigned long MDParser::_tokenSet_8_data_[] = { 360448UL, 0UL, 0UL, 0UL };
1401 < // "position" "orientation" ID
1400 > const unsigned long MDParser::_tokenSet_8_data_[] = { 34635648UL, 0UL, 0UL, 0UL };
1401 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1402 > // "fragment" ID RCURLY
1403   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1404 < const unsigned long MDParser::_tokenSet_9_data_[] = { 437256192UL, 0UL, 0UL, 0UL };
1405 < // SEMICOLON RBRACKET RPAREN COMMA
1404 > const unsigned long MDParser::_tokenSet_9_data_[] = { 1441792UL, 0UL, 0UL, 0UL };
1405 > // "position" "orientation" ID
1406   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1407 < const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL };
1407 > const unsigned long MDParser::_tokenSet_10_data_[] = { 34996224UL, 0UL, 0UL, 0UL };
1408   // "position" "orientation" ID RCURLY
1409   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1410 < const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL };
1410 > const unsigned long MDParser::_tokenSet_11_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1411   // RPAREN
1412   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1413 < const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL };
1413 > const unsigned long MDParser::_tokenSet_12_data_[] = { 34635776UL, 0UL, 0UL, 0UL };
1414   // "members" ID RCURLY
1415   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1416 < const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL };
1417 < // ID RCURLY
1416 > const unsigned long MDParser::_tokenSet_13_data_[] = { 34668544UL, 0UL, 0UL, 0UL };
1417 > // "center" ID RCURLY
1418   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1419 + const unsigned long MDParser::_tokenSet_14_data_[] = { 34603008UL, 0UL, 0UL, 0UL };
1420 + // ID RCURLY
1421 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1422 + const unsigned long MDParser::_tokenSet_15_data_[] = { 1610612736UL, 0UL, 0UL, 0UL };
1423 + // RPAREN COMMA
1424 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1425  
1426  

Diff Legend

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