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 1442 by gezelter, Mon May 10 17:28:26 2010 UTC vs.
Revision 2026 by gezelter, Wed Oct 22 12:23:59 2014 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20131114): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 100 | Line 100 | void MDParser::statement() {
100                          statement_AST = currentAST.root;
101                          break;
102                  }
103 +                case FLUCQ:
104 +                {
105 +                        flucqblock();
106 +                        astFactory->addASTChild( currentAST, returnAST );
107 +                        statement_AST = currentAST.root;
108 +                        break;
109 +                }
110 +                case RNEMD:
111 +                {
112 +                        rnemdblock();
113 +                        astFactory->addASTChild( currentAST, returnAST );
114 +                        statement_AST = currentAST.root;
115 +                        break;
116 +                }
117 +                case MINIMIZER:
118 +                {
119 +                        minimizerblock();
120 +                        astFactory->addASTChild( currentAST, returnAST );
121 +                        statement_AST = currentAST.root;
122 +                        break;
123 +                }
124                  default:
125                  {
126                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 167 | Line 188 | void MDParser::componentblock() {
188                  tmp6_AST = astFactory->create(LT(1));
189                  astFactory->addASTChild(currentAST, tmp6_AST);
190                  match(RCURLY);
191 < #line 67 "MDParser.g"
191 > #line 77 "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 95 "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 80 "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 83 "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 86 "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 89 "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 92 "MDParser.g"
432 +                tmp24_AST->setType(ENDBLOCK);
433 + #line 434 "MDParser.cpp"
434 +                minimizerblock_AST = currentAST.root;
435 +        }
436 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
437 +                reportError(ex);
438 +                recover(ex,_tokenSet_2);
439 +        }
440 +        returnAST = minimizerblock_AST;
441 + }
442 +
443   void MDParser::constant() {
444          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
445          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 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 429 | Line 577 | void MDParser::floatConst() {
577          returnAST = floatConst_AST;
578   }
579  
580 + void MDParser::vectorConst() {
581 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
582 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
583 +        ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
584 +        
585 +        try {      // for error handling
586 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
587 +                tmp31_AST = astFactory->create(LT(1));
588 +                astFactory->makeASTRoot(currentAST, tmp31_AST);
589 +                match(LPAREN);
590 +                doubleNumberTuple();
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(RPAREN);
596 +                vectorConst_AST = currentAST.root;
597 +        }
598 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
599 +                reportError(ex);
600 +                recover(ex,_tokenSet_5);
601 +        }
602 +        returnAST = vectorConst_AST;
603 + }
604 +
605   void MDParser::moleculestatement() {
606          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
607          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 499 | Line 672 | void MDParser::moleculestatement() {
672                          moleculestatement_AST = currentAST.root;
673                          break;
674                  }
675 +                case CONSTRAINT:
676 +                {
677 +                        constraintblock();
678 +                        astFactory->addASTChild( currentAST, returnAST );
679 +                        moleculestatement_AST = currentAST.root;
680 +                        break;
681 +                }
682                  default:
683                  {
684                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 518 | Line 698 | void MDParser::atomblock() {
698          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
699          
700          try {      // for error handling
701 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
702 <                tmp22_AST = astFactory->create(LT(1));
703 <                astFactory->makeASTRoot(currentAST, tmp22_AST);
701 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
702 >                tmp33_AST = astFactory->create(LT(1));
703 >                astFactory->makeASTRoot(currentAST, tmp33_AST);
704                  match(ATOM);
705                  match(LBRACKET);
706                  intConst();
# Line 534 | Line 714 | void MDParser::atomblock() {
714                                  astFactory->addASTChild( currentAST, returnAST );
715                          }
716                          else {
717 <                                goto _loop22;
717 >                                goto _loop31;
718                          }
719                          
720                  }
721 <                _loop22:;
721 >                _loop31:;
722                  } // ( ... )*
723 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
724 <                tmp26_AST = astFactory->create(LT(1));
725 <                astFactory->addASTChild(currentAST, tmp26_AST);
723 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
724 >                tmp37_AST = astFactory->create(LT(1));
725 >                astFactory->addASTChild(currentAST, tmp37_AST);
726                  match(RCURLY);
727 < #line 90 "MDParser.g"
728 <                tmp26_AST->setType(ENDBLOCK);
729 < #line 550 "MDParser.cpp"
727 > #line 110 "MDParser.g"
728 >                tmp37_AST->setType(ENDBLOCK);
729 > #line 730 "MDParser.cpp"
730                  atomblock_AST = currentAST.root;
731          }
732          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 562 | Line 742 | void MDParser::bondblock() {
742          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
743          
744          try {      // for error handling
745 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
746 <                tmp27_AST = astFactory->create(LT(1));
747 <                astFactory->makeASTRoot(currentAST, tmp27_AST);
745 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
746 >                tmp38_AST = astFactory->create(LT(1));
747 >                astFactory->makeASTRoot(currentAST, tmp38_AST);
748                  match(BOND);
749                  {
750                  switch ( LA(1)) {
# Line 593 | Line 773 | void MDParser::bondblock() {
773                                  astFactory->addASTChild( currentAST, returnAST );
774                          }
775                          else {
776 <                                goto _loop27;
776 >                                goto _loop36;
777                          }
778                          
779                  }
780 <                _loop27:;
780 >                _loop36:;
781                  } // ( ... )*
782 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
783 <                tmp31_AST = astFactory->create(LT(1));
784 <                astFactory->addASTChild(currentAST, tmp31_AST);
782 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
783 >                tmp42_AST = astFactory->create(LT(1));
784 >                astFactory->addASTChild(currentAST, tmp42_AST);
785                  match(RCURLY);
786 < #line 99 "MDParser.g"
787 <                tmp31_AST->setType(ENDBLOCK);
788 < #line 609 "MDParser.cpp"
786 > #line 119 "MDParser.g"
787 >                tmp42_AST->setType(ENDBLOCK);
788 > #line 789 "MDParser.cpp"
789                  bondblock_AST = currentAST.root;
790          }
791          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 621 | Line 801 | void MDParser::bendblock() {
801          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
802          
803          try {      // for error handling
804 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
805 <                tmp32_AST = astFactory->create(LT(1));
806 <                astFactory->makeASTRoot(currentAST, tmp32_AST);
804 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
805 >                tmp43_AST = astFactory->create(LT(1));
806 >                astFactory->makeASTRoot(currentAST, tmp43_AST);
807                  match(BEND);
808                  {
809                  switch ( LA(1)) {
# Line 652 | Line 832 | void MDParser::bendblock() {
832                                  astFactory->addASTChild( currentAST, returnAST );
833                          }
834                          else {
835 <                                goto _loop32;
835 >                                goto _loop41;
836                          }
837                          
838                  }
839 <                _loop32:;
839 >                _loop41:;
840                  } // ( ... )*
841 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
842 <                tmp36_AST = astFactory->create(LT(1));
843 <                astFactory->addASTChild(currentAST, tmp36_AST);
841 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
842 >                tmp47_AST = astFactory->create(LT(1));
843 >                astFactory->addASTChild(currentAST, tmp47_AST);
844                  match(RCURLY);
845 < #line 106 "MDParser.g"
846 <                tmp36_AST->setType(ENDBLOCK);
847 < #line 668 "MDParser.cpp"
845 > #line 126 "MDParser.g"
846 >                tmp47_AST->setType(ENDBLOCK);
847 > #line 848 "MDParser.cpp"
848                  bendblock_AST = currentAST.root;
849          }
850          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 680 | Line 860 | void MDParser::torsionblock() {
860          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
861          
862          try {      // for error handling
863 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
864 <                tmp37_AST = astFactory->create(LT(1));
865 <                astFactory->makeASTRoot(currentAST, tmp37_AST);
863 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
864 >                tmp48_AST = astFactory->create(LT(1));
865 >                astFactory->makeASTRoot(currentAST, tmp48_AST);
866                  match(TORSION);
867                  {
868                  switch ( LA(1)) {
# Line 711 | Line 891 | void MDParser::torsionblock() {
891                                  astFactory->addASTChild( currentAST, returnAST );
892                          }
893                          else {
894 <                                goto _loop37;
894 >                                goto _loop46;
895                          }
896                          
897                  }
898 <                _loop37:;
898 >                _loop46:;
899                  } // ( ... )*
900 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
901 <                tmp41_AST = astFactory->create(LT(1));
902 <                astFactory->addASTChild(currentAST, tmp41_AST);
900 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
901 >                tmp52_AST = astFactory->create(LT(1));
902 >                astFactory->addASTChild(currentAST, tmp52_AST);
903                  match(RCURLY);
904 < #line 113 "MDParser.g"
905 <                tmp41_AST->setType(ENDBLOCK);
906 < #line 727 "MDParser.cpp"
904 > #line 133 "MDParser.g"
905 >                tmp52_AST->setType(ENDBLOCK);
906 > #line 907 "MDParser.cpp"
907                  torsionblock_AST = currentAST.root;
908          }
909          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 739 | Line 919 | void MDParser::inversionblock() {
919          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
920          
921          try {      // for error handling
922 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
923 <                tmp42_AST = astFactory->create(LT(1));
924 <                astFactory->makeASTRoot(currentAST, tmp42_AST);
922 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
923 >                tmp53_AST = astFactory->create(LT(1));
924 >                astFactory->makeASTRoot(currentAST, tmp53_AST);
925                  match(INVERSION);
926                  {
927                  switch ( LA(1)) {
# Line 765 | Line 945 | void MDParser::inversionblock() {
945                  match(LCURLY);
946                  { // ( ... )*
947                  for (;;) {
948 <                        if ((LA(1) == CENTER || LA(1) == ID)) {
948 >                        if ((_tokenSet_10.member(LA(1)))) {
949                                  inversionstatement();
950                                  astFactory->addASTChild( currentAST, returnAST );
951                          }
952                          else {
953 <                                goto _loop42;
953 >                                goto _loop51;
954                          }
955                          
956                  }
957 <                _loop42:;
957 >                _loop51:;
958                  } // ( ... )*
959 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
960 <                tmp46_AST = astFactory->create(LT(1));
961 <                astFactory->addASTChild(currentAST, tmp46_AST);
959 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
960 >                tmp57_AST = astFactory->create(LT(1));
961 >                astFactory->addASTChild(currentAST, tmp57_AST);
962                  match(RCURLY);
963 < #line 120 "MDParser.g"
964 <                tmp46_AST->setType(ENDBLOCK);
965 < #line 786 "MDParser.cpp"
963 > #line 140 "MDParser.g"
964 >                tmp57_AST->setType(ENDBLOCK);
965 > #line 966 "MDParser.cpp"
966                  inversionblock_AST = currentAST.root;
967          }
968          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 798 | Line 978 | void MDParser::rigidbodyblock() {
978          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
979          
980          try {      // for error handling
981 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
982 <                tmp47_AST = astFactory->create(LT(1));
983 <                astFactory->makeASTRoot(currentAST, tmp47_AST);
981 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
982 >                tmp58_AST = astFactory->create(LT(1));
983 >                astFactory->makeASTRoot(currentAST, tmp58_AST);
984                  match(RIGIDBODY);
985                  match(LBRACKET);
986                  intConst();
# Line 814 | Line 994 | void MDParser::rigidbodyblock() {
994                                  astFactory->addASTChild( currentAST, returnAST );
995                          }
996                          else {
997 <                                goto _loop46;
997 >                                goto _loop55;
998                          }
999                          
1000                  }
1001 <                _loop46:;
1001 >                _loop55:;
1002                  } // ( ... )*
1003 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1004 <                tmp51_AST = astFactory->create(LT(1));
1005 <                astFactory->addASTChild(currentAST, tmp51_AST);
1003 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1004 >                tmp62_AST = astFactory->create(LT(1));
1005 >                astFactory->addASTChild(currentAST, tmp62_AST);
1006                  match(RCURLY);
1007 < #line 127 "MDParser.g"
1008 <                tmp51_AST->setType(ENDBLOCK);
1009 < #line 830 "MDParser.cpp"
1007 > #line 148 "MDParser.g"
1008 >                tmp62_AST->setType(ENDBLOCK);
1009 > #line 1010 "MDParser.cpp"
1010                  rigidbodyblock_AST = currentAST.root;
1011          }
1012          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 842 | Line 1022 | void MDParser::cutoffgroupblock() {
1022          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1023          
1024          try {      // for error handling
1025 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026 <                tmp52_AST = astFactory->create(LT(1));
1027 <                astFactory->makeASTRoot(currentAST, tmp52_AST);
1025 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026 >                tmp63_AST = astFactory->create(LT(1));
1027 >                astFactory->makeASTRoot(currentAST, tmp63_AST);
1028                  match(CUTOFFGROUP);
1029                  {
1030                  switch ( LA(1)) {
# Line 873 | Line 1053 | void MDParser::cutoffgroupblock() {
1053                                  astFactory->addASTChild( currentAST, returnAST );
1054                          }
1055                          else {
1056 <                                goto _loop51;
1056 >                                goto _loop60;
1057                          }
1058                          
1059                  }
1060 <                _loop51:;
1060 >                _loop60:;
1061                  } // ( ... )*
1062 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1063 <                tmp56_AST = astFactory->create(LT(1));
1064 <                astFactory->addASTChild(currentAST, tmp56_AST);
1062 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1063 >                tmp67_AST = astFactory->create(LT(1));
1064 >                astFactory->addASTChild(currentAST, tmp67_AST);
1065                  match(RCURLY);
1066 < #line 134 "MDParser.g"
1067 <                tmp56_AST->setType(ENDBLOCK);
1068 < #line 889 "MDParser.cpp"
1066 > #line 155 "MDParser.g"
1067 >                tmp67_AST->setType(ENDBLOCK);
1068 > #line 1069 "MDParser.cpp"
1069                  cutoffgroupblock_AST = currentAST.root;
1070          }
1071          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 901 | Line 1081 | void MDParser::fragmentblock() {
1081          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1082          
1083          try {      // for error handling
1084 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1085 <                tmp57_AST = astFactory->create(LT(1));
1086 <                astFactory->makeASTRoot(currentAST, tmp57_AST);
1084 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1085 >                tmp68_AST = astFactory->create(LT(1));
1086 >                astFactory->makeASTRoot(currentAST, tmp68_AST);
1087                  match(FRAGMENT);
1088                  match(LBRACKET);
1089                  intConst();
# Line 917 | Line 1097 | void MDParser::fragmentblock() {
1097                                  astFactory->addASTChild( currentAST, returnAST );
1098                          }
1099                          else {
1100 <                                goto _loop55;
1100 >                                goto _loop64;
1101                          }
1102                          
1103                  }
1104 <                _loop55:;
1104 >                _loop64:;
1105                  } // ( ... )*
1106 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1107 <                tmp61_AST = astFactory->create(LT(1));
1108 <                astFactory->addASTChild(currentAST, tmp61_AST);
1106 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1107 >                tmp72_AST = astFactory->create(LT(1));
1108 >                astFactory->addASTChild(currentAST, tmp72_AST);
1109                  match(RCURLY);
1110 < #line 141 "MDParser.g"
1111 <                tmp61_AST->setType(ENDBLOCK);
1112 < #line 933 "MDParser.cpp"
1110 > #line 162 "MDParser.g"
1111 >                tmp72_AST->setType(ENDBLOCK);
1112 > #line 1113 "MDParser.cpp"
1113                  fragmentblock_AST = currentAST.root;
1114          }
1115          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 939 | Line 1119 | void MDParser::fragmentblock() {
1119          returnAST = fragmentblock_AST;
1120   }
1121  
1122 + void MDParser::constraintblock() {
1123 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1124 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1125 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1126 +        
1127 +        try {      // for error handling
1128 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1129 +                tmp73_AST = astFactory->create(LT(1));
1130 +                astFactory->makeASTRoot(currentAST, tmp73_AST);
1131 +                match(CONSTRAINT);
1132 +                {
1133 +                switch ( LA(1)) {
1134 +                case LBRACKET:
1135 +                {
1136 +                        match(LBRACKET);
1137 +                        intConst();
1138 +                        match(RBRACKET);
1139 +                        break;
1140 +                }
1141 +                case LCURLY:
1142 +                {
1143 +                        break;
1144 +                }
1145 +                default:
1146 +                {
1147 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1148 +                }
1149 +                }
1150 +                }
1151 +                match(LCURLY);
1152 +                { // ( ... )*
1153 +                for (;;) {
1154 +                        if ((LA(1) == MEMBERS || LA(1) == ID)) {
1155 +                                constraintstatement();
1156 +                                astFactory->addASTChild( currentAST, returnAST );
1157 +                        }
1158 +                        else {
1159 +                                goto _loop69;
1160 +                        }
1161 +                        
1162 +                }
1163 +                _loop69:;
1164 +                } // ( ... )*
1165 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1166 +                tmp77_AST = astFactory->create(LT(1));
1167 +                astFactory->addASTChild(currentAST, tmp77_AST);
1168 +                match(RCURLY);
1169 + #line 168 "MDParser.g"
1170 +                tmp77_AST->setType(ENDBLOCK);
1171 + #line 1172 "MDParser.cpp"
1172 +                constraintblock_AST = currentAST.root;
1173 +        }
1174 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1175 +                reportError(ex);
1176 +                recover(ex,_tokenSet_8);
1177 +        }
1178 +        returnAST = constraintblock_AST;
1179 + }
1180 +
1181   void MDParser::atomstatement() {
1182          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1183          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 955 | Line 1194 | void MDParser::atomstatement() {
1194                  }
1195                  case POSITION:
1196                  {
1197 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1198 <                        tmp62_AST = astFactory->create(LT(1));
1199 <                        astFactory->makeASTRoot(currentAST, tmp62_AST);
1197 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp78_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1198 >                        tmp78_AST = astFactory->create(LT(1));
1199 >                        astFactory->makeASTRoot(currentAST, tmp78_AST);
1200                          match(POSITION);
1201                          match(LPAREN);
1202                          doubleNumberTuple();
# Line 969 | Line 1208 | void MDParser::atomstatement() {
1208                  }
1209                  case ORIENTATION:
1210                  {
1211 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 <                        tmp66_AST = astFactory->create(LT(1));
1213 <                        astFactory->makeASTRoot(currentAST, tmp66_AST);
1211 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 >                        tmp82_AST = astFactory->create(LT(1));
1213 >                        astFactory->makeASTRoot(currentAST, tmp82_AST);
1214                          match(ORIENTATION);
1215                          match(LPAREN);
1216                          doubleNumberTuple();
# Line 989 | Line 1228 | void MDParser::atomstatement() {
1228          }
1229          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1230                  reportError(ex);
1231 <                recover(ex,_tokenSet_10);
1231 >                recover(ex,_tokenSet_11);
1232          }
1233          returnAST = atomstatement_AST;
1234   }
# Line 1010 | Line 1249 | void MDParser::doubleNumberTuple() {
1249                                  astFactory->addASTChild( currentAST, returnAST );
1250                          }
1251                          else {
1252 <                                goto _loop59;
1252 >                                goto _loop73;
1253                          }
1254                          
1255                  }
1256 <                _loop59:;
1256 >                _loop73:;
1257                  } // ( ... )*
1258                  doubleNumberTuple_AST = currentAST.root;
1259          }
1260          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1261                  reportError(ex);
1262 <                recover(ex,_tokenSet_11);
1262 >                recover(ex,_tokenSet_12);
1263          }
1264          returnAST = doubleNumberTuple_AST;
1265   }
# Line 1041 | Line 1280 | void MDParser::bondstatement() {
1280                  }
1281                  case MEMBERS:
1282                  {
1283 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1284 <                        tmp71_AST = astFactory->create(LT(1));
1285 <                        astFactory->makeASTRoot(currentAST, tmp71_AST);
1283 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1284 >                        tmp87_AST = astFactory->create(LT(1));
1285 >                        astFactory->makeASTRoot(currentAST, tmp87_AST);
1286                          match(MEMBERS);
1287                          match(LPAREN);
1288                          inttuple();
# Line 1061 | Line 1300 | void MDParser::bondstatement() {
1300          }
1301          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1302                  reportError(ex);
1303 <                recover(ex,_tokenSet_12);
1303 >                recover(ex,_tokenSet_13);
1304          }
1305          returnAST = bondstatement_AST;
1306   }
# Line 1082 | Line 1321 | void MDParser::inttuple() {
1321                                  astFactory->addASTChild( currentAST, returnAST );
1322                          }
1323                          else {
1324 <                                goto _loop62;
1324 >                                goto _loop76;
1325                          }
1326                          
1327                  }
1328 <                _loop62:;
1328 >                _loop76:;
1329                  } // ( ... )*
1330                  inttuple_AST = currentAST.root;
1331          }
1332          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1333                  reportError(ex);
1334 <                recover(ex,_tokenSet_11);
1334 >                recover(ex,_tokenSet_12);
1335          }
1336          returnAST = inttuple_AST;
1337   }
# Line 1113 | Line 1352 | void MDParser::bendstatement() {
1352                  }
1353                  case MEMBERS:
1354                  {
1355 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1356 <                        tmp76_AST = astFactory->create(LT(1));
1357 <                        astFactory->makeASTRoot(currentAST, tmp76_AST);
1355 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1356 >                        tmp92_AST = astFactory->create(LT(1));
1357 >                        astFactory->makeASTRoot(currentAST, tmp92_AST);
1358                          match(MEMBERS);
1359                          match(LPAREN);
1360                          inttuple();
# Line 1133 | Line 1372 | void MDParser::bendstatement() {
1372          }
1373          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1374                  reportError(ex);
1375 <                recover(ex,_tokenSet_12);
1375 >                recover(ex,_tokenSet_13);
1376          }
1377          returnAST = bendstatement_AST;
1378   }
# Line 1154 | Line 1393 | void MDParser::torsionstatement() {
1393                  }
1394                  case MEMBERS:
1395                  {
1396 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 <                        tmp80_AST = astFactory->create(LT(1));
1398 <                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1396 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 >                        tmp96_AST = astFactory->create(LT(1));
1398 >                        astFactory->makeASTRoot(currentAST, tmp96_AST);
1399                          match(MEMBERS);
1400                          match(LPAREN);
1401                          inttuple();
# Line 1174 | Line 1413 | void MDParser::torsionstatement() {
1413          }
1414          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1415                  reportError(ex);
1416 <                recover(ex,_tokenSet_12);
1416 >                recover(ex,_tokenSet_13);
1417          }
1418          returnAST = torsionstatement_AST;
1419   }
# Line 1195 | Line 1434 | void MDParser::inversionstatement() {
1434                  }
1435                  case CENTER:
1436                  {
1437 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438 <                        tmp84_AST = astFactory->create(LT(1));
1439 <                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1437 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438 >                        tmp100_AST = astFactory->create(LT(1));
1439 >                        astFactory->makeASTRoot(currentAST, tmp100_AST);
1440                          match(CENTER);
1441                          match(LPAREN);
1442                          intConst();
1443 +                        astFactory->addASTChild( currentAST, returnAST );
1444 +                        match(RPAREN);
1445 +                        match(SEMICOLON);
1446 +                        inversionstatement_AST = currentAST.root;
1447 +                        break;
1448 +                }
1449 +                case SATELLITES:
1450 +                {
1451 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1452 +                        tmp104_AST = astFactory->create(LT(1));
1453 +                        astFactory->makeASTRoot(currentAST, tmp104_AST);
1454 +                        match(SATELLITES);
1455 +                        match(LPAREN);
1456 +                        inttuple();
1457                          astFactory->addASTChild( currentAST, returnAST );
1458                          match(RPAREN);
1459                          match(SEMICOLON);
# Line 1215 | Line 1468 | void MDParser::inversionstatement() {
1468          }
1469          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1470                  reportError(ex);
1471 <                recover(ex,_tokenSet_13);
1471 >                recover(ex,_tokenSet_14);
1472          }
1473          returnAST = inversionstatement_AST;
1474   }
# Line 1236 | Line 1489 | void MDParser::rigidbodystatement() {
1489                  }
1490                  case MEMBERS:
1491                  {
1492 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1493 <                        tmp88_AST = astFactory->create(LT(1));
1494 <                        astFactory->makeASTRoot(currentAST, tmp88_AST);
1492 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1493 >                        tmp108_AST = astFactory->create(LT(1));
1494 >                        astFactory->makeASTRoot(currentAST, tmp108_AST);
1495                          match(MEMBERS);
1496                          match(LPAREN);
1497                          inttuple();
# Line 1256 | Line 1509 | void MDParser::rigidbodystatement() {
1509          }
1510          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1511                  reportError(ex);
1512 <                recover(ex,_tokenSet_12);
1512 >                recover(ex,_tokenSet_13);
1513          }
1514          returnAST = rigidbodystatement_AST;
1515   }
# Line 1277 | Line 1530 | void MDParser::cutoffgroupstatement() {
1530                  }
1531                  case MEMBERS:
1532                  {
1533 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1534 <                        tmp92_AST = astFactory->create(LT(1));
1535 <                        astFactory->makeASTRoot(currentAST, tmp92_AST);
1533 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1534 >                        tmp112_AST = astFactory->create(LT(1));
1535 >                        astFactory->makeASTRoot(currentAST, tmp112_AST);
1536                          match(MEMBERS);
1537                          match(LPAREN);
1538                          inttuple();
# Line 1297 | Line 1550 | void MDParser::cutoffgroupstatement() {
1550          }
1551          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1552                  reportError(ex);
1553 <                recover(ex,_tokenSet_12);
1553 >                recover(ex,_tokenSet_13);
1554          }
1555          returnAST = cutoffgroupstatement_AST;
1556   }
# Line 1314 | Line 1567 | void MDParser::fragmentstatement() {
1567          }
1568          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1569                  reportError(ex);
1570 <                recover(ex,_tokenSet_14);
1570 >                recover(ex,_tokenSet_15);
1571          }
1572          returnAST = fragmentstatement_AST;
1573   }
1574  
1575 + void MDParser::constraintstatement() {
1576 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1577 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1578 +        ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1579 +        
1580 +        try {      // for error handling
1581 +                switch ( LA(1)) {
1582 +                case ID:
1583 +                {
1584 +                        assignment();
1585 +                        astFactory->addASTChild( currentAST, returnAST );
1586 +                        constraintstatement_AST = currentAST.root;
1587 +                        break;
1588 +                }
1589 +                case MEMBERS:
1590 +                {
1591 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1592 +                        tmp116_AST = astFactory->create(LT(1));
1593 +                        astFactory->makeASTRoot(currentAST, tmp116_AST);
1594 +                        match(MEMBERS);
1595 +                        match(LPAREN);
1596 +                        inttuple();
1597 +                        astFactory->addASTChild( currentAST, returnAST );
1598 +                        match(RPAREN);
1599 +                        match(SEMICOLON);
1600 +                        constraintstatement_AST = currentAST.root;
1601 +                        break;
1602 +                }
1603 +                default:
1604 +                {
1605 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1606 +                }
1607 +                }
1608 +        }
1609 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1610 +                reportError(ex);
1611 +                recover(ex,_tokenSet_13);
1612 +        }
1613 +        returnAST = constraintstatement_AST;
1614 + }
1615 +
1616   void MDParser::doubleNumber() {
1617          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1618          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 1351 | Line 1645 | void MDParser::doubleNumber() {
1645          }
1646          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1647                  reportError(ex);
1648 <                recover(ex,_tokenSet_15);
1648 >                recover(ex,_tokenSet_16);
1649          }
1650          returnAST = doubleNumber_AST;
1651   }
1652  
1653   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1654   {
1655 <        factory.setMaxNodeType(53);
1655 >        factory.setMaxNodeType(59);
1656   }
1657   const char* MDParser::tokenNames[] = {
1658          "<0>",
# Line 1376 | Line 1670 | const char* MDParser::tokenNames[] = {
1670          "\"inversion\"",
1671          "\"rigidBody\"",
1672          "\"cutoffGroup\"",
1673 +        "\"constraint\"",
1674 +        "\"distance\"",
1675          "\"fragment\"",
1676          "\"members\"",
1677          "\"center\"",
1678 +        "\"satellites\"",
1679          "\"position\"",
1680          "\"orientation\"",
1681 +        "\"flucQ\"",
1682 +        "\"RNEMD\"",
1683 +        "\"minimizer\"",
1684          "ENDBLOCK",
1685          "ID",
1686          "ASSIGNEQUAL",
# Line 1418 | Line 1718 | const char* MDParser::tokenNames[] = {
1718          0
1719   };
1720  
1721 < const unsigned long MDParser::_tokenSet_0_data_[] = { 2097392UL, 0UL, 0UL, 0UL };
1722 < // "component" "molecule" "zconstraint" "restraint" ID
1721 > const unsigned long MDParser::_tokenSet_0_data_[] = { 192938224UL, 0UL, 0UL, 0UL };
1722 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1723 > // ID
1724   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1725   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1726   // EOF
1727   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1728 < const unsigned long MDParser::_tokenSet_2_data_[] = { 2097394UL, 0UL, 0UL, 0UL };
1729 < // EOF "component" "molecule" "zconstraint" "restraint" ID
1728 > const unsigned long MDParser::_tokenSet_2_data_[] = { 192938226UL, 0UL, 0UL, 0UL };
1729 > // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1730 > // "minimizer" ID
1731   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1732 < const unsigned long MDParser::_tokenSet_3_data_[] = { 70254578UL, 0UL, 0UL, 0UL };
1732 > const unsigned long MDParser::_tokenSet_3_data_[] = { 201261042UL, 1UL, 0UL, 0UL };
1733   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1734 < // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1735 < // "center" "position" "orientation" ID RCURLY
1734 > // "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment"
1735 > // "members" "center" "satellites" "position" "orientation" "flucQ" "RNEMD"
1736 > // "minimizer" ID RCURLY
1737   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1738 < const unsigned long MDParser::_tokenSet_4_data_[] = { 2162432UL, 0UL, 0UL, 0UL };
1738 > const unsigned long MDParser::_tokenSet_4_data_[] = { 134414080UL, 0UL, 0UL, 0UL };
1739   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1740 < // "fragment" ID
1740 > // "constraint" "fragment" ID
1741   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1742 < const unsigned long MDParser::_tokenSet_5_data_[] = { 8388608UL, 0UL, 0UL, 0UL };
1742 > const unsigned long MDParser::_tokenSet_5_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1743   // SEMICOLON
1744   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1745 < const unsigned long MDParser::_tokenSet_6_data_[] = { 3498049536UL, 0UL, 0UL, 0UL };
1745 > const unsigned long MDParser::_tokenSet_6_data_[] = { 536870912UL, 52UL, 0UL, 0UL };
1746   // SEMICOLON RBRACKET RPAREN COMMA
1747   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1748 < const unsigned long MDParser::_tokenSet_7_data_[] = { 3229614080UL, 0UL, 0UL, 0UL };
1748 > const unsigned long MDParser::_tokenSet_7_data_[] = { 536870912UL, 48UL, 0UL, 0UL };
1749   // SEMICOLON RPAREN COMMA
1750   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1751 < const unsigned long MDParser::_tokenSet_8_data_[] = { 69271296UL, 0UL, 0UL, 0UL };
1751 > const unsigned long MDParser::_tokenSet_8_data_[] = { 134414080UL, 1UL, 0UL, 0UL };
1752   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1753 < // "fragment" ID RCURLY
1753 > // "constraint" "fragment" ID RCURLY
1754   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1755 < const unsigned long MDParser::_tokenSet_9_data_[] = { 2883584UL, 0UL, 0UL, 0UL };
1755 > const unsigned long MDParser::_tokenSet_9_data_[] = { 140509184UL, 0UL, 0UL, 0UL };
1756   // "position" "orientation" ID
1757   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1758 < const unsigned long MDParser::_tokenSet_10_data_[] = { 69992448UL, 0UL, 0UL, 0UL };
1759 < // "position" "orientation" ID RCURLY
1758 > const unsigned long MDParser::_tokenSet_10_data_[] = { 135790592UL, 0UL, 0UL, 0UL };
1759 > // "center" "satellites" ID
1760   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1761 < const unsigned long MDParser::_tokenSet_11_data_[] = { 1073741824UL, 0UL, 0UL, 0UL };
1762 < // RPAREN
1761 > const unsigned long MDParser::_tokenSet_11_data_[] = { 140509184UL, 1UL, 0UL, 0UL };
1762 > // "position" "orientation" ID RCURLY
1763   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1764 < const unsigned long MDParser::_tokenSet_12_data_[] = { 69271552UL, 0UL, 0UL, 0UL };
1765 < // "members" ID RCURLY
1764 > const unsigned long MDParser::_tokenSet_12_data_[] = { 0UL, 16UL, 0UL, 0UL };
1765 > // RPAREN
1766   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1767 < const unsigned long MDParser::_tokenSet_13_data_[] = { 69337088UL, 0UL, 0UL, 0UL };
1768 < // "center" ID RCURLY
1767 > const unsigned long MDParser::_tokenSet_13_data_[] = { 134479872UL, 1UL, 0UL, 0UL };
1768 > // "members" ID RCURLY
1769   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1770 < const unsigned long MDParser::_tokenSet_14_data_[] = { 69206016UL, 0UL, 0UL, 0UL };
1771 < // ID RCURLY
1770 > const unsigned long MDParser::_tokenSet_14_data_[] = { 135790592UL, 1UL, 0UL, 0UL };
1771 > // "center" "satellites" ID RCURLY
1772   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1773 < const unsigned long MDParser::_tokenSet_15_data_[] = { 3221225472UL, 0UL, 0UL, 0UL };
1774 < // RPAREN COMMA
1773 > const unsigned long MDParser::_tokenSet_15_data_[] = { 134217728UL, 1UL, 0UL, 0UL };
1774 > // ID RCURLY
1775   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1776 + const unsigned long MDParser::_tokenSet_16_data_[] = { 0UL, 48UL, 0UL, 0UL };
1777 + // RPAREN COMMA
1778 + const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
1779  
1780  

Diff Legend

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