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 1558 by gezelter, Wed May 11 16:32:48 2011 UTC vs.
Revision 1902 by gezelter, Tue Jul 16 17:16:45 2013 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20101020): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20121118): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 96 | Line 96 | void MDParser::statement() {
96                  case RESTRAINT:
97                  {
98                          restraintblock();
99 +                        astFactory->addASTChild( currentAST, returnAST );
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;
# 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 75 "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 93 "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 78 "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 81 "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 297 | Line 318 | void MDParser::restraintblock() {
318                  recover(ex,_tokenSet_2);
319          }
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 84 "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 87 "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 90 "MDParser.g"
432 +                tmp24_AST->setType(ENDBLOCK);
433 + #line 434 "MDParser.cpp"
434 +                minimizerblock_AST = currentAST.root;
435 +        }
436 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
437 +                reportError(ex);
438 +                recover(ex,_tokenSet_2);
439 +        }
440 +        returnAST = minimizerblock_AST;
441   }
442  
443   void MDParser::constant() {
# Line 322 | Line 463 | void MDParser::constant() {
463                          constant_AST = currentAST.root;
464                          break;
465                  }
466 +                case LPAREN:
467 +                {
468 +                        vectorConst();
469 +                        astFactory->addASTChild( currentAST, returnAST );
470 +                        constant_AST = currentAST.root;
471 +                        break;
472 +                }
473                  case ID:
474                  {
475 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
476 <                        tmp16_AST = astFactory->create(LT(1));
477 <                        astFactory->addASTChild(currentAST, tmp16_AST);
475 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
476 >                        tmp25_AST = astFactory->create(LT(1));
477 >                        astFactory->addASTChild(currentAST, tmp25_AST);
478                          match(ID);
479                          constant_AST = currentAST.root;
480                          break;
481                  }
482                  case StringLiteral:
483                  {
484 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
485 <                        tmp17_AST = astFactory->create(LT(1));
486 <                        astFactory->addASTChild(currentAST, tmp17_AST);
484 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
485 >                        tmp26_AST = astFactory->create(LT(1));
486 >                        astFactory->addASTChild(currentAST, tmp26_AST);
487                          match(StringLiteral);
488                          constant_AST = currentAST.root;
489                          break;
# Line 362 | Line 510 | void MDParser::intConst() {
510                  switch ( LA(1)) {
511                  case NUM_INT:
512                  {
513 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514 <                        tmp18_AST = astFactory->create(LT(1));
515 <                        astFactory->addASTChild(currentAST, tmp18_AST);
513 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514 >                        tmp27_AST = astFactory->create(LT(1));
515 >                        astFactory->addASTChild(currentAST, tmp27_AST);
516                          match(NUM_INT);
517                          intConst_AST = currentAST.root;
518                          break;
519                  }
520                  case NUM_LONG:
521                  {
522 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 <                        tmp19_AST = astFactory->create(LT(1));
524 <                        astFactory->addASTChild(currentAST, tmp19_AST);
522 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 >                        tmp28_AST = astFactory->create(LT(1));
524 >                        astFactory->addASTChild(currentAST, tmp28_AST);
525                          match(NUM_LONG);
526                          intConst_AST = currentAST.root;
527                          break;
# Line 400 | Line 548 | void MDParser::floatConst() {
548                  switch ( LA(1)) {
549                  case NUM_FLOAT:
550                  {
551 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
552 <                        tmp20_AST = astFactory->create(LT(1));
553 <                        astFactory->addASTChild(currentAST, tmp20_AST);
551 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
552 >                        tmp29_AST = astFactory->create(LT(1));
553 >                        astFactory->addASTChild(currentAST, tmp29_AST);
554                          match(NUM_FLOAT);
555                          floatConst_AST = currentAST.root;
556                          break;
557                  }
558                  case NUM_DOUBLE:
559                  {
560 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 <                        tmp21_AST = astFactory->create(LT(1));
562 <                        astFactory->addASTChild(currentAST, tmp21_AST);
560 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 >                        tmp30_AST = astFactory->create(LT(1));
562 >                        astFactory->addASTChild(currentAST, tmp30_AST);
563                          match(NUM_DOUBLE);
564                          floatConst_AST = currentAST.root;
565                          break;
# Line 427 | Line 575 | void MDParser::floatConst() {
575                  recover(ex,_tokenSet_7);
576          }
577          returnAST = floatConst_AST;
578 + }
579 +
580 + void MDParser::vectorConst() {
581 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
582 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
583 +        ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
584 +        
585 +        try {      // for error handling
586 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
587 +                tmp31_AST = astFactory->create(LT(1));
588 +                astFactory->makeASTRoot(currentAST, tmp31_AST);
589 +                match(LPAREN);
590 +                doubleNumber();
591 +                astFactory->addASTChild( currentAST, returnAST );
592 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
593 +                tmp32_AST = astFactory->create(LT(1));
594 +                astFactory->addASTChild(currentAST, tmp32_AST);
595 +                match(COMMA);
596 +                doubleNumber();
597 +                astFactory->addASTChild( currentAST, returnAST );
598 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 +                tmp33_AST = astFactory->create(LT(1));
600 +                astFactory->addASTChild(currentAST, tmp33_AST);
601 +                match(COMMA);
602 +                doubleNumber();
603 +                astFactory->addASTChild( currentAST, returnAST );
604 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
605 +                tmp34_AST = astFactory->create(LT(1));
606 +                astFactory->addASTChild(currentAST, tmp34_AST);
607 +                match(RPAREN);
608 +                vectorConst_AST = currentAST.root;
609 +        }
610 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
611 +                reportError(ex);
612 +                recover(ex,_tokenSet_5);
613 +        }
614 +        returnAST = vectorConst_AST;
615   }
616  
617   void MDParser::moleculestatement() {
# Line 518 | Line 703 | void MDParser::atomblock() {
703          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
704          
705          try {      // for error handling
706 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 <                tmp22_AST = astFactory->create(LT(1));
708 <                astFactory->makeASTRoot(currentAST, tmp22_AST);
706 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
707 >                tmp35_AST = astFactory->create(LT(1));
708 >                astFactory->makeASTRoot(currentAST, tmp35_AST);
709                  match(ATOM);
710                  match(LBRACKET);
711                  intConst();
# Line 534 | Line 719 | void MDParser::atomblock() {
719                                  astFactory->addASTChild( currentAST, returnAST );
720                          }
721                          else {
722 <                                goto _loop22;
722 >                                goto _loop31;
723                          }
724                          
725                  }
726 <                _loop22:;
726 >                _loop31:;
727                  } // ( ... )*
728 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 <                tmp26_AST = astFactory->create(LT(1));
730 <                astFactory->addASTChild(currentAST, tmp26_AST);
728 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
729 >                tmp39_AST = astFactory->create(LT(1));
730 >                astFactory->addASTChild(currentAST, tmp39_AST);
731                  match(RCURLY);
732 < #line 90 "MDParser.g"
733 <                tmp26_AST->setType(ENDBLOCK);
734 < #line 550 "MDParser.cpp"
732 > #line 107 "MDParser.g"
733 >                tmp39_AST->setType(ENDBLOCK);
734 > #line 735 "MDParser.cpp"
735                  atomblock_AST = currentAST.root;
736          }
737          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 562 | Line 747 | void MDParser::bondblock() {
747          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
748          
749          try {      // for error handling
750 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 <                tmp27_AST = astFactory->create(LT(1));
752 <                astFactory->makeASTRoot(currentAST, tmp27_AST);
750 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
751 >                tmp40_AST = astFactory->create(LT(1));
752 >                astFactory->makeASTRoot(currentAST, tmp40_AST);
753                  match(BOND);
754                  {
755                  switch ( LA(1)) {
# Line 593 | Line 778 | void MDParser::bondblock() {
778                                  astFactory->addASTChild( currentAST, returnAST );
779                          }
780                          else {
781 <                                goto _loop27;
781 >                                goto _loop36;
782                          }
783                          
784                  }
785 <                _loop27:;
785 >                _loop36:;
786                  } // ( ... )*
787 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 <                tmp31_AST = astFactory->create(LT(1));
789 <                astFactory->addASTChild(currentAST, tmp31_AST);
787 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 >                tmp44_AST = astFactory->create(LT(1));
789 >                astFactory->addASTChild(currentAST, tmp44_AST);
790                  match(RCURLY);
791 < #line 99 "MDParser.g"
792 <                tmp31_AST->setType(ENDBLOCK);
793 < #line 609 "MDParser.cpp"
791 > #line 116 "MDParser.g"
792 >                tmp44_AST->setType(ENDBLOCK);
793 > #line 794 "MDParser.cpp"
794                  bondblock_AST = currentAST.root;
795          }
796          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 621 | Line 806 | void MDParser::bendblock() {
806          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
807          
808          try {      // for error handling
809 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 <                tmp32_AST = astFactory->create(LT(1));
811 <                astFactory->makeASTRoot(currentAST, tmp32_AST);
809 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
810 >                tmp45_AST = astFactory->create(LT(1));
811 >                astFactory->makeASTRoot(currentAST, tmp45_AST);
812                  match(BEND);
813                  {
814                  switch ( LA(1)) {
# Line 652 | Line 837 | void MDParser::bendblock() {
837                                  astFactory->addASTChild( currentAST, returnAST );
838                          }
839                          else {
840 <                                goto _loop32;
840 >                                goto _loop41;
841                          }
842                          
843                  }
844 <                _loop32:;
844 >                _loop41:;
845                  } // ( ... )*
846 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 <                tmp36_AST = astFactory->create(LT(1));
848 <                astFactory->addASTChild(currentAST, tmp36_AST);
846 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 >                tmp49_AST = astFactory->create(LT(1));
848 >                astFactory->addASTChild(currentAST, tmp49_AST);
849                  match(RCURLY);
850 < #line 106 "MDParser.g"
851 <                tmp36_AST->setType(ENDBLOCK);
852 < #line 668 "MDParser.cpp"
850 > #line 123 "MDParser.g"
851 >                tmp49_AST->setType(ENDBLOCK);
852 > #line 853 "MDParser.cpp"
853                  bendblock_AST = currentAST.root;
854          }
855          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 680 | Line 865 | void MDParser::torsionblock() {
865          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
866          
867          try {      // for error handling
868 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 <                tmp37_AST = astFactory->create(LT(1));
870 <                astFactory->makeASTRoot(currentAST, tmp37_AST);
868 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
869 >                tmp50_AST = astFactory->create(LT(1));
870 >                astFactory->makeASTRoot(currentAST, tmp50_AST);
871                  match(TORSION);
872                  {
873                  switch ( LA(1)) {
# Line 711 | Line 896 | void MDParser::torsionblock() {
896                                  astFactory->addASTChild( currentAST, returnAST );
897                          }
898                          else {
899 <                                goto _loop37;
899 >                                goto _loop46;
900                          }
901                          
902                  }
903 <                _loop37:;
903 >                _loop46:;
904                  } // ( ... )*
905 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 <                tmp41_AST = astFactory->create(LT(1));
907 <                astFactory->addASTChild(currentAST, tmp41_AST);
905 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 >                tmp54_AST = astFactory->create(LT(1));
907 >                astFactory->addASTChild(currentAST, tmp54_AST);
908                  match(RCURLY);
909 < #line 113 "MDParser.g"
910 <                tmp41_AST->setType(ENDBLOCK);
911 < #line 727 "MDParser.cpp"
909 > #line 130 "MDParser.g"
910 >                tmp54_AST->setType(ENDBLOCK);
911 > #line 912 "MDParser.cpp"
912                  torsionblock_AST = currentAST.root;
913          }
914          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 739 | Line 924 | void MDParser::inversionblock() {
924          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
925          
926          try {      // for error handling
927 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 <                tmp42_AST = astFactory->create(LT(1));
929 <                astFactory->makeASTRoot(currentAST, tmp42_AST);
927 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
928 >                tmp55_AST = astFactory->create(LT(1));
929 >                astFactory->makeASTRoot(currentAST, tmp55_AST);
930                  match(INVERSION);
931                  {
932                  switch ( LA(1)) {
# Line 765 | Line 950 | void MDParser::inversionblock() {
950                  match(LCURLY);
951                  { // ( ... )*
952                  for (;;) {
953 <                        if ((LA(1) == CENTER || LA(1) == ID)) {
953 >                        if ((_tokenSet_10.member(LA(1)))) {
954                                  inversionstatement();
955                                  astFactory->addASTChild( currentAST, returnAST );
956                          }
957                          else {
958 <                                goto _loop42;
958 >                                goto _loop51;
959                          }
960                          
961                  }
962 <                _loop42:;
962 >                _loop51:;
963                  } // ( ... )*
964 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 <                tmp46_AST = astFactory->create(LT(1));
966 <                astFactory->addASTChild(currentAST, tmp46_AST);
964 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 >                tmp59_AST = astFactory->create(LT(1));
966 >                astFactory->addASTChild(currentAST, tmp59_AST);
967                  match(RCURLY);
968 < #line 120 "MDParser.g"
969 <                tmp46_AST->setType(ENDBLOCK);
970 < #line 786 "MDParser.cpp"
968 > #line 137 "MDParser.g"
969 >                tmp59_AST->setType(ENDBLOCK);
970 > #line 971 "MDParser.cpp"
971                  inversionblock_AST = currentAST.root;
972          }
973          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 798 | Line 983 | void MDParser::rigidbodyblock() {
983          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
984          
985          try {      // for error handling
986 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 <                tmp47_AST = astFactory->create(LT(1));
988 <                astFactory->makeASTRoot(currentAST, tmp47_AST);
986 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
987 >                tmp60_AST = astFactory->create(LT(1));
988 >                astFactory->makeASTRoot(currentAST, tmp60_AST);
989                  match(RIGIDBODY);
990                  match(LBRACKET);
991                  intConst();
# Line 814 | Line 999 | void MDParser::rigidbodyblock() {
999                                  astFactory->addASTChild( currentAST, returnAST );
1000                          }
1001                          else {
1002 <                                goto _loop46;
1002 >                                goto _loop55;
1003                          }
1004                          
1005                  }
1006 <                _loop46:;
1006 >                _loop55:;
1007                  } // ( ... )*
1008 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 <                tmp51_AST = astFactory->create(LT(1));
1010 <                astFactory->addASTChild(currentAST, tmp51_AST);
1008 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1009 >                tmp64_AST = astFactory->create(LT(1));
1010 >                astFactory->addASTChild(currentAST, tmp64_AST);
1011                  match(RCURLY);
1012 < #line 127 "MDParser.g"
1013 <                tmp51_AST->setType(ENDBLOCK);
1014 < #line 830 "MDParser.cpp"
1012 > #line 145 "MDParser.g"
1013 >                tmp64_AST->setType(ENDBLOCK);
1014 > #line 1015 "MDParser.cpp"
1015                  rigidbodyblock_AST = currentAST.root;
1016          }
1017          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 842 | Line 1027 | void MDParser::cutoffgroupblock() {
1027          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1028          
1029          try {      // for error handling
1030 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 <                tmp52_AST = astFactory->create(LT(1));
1032 <                astFactory->makeASTRoot(currentAST, tmp52_AST);
1030 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1031 >                tmp65_AST = astFactory->create(LT(1));
1032 >                astFactory->makeASTRoot(currentAST, tmp65_AST);
1033                  match(CUTOFFGROUP);
1034                  {
1035                  switch ( LA(1)) {
# Line 873 | Line 1058 | void MDParser::cutoffgroupblock() {
1058                                  astFactory->addASTChild( currentAST, returnAST );
1059                          }
1060                          else {
1061 <                                goto _loop51;
1061 >                                goto _loop60;
1062                          }
1063                          
1064                  }
1065 <                _loop51:;
1065 >                _loop60:;
1066                  } // ( ... )*
1067 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 <                tmp56_AST = astFactory->create(LT(1));
1069 <                astFactory->addASTChild(currentAST, tmp56_AST);
1067 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 >                tmp69_AST = astFactory->create(LT(1));
1069 >                astFactory->addASTChild(currentAST, tmp69_AST);
1070                  match(RCURLY);
1071 < #line 134 "MDParser.g"
1072 <                tmp56_AST->setType(ENDBLOCK);
1073 < #line 889 "MDParser.cpp"
1071 > #line 152 "MDParser.g"
1072 >                tmp69_AST->setType(ENDBLOCK);
1073 > #line 1074 "MDParser.cpp"
1074                  cutoffgroupblock_AST = currentAST.root;
1075          }
1076          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 901 | Line 1086 | void MDParser::fragmentblock() {
1086          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1087          
1088          try {      // for error handling
1089 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 <                tmp57_AST = astFactory->create(LT(1));
1091 <                astFactory->makeASTRoot(currentAST, tmp57_AST);
1089 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1090 >                tmp70_AST = astFactory->create(LT(1));
1091 >                astFactory->makeASTRoot(currentAST, tmp70_AST);
1092                  match(FRAGMENT);
1093                  match(LBRACKET);
1094                  intConst();
# Line 917 | Line 1102 | void MDParser::fragmentblock() {
1102                                  astFactory->addASTChild( currentAST, returnAST );
1103                          }
1104                          else {
1105 <                                goto _loop55;
1105 >                                goto _loop64;
1106                          }
1107                          
1108                  }
1109 <                _loop55:;
1109 >                _loop64:;
1110                  } // ( ... )*
1111 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 <                tmp61_AST = astFactory->create(LT(1));
1113 <                astFactory->addASTChild(currentAST, tmp61_AST);
1111 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112 >                tmp74_AST = astFactory->create(LT(1));
1113 >                astFactory->addASTChild(currentAST, tmp74_AST);
1114                  match(RCURLY);
1115 < #line 141 "MDParser.g"
1116 <                tmp61_AST->setType(ENDBLOCK);
1117 < #line 933 "MDParser.cpp"
1115 > #line 159 "MDParser.g"
1116 >                tmp74_AST->setType(ENDBLOCK);
1117 > #line 1118 "MDParser.cpp"
1118                  fragmentblock_AST = currentAST.root;
1119          }
1120          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 955 | Line 1140 | void MDParser::atomstatement() {
1140                  }
1141                  case POSITION:
1142                  {
1143 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 <                        tmp62_AST = astFactory->create(LT(1));
1145 <                        astFactory->makeASTRoot(currentAST, tmp62_AST);
1143 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1144 >                        tmp75_AST = astFactory->create(LT(1));
1145 >                        astFactory->makeASTRoot(currentAST, tmp75_AST);
1146                          match(POSITION);
1147                          match(LPAREN);
1148                          doubleNumberTuple();
# Line 969 | Line 1154 | void MDParser::atomstatement() {
1154                  }
1155                  case ORIENTATION:
1156                  {
1157 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 <                        tmp66_AST = astFactory->create(LT(1));
1159 <                        astFactory->makeASTRoot(currentAST, tmp66_AST);
1157 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1158 >                        tmp79_AST = astFactory->create(LT(1));
1159 >                        astFactory->makeASTRoot(currentAST, tmp79_AST);
1160                          match(ORIENTATION);
1161                          match(LPAREN);
1162                          doubleNumberTuple();
# Line 989 | Line 1174 | void MDParser::atomstatement() {
1174          }
1175          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1176                  reportError(ex);
1177 <                recover(ex,_tokenSet_10);
1177 >                recover(ex,_tokenSet_11);
1178          }
1179          returnAST = atomstatement_AST;
1180   }
# Line 1010 | Line 1195 | void MDParser::doubleNumberTuple() {
1195                                  astFactory->addASTChild( currentAST, returnAST );
1196                          }
1197                          else {
1198 <                                goto _loop59;
1198 >                                goto _loop68;
1199                          }
1200                          
1201                  }
1202 <                _loop59:;
1202 >                _loop68:;
1203                  } // ( ... )*
1204                  doubleNumberTuple_AST = currentAST.root;
1205          }
1206          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1207                  reportError(ex);
1208 <                recover(ex,_tokenSet_11);
1208 >                recover(ex,_tokenSet_12);
1209          }
1210          returnAST = doubleNumberTuple_AST;
1211   }
# Line 1041 | Line 1226 | void MDParser::bondstatement() {
1226                  }
1227                  case MEMBERS:
1228                  {
1229 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 <                        tmp71_AST = astFactory->create(LT(1));
1231 <                        astFactory->makeASTRoot(currentAST, tmp71_AST);
1229 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1230 >                        tmp84_AST = astFactory->create(LT(1));
1231 >                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1232                          match(MEMBERS);
1233                          match(LPAREN);
1234                          inttuple();
# Line 1061 | Line 1246 | void MDParser::bondstatement() {
1246          }
1247          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1248                  reportError(ex);
1249 <                recover(ex,_tokenSet_12);
1249 >                recover(ex,_tokenSet_13);
1250          }
1251          returnAST = bondstatement_AST;
1252   }
# Line 1082 | Line 1267 | void MDParser::inttuple() {
1267                                  astFactory->addASTChild( currentAST, returnAST );
1268                          }
1269                          else {
1270 <                                goto _loop62;
1270 >                                goto _loop71;
1271                          }
1272                          
1273                  }
1274 <                _loop62:;
1274 >                _loop71:;
1275                  } // ( ... )*
1276                  inttuple_AST = currentAST.root;
1277          }
1278          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1279                  reportError(ex);
1280 <                recover(ex,_tokenSet_11);
1280 >                recover(ex,_tokenSet_12);
1281          }
1282          returnAST = inttuple_AST;
1283   }
# Line 1113 | Line 1298 | void MDParser::bendstatement() {
1298                  }
1299                  case MEMBERS:
1300                  {
1301 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 <                        tmp76_AST = astFactory->create(LT(1));
1303 <                        astFactory->makeASTRoot(currentAST, tmp76_AST);
1301 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1302 >                        tmp89_AST = astFactory->create(LT(1));
1303 >                        astFactory->makeASTRoot(currentAST, tmp89_AST);
1304                          match(MEMBERS);
1305                          match(LPAREN);
1306                          inttuple();
# Line 1133 | Line 1318 | void MDParser::bendstatement() {
1318          }
1319          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1320                  reportError(ex);
1321 <                recover(ex,_tokenSet_12);
1321 >                recover(ex,_tokenSet_13);
1322          }
1323          returnAST = bendstatement_AST;
1324   }
# Line 1154 | Line 1339 | void MDParser::torsionstatement() {
1339                  }
1340                  case MEMBERS:
1341                  {
1342 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 <                        tmp80_AST = astFactory->create(LT(1));
1344 <                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1342 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp93_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1343 >                        tmp93_AST = astFactory->create(LT(1));
1344 >                        astFactory->makeASTRoot(currentAST, tmp93_AST);
1345                          match(MEMBERS);
1346                          match(LPAREN);
1347                          inttuple();
# Line 1174 | Line 1359 | void MDParser::torsionstatement() {
1359          }
1360          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1361                  reportError(ex);
1362 <                recover(ex,_tokenSet_12);
1362 >                recover(ex,_tokenSet_13);
1363          }
1364          returnAST = torsionstatement_AST;
1365   }
# Line 1195 | Line 1380 | void MDParser::inversionstatement() {
1380                  }
1381                  case CENTER:
1382                  {
1383 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 <                        tmp84_AST = astFactory->create(LT(1));
1385 <                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1383 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp97_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1384 >                        tmp97_AST = astFactory->create(LT(1));
1385 >                        astFactory->makeASTRoot(currentAST, tmp97_AST);
1386                          match(CENTER);
1387                          match(LPAREN);
1388                          intConst();
# Line 1207 | Line 1392 | void MDParser::inversionstatement() {
1392                          inversionstatement_AST = currentAST.root;
1393                          break;
1394                  }
1395 +                case SATELLITES:
1396 +                {
1397 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp101_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1398 +                        tmp101_AST = astFactory->create(LT(1));
1399 +                        astFactory->makeASTRoot(currentAST, tmp101_AST);
1400 +                        match(SATELLITES);
1401 +                        match(LPAREN);
1402 +                        inttuple();
1403 +                        astFactory->addASTChild( currentAST, returnAST );
1404 +                        match(RPAREN);
1405 +                        match(SEMICOLON);
1406 +                        inversionstatement_AST = currentAST.root;
1407 +                        break;
1408 +                }
1409                  default:
1410                  {
1411                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 1215 | Line 1414 | void MDParser::inversionstatement() {
1414          }
1415          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1416                  reportError(ex);
1417 <                recover(ex,_tokenSet_13);
1417 >                recover(ex,_tokenSet_14);
1418          }
1419          returnAST = inversionstatement_AST;
1420   }
# Line 1236 | Line 1435 | void MDParser::rigidbodystatement() {
1435                  }
1436                  case MEMBERS:
1437                  {
1438 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1439 <                        tmp88_AST = astFactory->create(LT(1));
1440 <                        astFactory->makeASTRoot(currentAST, tmp88_AST);
1438 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp105_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1439 >                        tmp105_AST = astFactory->create(LT(1));
1440 >                        astFactory->makeASTRoot(currentAST, tmp105_AST);
1441                          match(MEMBERS);
1442                          match(LPAREN);
1443                          inttuple();
# Line 1256 | Line 1455 | void MDParser::rigidbodystatement() {
1455          }
1456          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1457                  reportError(ex);
1458 <                recover(ex,_tokenSet_12);
1458 >                recover(ex,_tokenSet_13);
1459          }
1460          returnAST = rigidbodystatement_AST;
1461   }
# Line 1277 | Line 1476 | void MDParser::cutoffgroupstatement() {
1476                  }
1477                  case MEMBERS:
1478                  {
1479 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1480 <                        tmp92_AST = astFactory->create(LT(1));
1481 <                        astFactory->makeASTRoot(currentAST, tmp92_AST);
1479 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp109_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1480 >                        tmp109_AST = astFactory->create(LT(1));
1481 >                        astFactory->makeASTRoot(currentAST, tmp109_AST);
1482                          match(MEMBERS);
1483                          match(LPAREN);
1484                          inttuple();
# Line 1297 | Line 1496 | void MDParser::cutoffgroupstatement() {
1496          }
1497          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1498                  reportError(ex);
1499 <                recover(ex,_tokenSet_12);
1499 >                recover(ex,_tokenSet_13);
1500          }
1501          returnAST = cutoffgroupstatement_AST;
1502   }
# Line 1314 | Line 1513 | void MDParser::fragmentstatement() {
1513          }
1514          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1515                  reportError(ex);
1516 <                recover(ex,_tokenSet_14);
1516 >                recover(ex,_tokenSet_15);
1517          }
1518          returnAST = fragmentstatement_AST;
1519   }
# Line 1351 | Line 1550 | void MDParser::doubleNumber() {
1550          }
1551          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1552                  reportError(ex);
1553 <                recover(ex,_tokenSet_15);
1553 >                recover(ex,_tokenSet_16);
1554          }
1555          returnAST = doubleNumber_AST;
1556   }
1557  
1558   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1559   {
1560 <        factory.setMaxNodeType(53);
1560 >        factory.setMaxNodeType(57);
1561   }
1562   const char* MDParser::tokenNames[] = {
1563          "<0>",
# Line 1379 | Line 1578 | const char* MDParser::tokenNames[] = {
1578          "\"fragment\"",
1579          "\"members\"",
1580          "\"center\"",
1581 +        "\"satellites\"",
1582          "\"position\"",
1583          "\"orientation\"",
1584 +        "\"flucQ\"",
1585 +        "\"RNEMD\"",
1586 +        "\"minimizer\"",
1587          "ENDBLOCK",
1588          "ID",
1589          "ASSIGNEQUAL",
# Line 1418 | Line 1621 | const char* MDParser::tokenNames[] = {
1621          0
1622   };
1623  
1624 < const unsigned long MDParser::_tokenSet_0_data_[] = { 2097392UL, 0UL, 0UL, 0UL };
1625 < // "component" "molecule" "zconstraint" "restraint" ID
1624 > const unsigned long MDParser::_tokenSet_0_data_[] = { 48234736UL, 0UL, 0UL, 0UL };
1625 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1626 > // ID
1627   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1628   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1629   // EOF
1630   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1631 < const unsigned long MDParser::_tokenSet_2_data_[] = { 2097394UL, 0UL, 0UL, 0UL };
1632 < // EOF "component" "molecule" "zconstraint" "restraint" ID
1631 > const unsigned long MDParser::_tokenSet_2_data_[] = { 48234738UL, 0UL, 0UL, 0UL };
1632 > // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1633 > // "minimizer" ID
1634   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1635 < const unsigned long MDParser::_tokenSet_3_data_[] = { 70254578UL, 0UL, 0UL, 0UL };
1635 > const unsigned long MDParser::_tokenSet_3_data_[] = { 1124073458UL, 0UL, 0UL, 0UL };
1636   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1637   // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1638 < // "center" "position" "orientation" ID RCURLY
1638 > // "center" "satellites" "position" "orientation" "flucQ" "RNEMD" "minimizer"
1639 > // ID RCURLY
1640   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1641 < const unsigned long MDParser::_tokenSet_4_data_[] = { 2162432UL, 0UL, 0UL, 0UL };
1641 > const unsigned long MDParser::_tokenSet_4_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1642   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1643   // "fragment" ID
1644   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1645 < const unsigned long MDParser::_tokenSet_5_data_[] = { 8388608UL, 0UL, 0UL, 0UL };
1645 > const unsigned long MDParser::_tokenSet_5_data_[] = { 134217728UL, 0UL, 0UL, 0UL };
1646   // SEMICOLON
1647   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1648 < const unsigned long MDParser::_tokenSet_6_data_[] = { 3498049536UL, 0UL, 0UL, 0UL };
1648 > const unsigned long MDParser::_tokenSet_6_data_[] = { 134217728UL, 13UL, 0UL, 0UL };
1649   // SEMICOLON RBRACKET RPAREN COMMA
1650   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1651 < const unsigned long MDParser::_tokenSet_7_data_[] = { 3229614080UL, 0UL, 0UL, 0UL };
1651 > const unsigned long MDParser::_tokenSet_7_data_[] = { 134217728UL, 12UL, 0UL, 0UL };
1652   // SEMICOLON RPAREN COMMA
1653   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1654 < const unsigned long MDParser::_tokenSet_8_data_[] = { 69271296UL, 0UL, 0UL, 0UL };
1654 > const unsigned long MDParser::_tokenSet_8_data_[] = { 1107361536UL, 0UL, 0UL, 0UL };
1655   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1656   // "fragment" ID RCURLY
1657   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1658 < const unsigned long MDParser::_tokenSet_9_data_[] = { 2883584UL, 0UL, 0UL, 0UL };
1658 > const unsigned long MDParser::_tokenSet_9_data_[] = { 35127296UL, 0UL, 0UL, 0UL };
1659   // "position" "orientation" ID
1660   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1661 < const unsigned long MDParser::_tokenSet_10_data_[] = { 69992448UL, 0UL, 0UL, 0UL };
1662 < // "position" "orientation" ID RCURLY
1661 > const unsigned long MDParser::_tokenSet_10_data_[] = { 33947648UL, 0UL, 0UL, 0UL };
1662 > // "center" "satellites" ID
1663   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1664 < const unsigned long MDParser::_tokenSet_11_data_[] = { 1073741824UL, 0UL, 0UL, 0UL };
1665 < // RPAREN
1664 > const unsigned long MDParser::_tokenSet_11_data_[] = { 1108869120UL, 0UL, 0UL, 0UL };
1665 > // "position" "orientation" ID RCURLY
1666   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1667 < const unsigned long MDParser::_tokenSet_12_data_[] = { 69271552UL, 0UL, 0UL, 0UL };
1668 < // "members" ID RCURLY
1667 > const unsigned long MDParser::_tokenSet_12_data_[] = { 0UL, 4UL, 0UL, 0UL };
1668 > // RPAREN
1669   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1670 < const unsigned long MDParser::_tokenSet_13_data_[] = { 69337088UL, 0UL, 0UL, 0UL };
1671 < // "center" ID RCURLY
1670 > const unsigned long MDParser::_tokenSet_13_data_[] = { 1107361792UL, 0UL, 0UL, 0UL };
1671 > // "members" ID RCURLY
1672   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1673 < const unsigned long MDParser::_tokenSet_14_data_[] = { 69206016UL, 0UL, 0UL, 0UL };
1674 < // ID RCURLY
1673 > const unsigned long MDParser::_tokenSet_14_data_[] = { 1107689472UL, 0UL, 0UL, 0UL };
1674 > // "center" "satellites" ID RCURLY
1675   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1676 < const unsigned long MDParser::_tokenSet_15_data_[] = { 3221225472UL, 0UL, 0UL, 0UL };
1677 < // RPAREN COMMA
1676 > const unsigned long MDParser::_tokenSet_15_data_[] = { 1107296256UL, 0UL, 0UL, 0UL };
1677 > // ID RCURLY
1678   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1679 + const unsigned long MDParser::_tokenSet_16_data_[] = { 0UL, 12UL, 0UL, 0UL };
1680 + // RPAREN COMMA
1681 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
1682  
1683  

Diff Legend

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