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

Comparing branches/development/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC vs.
Revision 1746 by gezelter, Wed Jun 6 02:18:54 2012 UTC

# Line 92 | Line 92 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
92                          _t = _retTree;
93                          break;
94                  }
95 +                case MINIMIZER:
96 +                {
97 +                        minimizerblock(_t);
98 +                        _t = _retTree;
99 +                        break;
100 +                }
101                  default:
102                  {
103                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 139 | Line 145 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
145                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146                  match(_t,COMPONENT);
147                  _t = _t->getFirstChild();
148 < #line 64 "MDTreeParser.g"
148 > #line 65 "MDTreeParser.g"
149                  Component* currComponet = new Component(); blockStack.push(currComponet);
150 < #line 145 "MDTreeParser.cpp"
150 > #line 151 "MDTreeParser.cpp"
151                  { // ( ... )*
152                  for (;;) {
153                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 162 | Line 168 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
168                  _t = _t->getNextSibling();
169                  _t = __t9;
170                  _t = _t->getNextSibling();
171 < #line 66 "MDTreeParser.g"
171 > #line 67 "MDTreeParser.g"
172                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173 < #line 168 "MDTreeParser.cpp"
173 > #line 174 "MDTreeParser.cpp"
174          }
175          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176                  reportError(ex);
# Line 178 | Line 184 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
184          ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
185          
186          try {      // for error handling
187 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
187 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
188                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189                  match(_t,MOLECULE);
190                  _t = _t->getFirstChild();
191 < #line 90 "MDTreeParser.g"
191 > #line 96 "MDTreeParser.g"
192                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193 < #line 188 "MDTreeParser.cpp"
193 > #line 194 "MDTreeParser.cpp"
194                  { // ( ... )*
195                  for (;;) {
196                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 194 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200                                  _t = _retTree;
201                          }
202                          else {
203 <                                goto _loop31;
203 >                                goto _loop35;
204                          }
205                          
206                  }
207 <                _loop31:;
207 >                _loop35:;
208                  } // ( ... )*
209                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210                  match(_t,ENDBLOCK);
211                  _t = _t->getNextSibling();
212 <                _t = __t29;
212 >                _t = __t33;
213                  _t = _t->getNextSibling();
214 < #line 92 "MDTreeParser.g"
214 > #line 98 "MDTreeParser.g"
215                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216 < #line 211 "MDTreeParser.cpp"
216 > #line 217 "MDTreeParser.cpp"
217          }
218          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219                  reportError(ex);
# Line 225 | Line 231 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
231                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232                  match(_t,ZCONSTRAINT);
233                  _t = _t->getFirstChild();
234 < #line 69 "MDTreeParser.g"
234 > #line 70 "MDTreeParser.g"
235                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236 < #line 231 "MDTreeParser.cpp"
236 > #line 237 "MDTreeParser.cpp"
237                  { // ( ... )*
238                  for (;;) {
239                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 248 | Line 254 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
254                  _t = _t->getNextSibling();
255                  _t = __t13;
256                  _t = _t->getNextSibling();
257 < #line 71 "MDTreeParser.g"
257 > #line 72 "MDTreeParser.g"
258                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259 < #line 254 "MDTreeParser.cpp"
259 > #line 260 "MDTreeParser.cpp"
260          }
261          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262                  reportError(ex);
# Line 268 | Line 274 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
274                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275                  match(_t,RESTRAINT);
276                  _t = _t->getFirstChild();
277 < #line 74 "MDTreeParser.g"
277 > #line 75 "MDTreeParser.g"
278                  RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279 < #line 274 "MDTreeParser.cpp"
279 > #line 280 "MDTreeParser.cpp"
280                  { // ( ... )*
281                  for (;;) {
282                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 291 | Line 297 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
297                  _t = _t->getNextSibling();
298                  _t = __t17;
299                  _t = _t->getNextSibling();
300 < #line 76 "MDTreeParser.g"
300 > #line 77 "MDTreeParser.g"
301                  blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302 < #line 297 "MDTreeParser.cpp"
302 > #line 303 "MDTreeParser.cpp"
303          }
304          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305                  reportError(ex);
# Line 311 | Line 317 | void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
317                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318                  match(_t,FLUCQ);
319                  _t = _t->getFirstChild();
320 < #line 79 "MDTreeParser.g"
320 > #line 80 "MDTreeParser.g"
321                  FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322 < #line 317 "MDTreeParser.cpp"
322 > #line 323 "MDTreeParser.cpp"
323                  { // ( ... )*
324                  for (;;) {
325                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 334 | Line 340 | void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
340                  _t = _t->getNextSibling();
341                  _t = __t21;
342                  _t = _t->getNextSibling();
343 < #line 81 "MDTreeParser.g"
343 > #line 82 "MDTreeParser.g"
344                  blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345 < #line 340 "MDTreeParser.cpp"
345 > #line 346 "MDTreeParser.cpp"
346          }
347          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348                  reportError(ex);
# Line 354 | Line 360 | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
360                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361                  match(_t,RNEMD);
362                  _t = _t->getFirstChild();
363 < #line 84 "MDTreeParser.g"
363 > #line 85 "MDTreeParser.g"
364                  RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365 < #line 360 "MDTreeParser.cpp"
365 > #line 366 "MDTreeParser.cpp"
366                  { // ( ... )*
367                  for (;;) {
368                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 377 | Line 383 | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
383                  _t = _t->getNextSibling();
384                  _t = __t25;
385                  _t = _t->getNextSibling();
386 < #line 86 "MDTreeParser.g"
386 > #line 87 "MDTreeParser.g"
387                  blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388 < #line 383 "MDTreeParser.cpp"
388 > #line 389 "MDTreeParser.cpp"
389          }
390          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
391                  reportError(ex);
# Line 389 | Line 395 | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
395          _retTree = _t;
396   }
397  
398 + void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
399 +        ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
400 +        
401 +        try {      // for error handling
402 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
403 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404 +                match(_t,MINIMIZER);
405 +                _t = _t->getFirstChild();
406 + #line 90 "MDTreeParser.g"
407 +                MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408 + #line 409 "MDTreeParser.cpp"
409 +                { // ( ... )*
410 +                for (;;) {
411 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
412 +                                _t = ASTNULL;
413 +                        if ((_t->getType() == ASSIGNEQUAL)) {
414 +                                assignment(_t);
415 +                                _t = _retTree;
416 +                        }
417 +                        else {
418 +                                goto _loop31;
419 +                        }
420 +                        
421 +                }
422 +                _loop31:;
423 +                } // ( ... )*
424 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425 +                match(_t,ENDBLOCK);
426 +                _t = _t->getNextSibling();
427 +                _t = __t29;
428 +                _t = _t->getNextSibling();
429 + #line 92 "MDTreeParser.g"
430 +                blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431 + #line 432 "MDTreeParser.cpp"
432 +        }
433 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
434 +                reportError(ex);
435 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
436 +                        _t = _t->getNextSibling();
437 +        }
438 +        _retTree = _t;
439 + }
440 +
441   void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
442          ANTLR_USE_NAMESPACE(antlr)RefAST id
443   ) {
444          ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447 < #line 49 "MDTreeParser.g"
447 > #line 50 "MDTreeParser.g"
448          
449          int ival;
450          RealType dval;
451          
452 < #line 404 "MDTreeParser.cpp"
452 > #line 453 "MDTreeParser.cpp"
453          
454          try {      // for error handling
455                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 411 | Line 460 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
460                  {
461                          ival=intConst(_t);
462                          _t = _retTree;
463 < #line 54 "MDTreeParser.g"
463 > #line 55 "MDTreeParser.g"
464                          blockStack.top()->assign(id->getText(), ival);
465 < #line 417 "MDTreeParser.cpp"
465 > #line 466 "MDTreeParser.cpp"
466                          break;
467                  }
468                  case NUM_FLOAT:
# Line 421 | Line 470 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
470                  {
471                          dval=floatConst(_t);
472                          _t = _retTree;
473 < #line 55 "MDTreeParser.g"
473 > #line 56 "MDTreeParser.g"
474                          blockStack.top()->assign(id->getText(), dval);
475 < #line 427 "MDTreeParser.cpp"
475 > #line 476 "MDTreeParser.cpp"
476                          break;
477                  }
478                  case ID:
# Line 431 | Line 480 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
480                          str1 = _t;
481                          match(_t,ID);
482                          _t = _t->getNextSibling();
483 < #line 56 "MDTreeParser.g"
483 > #line 57 "MDTreeParser.g"
484                          blockStack.top()->assign(id->getText(), str1->getText());
485 < #line 437 "MDTreeParser.cpp"
485 > #line 486 "MDTreeParser.cpp"
486                          break;
487                  }
488                  case StringLiteral:
# Line 441 | Line 490 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
490                          str2 = _t;
491                          match(_t,StringLiteral);
492                          _t = _t->getNextSibling();
493 < #line 57 "MDTreeParser.g"
493 > #line 58 "MDTreeParser.g"
494                          std::string s =  str2->getText();
495                          s = s.substr(1, s.length()-2);
496                          blockStack.top()->assign(id->getText(),s);
497                          
498 < #line 450 "MDTreeParser.cpp"
498 > #line 499 "MDTreeParser.cpp"
499                          break;
500                  }
501                  default:
# Line 464 | Line 513 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
513   }
514  
515   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
516 < #line 280 "MDTreeParser.g"
516 > #line 286 "MDTreeParser.g"
517          int ival;
518 < #line 470 "MDTreeParser.cpp"
518 > #line 519 "MDTreeParser.cpp"
519          ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
520          ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
521          ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 480 | Line 529 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
529                          i1 = _t;
530                          match(_t,NUM_INT);
531                          _t = _t->getNextSibling();
532 < #line 281 "MDTreeParser.g"
532 > #line 287 "MDTreeParser.g"
533                          ival = lexi_cast<int>(i1->getText());
534 < #line 486 "MDTreeParser.cpp"
534 > #line 535 "MDTreeParser.cpp"
535                          break;
536                  }
537                  case NUM_LONG:
# Line 490 | Line 539 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
539                          i2 = _t;
540                          match(_t,NUM_LONG);
541                          _t = _t->getNextSibling();
542 < #line 282 "MDTreeParser.g"
542 > #line 288 "MDTreeParser.g"
543                          ival = lexi_cast<int>(i2->getText());
544 < #line 496 "MDTreeParser.cpp"
544 > #line 545 "MDTreeParser.cpp"
545                          break;
546                  }
547                  default:
# Line 511 | Line 560 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
560   }
561  
562   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
563 < #line 294 "MDTreeParser.g"
563 > #line 300 "MDTreeParser.g"
564          RealType dval;
565 < #line 517 "MDTreeParser.cpp"
565 > #line 566 "MDTreeParser.cpp"
566          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
567          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
568          ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 527 | Line 576 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
576                          d1 = _t;
577                          match(_t,NUM_FLOAT);
578                          _t = _t->getNextSibling();
579 < #line 295 "MDTreeParser.g"
579 > #line 301 "MDTreeParser.g"
580                          dval = lexi_cast<RealType>(d1->getText());
581 < #line 533 "MDTreeParser.cpp"
581 > #line 582 "MDTreeParser.cpp"
582                          break;
583                  }
584                  case NUM_DOUBLE:
# Line 537 | Line 586 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
586                          d2 = _t;
587                          match(_t,NUM_DOUBLE);
588                          _t = _t->getNextSibling();
589 < #line 296 "MDTreeParser.g"
589 > #line 302 "MDTreeParser.g"
590                          dval = lexi_cast<RealType>(d2->getText());
591 < #line 543 "MDTreeParser.cpp"
591 > #line 592 "MDTreeParser.cpp"
592                          break;
593                  }
594                  default:
# Line 634 | Line 683 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
683  
684   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
685          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
686 < #line 106 "MDTreeParser.g"
686 > #line 112 "MDTreeParser.g"
687          
688          int index;
689          
690 < #line 642 "MDTreeParser.cpp"
690 > #line 691 "MDTreeParser.cpp"
691          
692          try {      // for error handling
693 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
694 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
693 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
694 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
695                  match(_t,ATOM);
696                  _t = _t->getFirstChild();
697                  index=intConst(_t);
698                  _t = _retTree;
699 < #line 110 "MDTreeParser.g"
699 > #line 116 "MDTreeParser.g"
700                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
701 < #line 653 "MDTreeParser.cpp"
701 > #line 702 "MDTreeParser.cpp"
702                  { // ( ... )*
703                  for (;;) {
704                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 659 | Line 708 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
708                                  _t = _retTree;
709                          }
710                          else {
711 <                                goto _loop36;
711 >                                goto _loop40;
712                          }
713                          
714                  }
715 <                _loop36:;
715 >                _loop40:;
716                  } // ( ... )*
717 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
717 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
718                  match(_t,ENDBLOCK);
719                  _t = _t->getNextSibling();
720 <                _t = __t34;
720 >                _t = __t38;
721                  _t = _t->getNextSibling();
722 < #line 112 "MDTreeParser.g"
722 > #line 118 "MDTreeParser.g"
723                  
724                  blockStack.top()->validate();
725                  blockStack.pop();
726                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
727                  currMoleculeStamp->addAtomStamp(currAtomStamp);
728                  
729 < #line 681 "MDTreeParser.cpp"
729 > #line 730 "MDTreeParser.cpp"
730          }
731          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
732                  reportError(ex);
# Line 691 | Line 740 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
740          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
741          
742          try {      // for error handling
743 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
744 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
743 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
744 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745                  match(_t,BOND);
746                  _t = _t->getFirstChild();
747 < #line 132 "MDTreeParser.g"
747 > #line 138 "MDTreeParser.g"
748                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
749 < #line 701 "MDTreeParser.cpp"
749 > #line 750 "MDTreeParser.cpp"
750                  { // ( ... )*
751                  for (;;) {
752                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 707 | Line 756 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
756                                  _t = _retTree;
757                          }
758                          else {
759 <                                goto _loop43;
759 >                                goto _loop47;
760                          }
761                          
762                  }
763 <                _loop43:;
763 >                _loop47:;
764                  } // ( ... )*
765 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
765 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
766                  match(_t,ENDBLOCK);
767                  _t = _t->getNextSibling();
768 <                _t = __t41;
768 >                _t = __t45;
769                  _t = _t->getNextSibling();
770 < #line 134 "MDTreeParser.g"
770 > #line 140 "MDTreeParser.g"
771                  
772                  blockStack.pop();
773                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
774                  currMoleculeStamp->addBondStamp(currBondStamp);
775                  
776 < #line 728 "MDTreeParser.cpp"
776 > #line 777 "MDTreeParser.cpp"
777          }
778          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
779                  reportError(ex);
# Line 738 | Line 787 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
787          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
788          
789          try {      // for error handling
790 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
791 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
790 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
791 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
792                  match(_t,BEND);
793                  _t = _t->getFirstChild();
794 < #line 150 "MDTreeParser.g"
794 > #line 156 "MDTreeParser.g"
795                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
796 < #line 748 "MDTreeParser.cpp"
796 > #line 797 "MDTreeParser.cpp"
797                  { // ( ... )*
798                  for (;;) {
799                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 754 | Line 803 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
803                                  _t = _retTree;
804                          }
805                          else {
806 <                                goto _loop49;
806 >                                goto _loop53;
807                          }
808                          
809                  }
810 <                _loop49:;
810 >                _loop53:;
811                  } // ( ... )*
812 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
812 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
813                  match(_t,ENDBLOCK);
814                  _t = _t->getNextSibling();
815 <                _t = __t47;
815 >                _t = __t51;
816                  _t = _t->getNextSibling();
817 < #line 152 "MDTreeParser.g"
817 > #line 158 "MDTreeParser.g"
818                  
819                  blockStack.top()->validate();
820                  blockStack.pop();
821                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
822                  currMoleculeStamp->addBendStamp(currBendStamp);
823                  
824 < #line 776 "MDTreeParser.cpp"
824 > #line 825 "MDTreeParser.cpp"
825          }
826          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
827                  reportError(ex);
# Line 786 | Line 835 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
835          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
836          
837          try {      // for error handling
838 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
839 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
838 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
839 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
840                  match(_t,TORSION);
841                  _t = _t->getFirstChild();
842 < #line 169 "MDTreeParser.g"
842 > #line 175 "MDTreeParser.g"
843                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
844 < #line 796 "MDTreeParser.cpp"
844 > #line 845 "MDTreeParser.cpp"
845                  { // ( ... )*
846                  for (;;) {
847                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 802 | Line 851 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
851                                  _t = _retTree;
852                          }
853                          else {
854 <                                goto _loop55;
854 >                                goto _loop59;
855                          }
856                          
857                  }
858 <                _loop55:;
858 >                _loop59:;
859                  } // ( ... )*
860 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
860 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
861                  match(_t,ENDBLOCK);
862                  _t = _t->getNextSibling();
863 <                _t = __t53;
863 >                _t = __t57;
864                  _t = _t->getNextSibling();
865 < #line 171 "MDTreeParser.g"
865 > #line 177 "MDTreeParser.g"
866                  
867                  blockStack.top()->validate();
868                  blockStack.pop();
869                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
870                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
871                  
872 < #line 824 "MDTreeParser.cpp"
872 > #line 873 "MDTreeParser.cpp"
873          }
874          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
875                  reportError(ex);
# Line 834 | Line 883 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
883          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
884          
885          try {      // for error handling
886 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
887 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
886 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
887 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
888                  match(_t,INVERSION);
889                  _t = _t->getFirstChild();
890 < #line 188 "MDTreeParser.g"
890 > #line 194 "MDTreeParser.g"
891                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
892 < #line 844 "MDTreeParser.cpp"
892 > #line 893 "MDTreeParser.cpp"
893                  { // ( ... )*
894                  for (;;) {
895                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 850 | Line 899 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
899                                  _t = _retTree;
900                          }
901                          else {
902 <                                goto _loop61;
902 >                                goto _loop65;
903                          }
904                          
905                  }
906 <                _loop61:;
906 >                _loop65:;
907                  } // ( ... )*
908 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
908 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
909                  match(_t,ENDBLOCK);
910                  _t = _t->getNextSibling();
911 <                _t = __t59;
911 >                _t = __t63;
912                  _t = _t->getNextSibling();
913 < #line 190 "MDTreeParser.g"
913 > #line 196 "MDTreeParser.g"
914                  
915                  blockStack.top()->validate();
916                  blockStack.pop();
917                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
918                  currMoleculeStamp->addInversionStamp(currInversionStamp);
919                  
920 < #line 872 "MDTreeParser.cpp"
920 > #line 921 "MDTreeParser.cpp"
921          }
922          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
923                  reportError(ex);
# Line 880 | Line 929 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
929  
930   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
931          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
932 < #line 207 "MDTreeParser.g"
932 > #line 213 "MDTreeParser.g"
933          
934          int index;
935          
936 < #line 888 "MDTreeParser.cpp"
936 > #line 937 "MDTreeParser.cpp"
937          
938          try {      // for error handling
939 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
940 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
939 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
940 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
941                  match(_t,RIGIDBODY);
942                  _t = _t->getFirstChild();
943                  index=intConst(_t);
944                  _t = _retTree;
945 < #line 211 "MDTreeParser.g"
945 > #line 217 "MDTreeParser.g"
946                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
947 < #line 899 "MDTreeParser.cpp"
947 > #line 948 "MDTreeParser.cpp"
948                  { // ( ... )*
949                  for (;;) {
950                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 905 | Line 954 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
954                                  _t = _retTree;
955                          }
956                          else {
957 <                                goto _loop67;
957 >                                goto _loop71;
958                          }
959                          
960                  }
961 <                _loop67:;
961 >                _loop71:;
962                  } // ( ... )*
963 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
963 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
964                  match(_t,ENDBLOCK);
965                  _t = _t->getNextSibling();
966 <                _t = __t65;
966 >                _t = __t69;
967                  _t = _t->getNextSibling();
968 < #line 213 "MDTreeParser.g"
968 > #line 219 "MDTreeParser.g"
969                  
970                  blockStack.top()->validate();
971                  blockStack.pop();
972                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
973                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
974                  
975 < #line 927 "MDTreeParser.cpp"
975 > #line 976 "MDTreeParser.cpp"
976          }
977          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
978                  reportError(ex);
# Line 937 | Line 986 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
986          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
987          
988          try {      // for error handling
989 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
990 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
989 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
990 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
991                  match(_t,CUTOFFGROUP);
992                  _t = _t->getFirstChild();
993 < #line 230 "MDTreeParser.g"
993 > #line 236 "MDTreeParser.g"
994                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
995 < #line 947 "MDTreeParser.cpp"
995 > #line 996 "MDTreeParser.cpp"
996                  { // ( ... )*
997                  for (;;) {
998                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 953 | Line 1002 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1002                                  _t = _retTree;
1003                          }
1004                          else {
1005 <                                goto _loop73;
1005 >                                goto _loop77;
1006                          }
1007                          
1008                  }
1009 <                _loop73:;
1009 >                _loop77:;
1010                  } // ( ... )*
1011 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1011 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1012                  match(_t,ENDBLOCK);
1013                  _t = _t->getNextSibling();
1014 <                _t = __t71;
1014 >                _t = __t75;
1015                  _t = _t->getNextSibling();
1016 < #line 232 "MDTreeParser.g"
1016 > #line 238 "MDTreeParser.g"
1017                  
1018                  blockStack.top()->validate();
1019                  blockStack.pop();
1020                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1021                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1022                  
1023 < #line 975 "MDTreeParser.cpp"
1023 > #line 1024 "MDTreeParser.cpp"
1024          }
1025          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1026                  reportError(ex);
# Line 983 | Line 1032 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1032  
1033   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1034          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1035 < #line 249 "MDTreeParser.g"
1035 > #line 255 "MDTreeParser.g"
1036          int ival;
1037 < #line 989 "MDTreeParser.cpp"
1037 > #line 1038 "MDTreeParser.cpp"
1038          
1039          try {      // for error handling
1040 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1041 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1040 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1041 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1042                  match(_t,FRAGMENT);
1043                  _t = _t->getFirstChild();
1044                  ival=intConst(_t);
1045                  _t = _retTree;
1046 < #line 250 "MDTreeParser.g"
1046 > #line 256 "MDTreeParser.g"
1047                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1048 < #line 1000 "MDTreeParser.cpp"
1048 > #line 1049 "MDTreeParser.cpp"
1049                  { // ( ... )*
1050                  for (;;) {
1051                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1006 | Line 1055 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1055                                  _t = _retTree;
1056                          }
1057                          else {
1058 <                                goto _loop79;
1058 >                                goto _loop83;
1059                          }
1060                          
1061                  }
1062 <                _loop79:;
1062 >                _loop83:;
1063                  } // ( ... )*
1064 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1064 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1065                  match(_t,ENDBLOCK);
1066                  _t = _t->getNextSibling();
1067 <                _t = __t77;
1067 >                _t = __t81;
1068                  _t = _t->getNextSibling();
1069 < #line 252 "MDTreeParser.g"
1069 > #line 258 "MDTreeParser.g"
1070                  
1071                  blockStack.top()->validate();
1072                  blockStack.pop();
1073                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1074                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1075                  
1076 < #line 1028 "MDTreeParser.cpp"
1076 > #line 1077 "MDTreeParser.cpp"
1077          }
1078          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1079                  reportError(ex);
# Line 1036 | Line 1085 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1085  
1086   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1087          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088 < #line 120 "MDTreeParser.g"
1088 > #line 126 "MDTreeParser.g"
1089          
1090          vector<RealType> dvec;
1091          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1092          
1093          
1094 < #line 1046 "MDTreeParser.cpp"
1094 > #line 1095 "MDTreeParser.cpp"
1095          
1096          try {      // for error handling
1097                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1056 | Line 1105 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1105                  }
1106                  case POSITION:
1107                  {
1108 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
1109 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1108 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t42 = _t;
1109 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1110                          match(_t,POSITION);
1111                          _t = _t->getFirstChild();
1112                          dvec=doubleNumberTuple(_t);
1113                          _t = _retTree;
1114 <                        _t = __t38;
1114 >                        _t = __t42;
1115                          _t = _t->getNextSibling();
1116 < #line 127 "MDTreeParser.g"
1116 > #line 133 "MDTreeParser.g"
1117                          currAtomStamp->setPosition(dvec);
1118 < #line 1070 "MDTreeParser.cpp"
1118 > #line 1119 "MDTreeParser.cpp"
1119                          break;
1120                  }
1121                  case ORIENTATION:
1122                  {
1123 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1124 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1123 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1124 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1125                          match(_t,ORIENTATION);
1126                          _t = _t->getFirstChild();
1127                          dvec=doubleNumberTuple(_t);
1128                          _t = _retTree;
1129 <                        _t = __t39;
1129 >                        _t = __t43;
1130                          _t = _t->getNextSibling();
1131 < #line 128 "MDTreeParser.g"
1131 > #line 134 "MDTreeParser.g"
1132                          currAtomStamp->setOrientation(dvec);
1133 < #line 1085 "MDTreeParser.cpp"
1133 > #line 1134 "MDTreeParser.cpp"
1134                          break;
1135                  }
1136                  default:
# Line 1099 | Line 1148 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1148   }
1149  
1150   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151 < #line 265 "MDTreeParser.g"
1151 > #line 271 "MDTreeParser.g"
1152          vector<RealType> dvec;
1153 < #line 1105 "MDTreeParser.cpp"
1153 > #line 1154 "MDTreeParser.cpp"
1154          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1155 < #line 265 "MDTreeParser.g"
1155 > #line 271 "MDTreeParser.g"
1156          
1157          RealType dval;
1158          
1159 < #line 1111 "MDTreeParser.cpp"
1159 > #line 1160 "MDTreeParser.cpp"
1160          
1161          try {      // for error handling
1162                  { // ( ... )+
1163 <                int _cnt83=0;
1163 >                int _cnt87=0;
1164                  for (;;) {
1165                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1166                                  _t = ASTNULL;
1167                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1168                                  dval=doubleNumber(_t);
1169                                  _t = _retTree;
1170 < #line 269 "MDTreeParser.g"
1170 > #line 275 "MDTreeParser.g"
1171                                  dvec.push_back(dval);
1172 < #line 1124 "MDTreeParser.cpp"
1172 > #line 1173 "MDTreeParser.cpp"
1173                          }
1174                          else {
1175 <                                if ( _cnt83>=1 ) { goto _loop83; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1175 >                                if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1176                          }
1177                          
1178 <                        _cnt83++;
1178 >                        _cnt87++;
1179                  }
1180 <                _loop83:;
1180 >                _loop87:;
1181                  }  // ( ... )+
1182          }
1183          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1142 | Line 1191 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1191  
1192   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1193          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1194 < #line 141 "MDTreeParser.g"
1194 > #line 147 "MDTreeParser.g"
1195          
1196          vector<int> ivec;
1197          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1198          
1199 < #line 1151 "MDTreeParser.cpp"
1199 > #line 1200 "MDTreeParser.cpp"
1200          
1201          try {      // for error handling
1202                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1161 | Line 1210 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1210                  }
1211                  case MEMBERS:
1212                  {
1213 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1214 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1213 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1214 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1215                          match(_t,MEMBERS);
1216                          _t = _t->getFirstChild();
1217                          ivec=inttuple(_t);
1218                          _t = _retTree;
1219 <                        _t = __t45;
1219 >                        _t = __t49;
1220                          _t = _t->getNextSibling();
1221 < #line 147 "MDTreeParser.g"
1221 > #line 153 "MDTreeParser.g"
1222                          currBondStamp->setMembers(ivec);
1223 < #line 1175 "MDTreeParser.cpp"
1223 > #line 1224 "MDTreeParser.cpp"
1224                          break;
1225                  }
1226                  default:
# Line 1189 | Line 1238 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1238   }
1239  
1240   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1241 < #line 272 "MDTreeParser.g"
1241 > #line 278 "MDTreeParser.g"
1242          vector<int> ivec;
1243 < #line 1195 "MDTreeParser.cpp"
1243 > #line 1244 "MDTreeParser.cpp"
1244          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1245 < #line 272 "MDTreeParser.g"
1245 > #line 278 "MDTreeParser.g"
1246          
1247          int ival;
1248          
1249 < #line 1201 "MDTreeParser.cpp"
1249 > #line 1250 "MDTreeParser.cpp"
1250          
1251          try {      // for error handling
1252                  { // ( ... )+
1253 <                int _cnt86=0;
1253 >                int _cnt90=0;
1254                  for (;;) {
1255                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1256                                  _t = ASTNULL;
1257                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1258                                  ival=intConst(_t);
1259                                  _t = _retTree;
1260 < #line 276 "MDTreeParser.g"
1260 > #line 282 "MDTreeParser.g"
1261                                  ivec.push_back(ival);
1262 < #line 1214 "MDTreeParser.cpp"
1262 > #line 1263 "MDTreeParser.cpp"
1263                          }
1264                          else {
1265 <                                if ( _cnt86>=1 ) { goto _loop86; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1265 >                                if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1266                          }
1267                          
1268 <                        _cnt86++;
1268 >                        _cnt90++;
1269                  }
1270 <                _loop86:;
1270 >                _loop90:;
1271                  }  // ( ... )+
1272          }
1273          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1232 | Line 1281 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1281  
1282   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1283          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1284 < #line 160 "MDTreeParser.g"
1284 > #line 166 "MDTreeParser.g"
1285          
1286          vector<int> ivec;
1287          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1288          
1289 < #line 1241 "MDTreeParser.cpp"
1289 > #line 1290 "MDTreeParser.cpp"
1290          
1291          try {      // for error handling
1292                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1251 | Line 1300 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1300                  }
1301                  case MEMBERS:
1302                  {
1303 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1304 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1303 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1304 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1305                          match(_t,MEMBERS);
1306                          _t = _t->getFirstChild();
1307                          ivec=inttuple(_t);
1308                          _t = _retTree;
1309 <                        _t = __t51;
1309 >                        _t = __t55;
1310                          _t = _t->getNextSibling();
1311 < #line 166 "MDTreeParser.g"
1311 > #line 172 "MDTreeParser.g"
1312                          currBendStamp->setMembers(ivec);
1313 < #line 1265 "MDTreeParser.cpp"
1313 > #line 1314 "MDTreeParser.cpp"
1314                          break;
1315                  }
1316                  default:
# Line 1280 | Line 1329 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1329  
1330   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1331          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1332 < #line 179 "MDTreeParser.g"
1332 > #line 185 "MDTreeParser.g"
1333          
1334          vector<int> ivec;
1335          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1336          
1337 < #line 1289 "MDTreeParser.cpp"
1337 > #line 1338 "MDTreeParser.cpp"
1338          
1339          try {      // for error handling
1340                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1299 | Line 1348 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1348                  }
1349                  case MEMBERS:
1350                  {
1351 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1352 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1351 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1352 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1353                          match(_t,MEMBERS);
1354                          _t = _t->getFirstChild();
1355                          ivec=inttuple(_t);
1356                          _t = _retTree;
1357 <                        _t = __t57;
1357 >                        _t = __t61;
1358                          _t = _t->getNextSibling();
1359 < #line 185 "MDTreeParser.g"
1359 > #line 191 "MDTreeParser.g"
1360                          currTorsionStamp->setMembers(ivec);
1361 < #line 1313 "MDTreeParser.cpp"
1361 > #line 1362 "MDTreeParser.cpp"
1362                          break;
1363                  }
1364                  default:
# Line 1328 | Line 1377 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1377  
1378   void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1379          ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380 < #line 198 "MDTreeParser.g"
1380 > #line 204 "MDTreeParser.g"
1381          
1382          int icent;
1383          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1384          
1385 < #line 1337 "MDTreeParser.cpp"
1385 > #line 1386 "MDTreeParser.cpp"
1386          
1387          try {      // for error handling
1388                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1347 | Line 1396 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1396                  }
1397                  case CENTER:
1398                  {
1399 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1400 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1399 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1400 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1401                          match(_t,CENTER);
1402                          _t = _t->getFirstChild();
1403                          icent=intConst(_t);
1404                          _t = _retTree;
1405 <                        _t = __t63;
1405 >                        _t = __t67;
1406                          _t = _t->getNextSibling();
1407 < #line 204 "MDTreeParser.g"
1407 > #line 210 "MDTreeParser.g"
1408                          currInversionStamp->setCenter(icent);
1409 < #line 1361 "MDTreeParser.cpp"
1409 > #line 1410 "MDTreeParser.cpp"
1410                          break;
1411                  }
1412                  default:
# Line 1376 | Line 1425 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1425  
1426   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1427          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1428 < #line 221 "MDTreeParser.g"
1428 > #line 227 "MDTreeParser.g"
1429          
1430          vector<int> ivec;
1431          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1432          
1433 < #line 1385 "MDTreeParser.cpp"
1433 > #line 1434 "MDTreeParser.cpp"
1434          
1435          try {      // for error handling
1436                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1395 | Line 1444 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1444                  }
1445                  case MEMBERS:
1446                  {
1447 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1448 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1447 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t73 = _t;
1448 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1449                          match(_t,MEMBERS);
1450                          _t = _t->getFirstChild();
1451                          ivec=inttuple(_t);
1452                          _t = _retTree;
1453 <                        _t = __t69;
1453 >                        _t = __t73;
1454                          _t = _t->getNextSibling();
1455 < #line 227 "MDTreeParser.g"
1455 > #line 233 "MDTreeParser.g"
1456                          currRigidBodyStamp->setMembers(ivec);
1457 < #line 1409 "MDTreeParser.cpp"
1457 > #line 1458 "MDTreeParser.cpp"
1458                          break;
1459                  }
1460                  default:
# Line 1424 | Line 1473 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1473  
1474   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1475          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1476 < #line 240 "MDTreeParser.g"
1476 > #line 246 "MDTreeParser.g"
1477          
1478          vector<int> ivec;
1479          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1480          
1481 < #line 1433 "MDTreeParser.cpp"
1481 > #line 1482 "MDTreeParser.cpp"
1482          
1483          try {      // for error handling
1484                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1443 | Line 1492 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1492                  }
1493                  case MEMBERS:
1494                  {
1495 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1496 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1495 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t79 = _t;
1496 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1497                          match(_t,MEMBERS);
1498                          _t = _t->getFirstChild();
1499                          ivec=inttuple(_t);
1500                          _t = _retTree;
1501 <                        _t = __t75;
1501 >                        _t = __t79;
1502                          _t = _t->getNextSibling();
1503 < #line 246 "MDTreeParser.g"
1503 > #line 252 "MDTreeParser.g"
1504                          currCutoffGroupStamp->setMembers(ivec);
1505 < #line 1457 "MDTreeParser.cpp"
1505 > #line 1506 "MDTreeParser.cpp"
1506                          break;
1507                  }
1508                  default:
# Line 1486 | Line 1535 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1535   }
1536  
1537   RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538 < #line 286 "MDTreeParser.g"
1538 > #line 292 "MDTreeParser.g"
1539          RealType dval;
1540 < #line 1492 "MDTreeParser.cpp"
1540 > #line 1541 "MDTreeParser.cpp"
1541          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1542          ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1543          ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 1503 | Line 1552 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1552                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1553                          intConst(_t);
1554                          _t = _retTree;
1555 < #line 288 "MDTreeParser.g"
1555 > #line 294 "MDTreeParser.g"
1556                          dval = lexi_cast<RealType>(ic->getText());
1557 < #line 1509 "MDTreeParser.cpp"
1557 > #line 1558 "MDTreeParser.cpp"
1558                          break;
1559                  }
1560                  case NUM_FLOAT:
# Line 1514 | Line 1563 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1563                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1564                          floatConst(_t);
1565                          _t = _retTree;
1566 < #line 289 "MDTreeParser.g"
1566 > #line 295 "MDTreeParser.g"
1567                          dval = lexi_cast<RealType>(fc->getText());
1568 < #line 1520 "MDTreeParser.cpp"
1568 > #line 1569 "MDTreeParser.cpp"
1569                          break;
1570                  }
1571                  default:
# Line 1560 | Line 1609 | const char* MDTreeParser::tokenNames[] = {
1609          "\"orientation\"",
1610          "\"flucQ\"",
1611          "\"RNEMD\"",
1612 +        "\"minimizer\"",
1613          "ENDBLOCK",
1614          "ID",
1615          "ASSIGNEQUAL",
# Line 1597 | Line 1647 | const char* MDTreeParser::tokenNames[] = {
1647          0
1648   };
1649  
1650 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 19923184UL, 0UL, 0UL, 0UL };
1651 < // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ASSIGNEQUAL
1650 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1651 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1652 > // ASSIGNEQUAL
1653   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1654 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1654 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1655   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1656   // "fragment" ASSIGNEQUAL
1657   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Diff Legend

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