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 1775 by gezelter, Wed Jun 6 02:18:54 2012 UTC vs.
Revision 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20110725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20120725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 141 | Line 141 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
141          ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
142          
143          try {      // for error handling
144 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
144 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
145                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146                  match(_t,COMPONENT);
147                  _t = _t->getFirstChild();
148 < #line 65 "MDTreeParser.g"
148 > #line 72 "MDTreeParser.g"
149                  Component* currComponet = new Component(); blockStack.push(currComponet);
150   #line 151 "MDTreeParser.cpp"
151                  { // ( ... )*
# Line 157 | Line 157 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
157                                  _t = _retTree;
158                          }
159                          else {
160 <                                goto _loop11;
160 >                                goto _loop12;
161                          }
162                          
163                  }
164 <                _loop11:;
164 >                _loop12:;
165                  } // ( ... )*
166                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167                  match(_t,ENDBLOCK);
168                  _t = _t->getNextSibling();
169 <                _t = __t9;
169 >                _t = __t10;
170                  _t = _t->getNextSibling();
171 < #line 67 "MDTreeParser.g"
171 > #line 74 "MDTreeParser.g"
172                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173   #line 174 "MDTreeParser.cpp"
174          }
# Line 184 | 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 __t33 = _t;
187 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
188                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189                  match(_t,MOLECULE);
190                  _t = _t->getFirstChild();
191 < #line 96 "MDTreeParser.g"
191 > #line 103 "MDTreeParser.g"
192                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193   #line 194 "MDTreeParser.cpp"
194                  { // ( ... )*
# Line 200 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200                                  _t = _retTree;
201                          }
202                          else {
203 <                                goto _loop35;
203 >                                goto _loop36;
204                          }
205                          
206                  }
207 <                _loop35:;
207 >                _loop36:;
208                  } // ( ... )*
209                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210                  match(_t,ENDBLOCK);
211                  _t = _t->getNextSibling();
212 <                _t = __t33;
212 >                _t = __t34;
213                  _t = _t->getNextSibling();
214 < #line 98 "MDTreeParser.g"
214 > #line 105 "MDTreeParser.g"
215                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216   #line 217 "MDTreeParser.cpp"
217          }
# Line 227 | Line 227 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
227          ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
228          
229          try {      // for error handling
230 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
230 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t;
231                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232                  match(_t,ZCONSTRAINT);
233                  _t = _t->getFirstChild();
234 < #line 70 "MDTreeParser.g"
234 > #line 77 "MDTreeParser.g"
235                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236   #line 237 "MDTreeParser.cpp"
237                  { // ( ... )*
# Line 243 | Line 243 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
243                                  _t = _retTree;
244                          }
245                          else {
246 <                                goto _loop15;
246 >                                goto _loop16;
247                          }
248                          
249                  }
250 <                _loop15:;
250 >                _loop16:;
251                  } // ( ... )*
252                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253                  match(_t,ENDBLOCK);
254                  _t = _t->getNextSibling();
255 <                _t = __t13;
255 >                _t = __t14;
256                  _t = _t->getNextSibling();
257 < #line 72 "MDTreeParser.g"
257 > #line 79 "MDTreeParser.g"
258                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259   #line 260 "MDTreeParser.cpp"
260          }
# Line 270 | Line 270 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
270          ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
271          
272          try {      // for error handling
273 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
273 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t18 = _t;
274                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275                  match(_t,RESTRAINT);
276                  _t = _t->getFirstChild();
277 < #line 75 "MDTreeParser.g"
277 > #line 82 "MDTreeParser.g"
278                  RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279   #line 280 "MDTreeParser.cpp"
280                  { // ( ... )*
# Line 286 | Line 286 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
286                                  _t = _retTree;
287                          }
288                          else {
289 <                                goto _loop19;
289 >                                goto _loop20;
290                          }
291                          
292                  }
293 <                _loop19:;
293 >                _loop20:;
294                  } // ( ... )*
295                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296                  match(_t,ENDBLOCK);
297                  _t = _t->getNextSibling();
298 <                _t = __t17;
298 >                _t = __t18;
299                  _t = _t->getNextSibling();
300 < #line 77 "MDTreeParser.g"
300 > #line 84 "MDTreeParser.g"
301                  blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302   #line 303 "MDTreeParser.cpp"
303          }
# Line 313 | Line 313 | void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
313          ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
314          
315          try {      // for error handling
316 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
316 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
317                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318                  match(_t,FLUCQ);
319                  _t = _t->getFirstChild();
320 < #line 80 "MDTreeParser.g"
320 > #line 87 "MDTreeParser.g"
321                  FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322   #line 323 "MDTreeParser.cpp"
323                  { // ( ... )*
# Line 329 | Line 329 | void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antl
329                                  _t = _retTree;
330                          }
331                          else {
332 <                                goto _loop23;
332 >                                goto _loop24;
333                          }
334                          
335                  }
336 <                _loop23:;
336 >                _loop24:;
337                  } // ( ... )*
338                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339                  match(_t,ENDBLOCK);
340                  _t = _t->getNextSibling();
341 <                _t = __t21;
341 >                _t = __t22;
342                  _t = _t->getNextSibling();
343 < #line 82 "MDTreeParser.g"
343 > #line 89 "MDTreeParser.g"
344                  blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345   #line 346 "MDTreeParser.cpp"
346          }
# Line 356 | Line 356 | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
356          ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
357          
358          try {      // for error handling
359 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t25 = _t;
359 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
360                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361                  match(_t,RNEMD);
362                  _t = _t->getFirstChild();
363 < #line 85 "MDTreeParser.g"
363 > #line 92 "MDTreeParser.g"
364                  RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365   #line 366 "MDTreeParser.cpp"
366                  { // ( ... )*
# Line 372 | Line 372 | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antl
372                                  _t = _retTree;
373                          }
374                          else {
375 <                                goto _loop27;
375 >                                goto _loop28;
376                          }
377                          
378                  }
379 <                _loop27:;
379 >                _loop28:;
380                  } // ( ... )*
381                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382                  match(_t,ENDBLOCK);
383                  _t = _t->getNextSibling();
384 <                _t = __t25;
384 >                _t = __t26;
385                  _t = _t->getNextSibling();
386 < #line 87 "MDTreeParser.g"
386 > #line 94 "MDTreeParser.g"
387                  blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388   #line 389 "MDTreeParser.cpp"
389          }
# Line 399 | Line 399 | void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(
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;
402 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
403                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404                  match(_t,MINIMIZER);
405                  _t = _t->getFirstChild();
406 < #line 90 "MDTreeParser.g"
406 > #line 97 "MDTreeParser.g"
407                  MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408   #line 409 "MDTreeParser.cpp"
409                  { // ( ... )*
# Line 415 | Line 415 | void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(
415                                  _t = _retTree;
416                          }
417                          else {
418 <                                goto _loop31;
418 >                                goto _loop32;
419                          }
420                          
421                  }
422 <                _loop31:;
422 >                _loop32:;
423                  } // ( ... )*
424                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425                  match(_t,ENDBLOCK);
426                  _t = _t->getNextSibling();
427 <                _t = __t29;
427 >                _t = __t30;
428                  _t = _t->getNextSibling();
429 < #line 92 "MDTreeParser.g"
429 > #line 99 "MDTreeParser.g"
430                  blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431   #line 432 "MDTreeParser.cpp"
432          }
# Line 447 | Line 447 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
447   #line 50 "MDTreeParser.g"
448          
449          int ival;
450 <        RealType dval;
450 >        RealType dval, x, y, z;
451 >        Vector3d dvec;
452          
453 < #line 453 "MDTreeParser.cpp"
453 > #line 454 "MDTreeParser.cpp"
454          
455          try {      // for error handling
456                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 460 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
461                  {
462                          ival=intConst(_t);
463                          _t = _retTree;
464 < #line 55 "MDTreeParser.g"
464 > #line 56 "MDTreeParser.g"
465                          blockStack.top()->assign(id->getText(), ival);
466 < #line 466 "MDTreeParser.cpp"
466 > #line 467 "MDTreeParser.cpp"
467                          break;
468                  }
469                  case NUM_FLOAT:
# Line 470 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
471                  {
472                          dval=floatConst(_t);
473                          _t = _retTree;
474 < #line 56 "MDTreeParser.g"
474 > #line 57 "MDTreeParser.g"
475                          blockStack.top()->assign(id->getText(), dval);
476 < #line 476 "MDTreeParser.cpp"
476 > #line 477 "MDTreeParser.cpp"
477                          break;
478                  }
479 +                case LPAREN:
480 +                {
481 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
482 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
483 +                        match(_t,LPAREN);
484 +                        _t = _t->getFirstChild();
485 +                        x=doubleNumber(_t);
486 +                        _t = _retTree;
487 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
488 +                        match(_t,COMMA);
489 +                        _t = _t->getNextSibling();
490 +                        y=doubleNumber(_t);
491 +                        _t = _retTree;
492 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
493 +                        match(_t,COMMA);
494 +                        _t = _t->getNextSibling();
495 +                        z=doubleNumber(_t);
496 +                        _t = _retTree;
497 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
498 +                        match(_t,RPAREN);
499 +                        _t = _t->getNextSibling();
500 +                        _t = __t8;
501 +                        _t = _t->getNextSibling();
502 + #line 59 "MDTreeParser.g"
503 +                        dvec.x() = x;
504 +                        dvec.y() = y;
505 +                        dvec.z() = z;
506 +                        blockStack.top()->assign(id->getText(), dvec);
507 +                        
508 + #line 509 "MDTreeParser.cpp"
509 +                        break;
510 +                }
511                  case ID:
512                  {
513                          str1 = _t;
514                          match(_t,ID);
515                          _t = _t->getNextSibling();
516 < #line 57 "MDTreeParser.g"
516 > #line 64 "MDTreeParser.g"
517                          blockStack.top()->assign(id->getText(), str1->getText());
518 < #line 486 "MDTreeParser.cpp"
518 > #line 519 "MDTreeParser.cpp"
519                          break;
520                  }
521                  case StringLiteral:
# Line 490 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523                          str2 = _t;
524                          match(_t,StringLiteral);
525                          _t = _t->getNextSibling();
526 < #line 58 "MDTreeParser.g"
526 > #line 65 "MDTreeParser.g"
527                          std::string s =  str2->getText();
528                          s = s.substr(1, s.length()-2);
529                          blockStack.top()->assign(id->getText(),s);
530                          
531 < #line 499 "MDTreeParser.cpp"
531 > #line 532 "MDTreeParser.cpp"
532                          break;
533                  }
534                  default:
# Line 513 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546   }
547  
548   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549 < #line 286 "MDTreeParser.g"
549 > #line 294 "MDTreeParser.g"
550          int ival;
551 < #line 519 "MDTreeParser.cpp"
551 > #line 552 "MDTreeParser.cpp"
552          ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
553          ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
554          ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 529 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562                          i1 = _t;
563                          match(_t,NUM_INT);
564                          _t = _t->getNextSibling();
565 < #line 287 "MDTreeParser.g"
565 > #line 295 "MDTreeParser.g"
566                          ival = lexi_cast<int>(i1->getText());
567 < #line 535 "MDTreeParser.cpp"
567 > #line 568 "MDTreeParser.cpp"
568                          break;
569                  }
570                  case NUM_LONG:
# Line 539 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572                          i2 = _t;
573                          match(_t,NUM_LONG);
574                          _t = _t->getNextSibling();
575 < #line 288 "MDTreeParser.g"
575 > #line 296 "MDTreeParser.g"
576                          ival = lexi_cast<int>(i2->getText());
577 < #line 545 "MDTreeParser.cpp"
577 > #line 578 "MDTreeParser.cpp"
578                          break;
579                  }
580                  default:
# Line 560 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593   }
594  
595   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596 < #line 300 "MDTreeParser.g"
596 > #line 306 "MDTreeParser.g"
597          RealType dval;
598 < #line 566 "MDTreeParser.cpp"
598 > #line 599 "MDTreeParser.cpp"
599          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
600          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
601          ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 576 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609                          d1 = _t;
610                          match(_t,NUM_FLOAT);
611                          _t = _t->getNextSibling();
612 < #line 301 "MDTreeParser.g"
612 > #line 307 "MDTreeParser.g"
613                          dval = lexi_cast<RealType>(d1->getText());
614 < #line 582 "MDTreeParser.cpp"
614 > #line 615 "MDTreeParser.cpp"
615                          break;
616                  }
617                  case NUM_DOUBLE:
# Line 586 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619                          d2 = _t;
620                          match(_t,NUM_DOUBLE);
621                          _t = _t->getNextSibling();
622 < #line 302 "MDTreeParser.g"
622 > #line 308 "MDTreeParser.g"
623                          dval = lexi_cast<RealType>(d2->getText());
624 < #line 592 "MDTreeParser.cpp"
624 > #line 625 "MDTreeParser.cpp"
625 >                        break;
626 >                }
627 >                default:
628 >                {
629 >                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
630 >                }
631 >                }
632 >        }
633 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
634 >                reportError(ex);
635 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
636 >                        _t = _t->getNextSibling();
637 >        }
638 >        _retTree = _t;
639 >        return dval;
640 > }
641 >
642 > RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643 > #line 300 "MDTreeParser.g"
644 >        RealType dval;
645 > #line 646 "MDTreeParser.cpp"
646 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647 >        ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
648 >        ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
649 >        
650 >        try {      // for error handling
651 >                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
652 >                        _t = ASTNULL;
653 >                switch ( _t->getType()) {
654 >                case NUM_INT:
655 >                case NUM_LONG:
656 >                {
657 >                        ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658 >                        intConst(_t);
659 >                        _t = _retTree;
660 > #line 301 "MDTreeParser.g"
661 >                        dval = lexi_cast<RealType>(ic->getText());
662 > #line 663 "MDTreeParser.cpp"
663                          break;
664                  }
665 +                case NUM_FLOAT:
666 +                case NUM_DOUBLE:
667 +                {
668 +                        fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669 +                        floatConst(_t);
670 +                        _t = _retTree;
671 + #line 302 "MDTreeParser.g"
672 +                        dval = lexi_cast<RealType>(fc->getText());
673 + #line 674 "MDTreeParser.cpp"
674 +                        break;
675 +                }
676                  default:
677                  {
678                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 683 | Line 765 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
765  
766   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
767          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768 < #line 112 "MDTreeParser.g"
768 > #line 119 "MDTreeParser.g"
769          
770          int index;
771          
772 < #line 691 "MDTreeParser.cpp"
772 > #line 773 "MDTreeParser.cpp"
773          
774          try {      // for error handling
775 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
775 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
776 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
777                  match(_t,ATOM);
778                  _t = _t->getFirstChild();
779                  index=intConst(_t);
780                  _t = _retTree;
781 < #line 116 "MDTreeParser.g"
781 > #line 123 "MDTreeParser.g"
782                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783 < #line 702 "MDTreeParser.cpp"
783 > #line 784 "MDTreeParser.cpp"
784                  { // ( ... )*
785                  for (;;) {
786                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 708 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790                                  _t = _retTree;
791                          }
792                          else {
793 <                                goto _loop40;
793 >                                goto _loop41;
794                          }
795                          
796                  }
797 <                _loop40:;
797 >                _loop41:;
798                  } // ( ... )*
799 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
799 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800                  match(_t,ENDBLOCK);
801                  _t = _t->getNextSibling();
802 <                _t = __t38;
802 >                _t = __t39;
803                  _t = _t->getNextSibling();
804 < #line 118 "MDTreeParser.g"
804 > #line 125 "MDTreeParser.g"
805                  
806                  blockStack.top()->validate();
807                  blockStack.pop();
808                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
809                  currMoleculeStamp->addAtomStamp(currAtomStamp);
810                  
811 < #line 730 "MDTreeParser.cpp"
811 > #line 812 "MDTreeParser.cpp"
812          }
813          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814                  reportError(ex);
# Line 740 | Line 822 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
822          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
823          
824          try {      // for error handling
825 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
826 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
825 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
826 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
827                  match(_t,BOND);
828                  _t = _t->getFirstChild();
829 < #line 138 "MDTreeParser.g"
829 > #line 145 "MDTreeParser.g"
830                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831 < #line 750 "MDTreeParser.cpp"
831 > #line 832 "MDTreeParser.cpp"
832                  { // ( ... )*
833                  for (;;) {
834                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 756 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838                                  _t = _retTree;
839                          }
840                          else {
841 <                                goto _loop47;
841 >                                goto _loop48;
842                          }
843                          
844                  }
845 <                _loop47:;
845 >                _loop48:;
846                  } // ( ... )*
847 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
847 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848                  match(_t,ENDBLOCK);
849                  _t = _t->getNextSibling();
850 <                _t = __t45;
850 >                _t = __t46;
851                  _t = _t->getNextSibling();
852 < #line 140 "MDTreeParser.g"
852 > #line 147 "MDTreeParser.g"
853                  
854                  blockStack.pop();
855                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
856                  currMoleculeStamp->addBondStamp(currBondStamp);
857                  
858 < #line 777 "MDTreeParser.cpp"
858 > #line 859 "MDTreeParser.cpp"
859          }
860          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861                  reportError(ex);
# Line 787 | Line 869 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
869          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
870          
871          try {      // for error handling
872 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
873 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
872 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
873 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
874                  match(_t,BEND);
875                  _t = _t->getFirstChild();
876 < #line 156 "MDTreeParser.g"
876 > #line 163 "MDTreeParser.g"
877                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878 < #line 797 "MDTreeParser.cpp"
878 > #line 879 "MDTreeParser.cpp"
879                  { // ( ... )*
880                  for (;;) {
881                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 803 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885                                  _t = _retTree;
886                          }
887                          else {
888 <                                goto _loop53;
888 >                                goto _loop54;
889                          }
890                          
891                  }
892 <                _loop53:;
892 >                _loop54:;
893                  } // ( ... )*
894 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
894 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895                  match(_t,ENDBLOCK);
896                  _t = _t->getNextSibling();
897 <                _t = __t51;
897 >                _t = __t52;
898                  _t = _t->getNextSibling();
899 < #line 158 "MDTreeParser.g"
899 > #line 165 "MDTreeParser.g"
900                  
901                  blockStack.top()->validate();
902                  blockStack.pop();
903                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
904                  currMoleculeStamp->addBendStamp(currBendStamp);
905                  
906 < #line 825 "MDTreeParser.cpp"
906 > #line 907 "MDTreeParser.cpp"
907          }
908          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909                  reportError(ex);
# Line 835 | Line 917 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
917          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
918          
919          try {      // for error handling
920 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
921 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
920 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
921 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
922                  match(_t,TORSION);
923                  _t = _t->getFirstChild();
924 < #line 175 "MDTreeParser.g"
924 > #line 182 "MDTreeParser.g"
925                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926 < #line 845 "MDTreeParser.cpp"
926 > #line 927 "MDTreeParser.cpp"
927                  { // ( ... )*
928                  for (;;) {
929                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 851 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933                                  _t = _retTree;
934                          }
935                          else {
936 <                                goto _loop59;
936 >                                goto _loop60;
937                          }
938                          
939                  }
940 <                _loop59:;
940 >                _loop60:;
941                  } // ( ... )*
942 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
942 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943                  match(_t,ENDBLOCK);
944                  _t = _t->getNextSibling();
945 <                _t = __t57;
945 >                _t = __t58;
946                  _t = _t->getNextSibling();
947 < #line 177 "MDTreeParser.g"
947 > #line 184 "MDTreeParser.g"
948                  
949                  blockStack.top()->validate();
950                  blockStack.pop();
951                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
952                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
953                  
954 < #line 873 "MDTreeParser.cpp"
954 > #line 955 "MDTreeParser.cpp"
955          }
956          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957                  reportError(ex);
# Line 883 | Line 965 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
965          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
966          
967          try {      // for error handling
968 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
969 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
968 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
969 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
970                  match(_t,INVERSION);
971                  _t = _t->getFirstChild();
972 < #line 194 "MDTreeParser.g"
972 > #line 201 "MDTreeParser.g"
973                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974 < #line 893 "MDTreeParser.cpp"
974 > #line 975 "MDTreeParser.cpp"
975                  { // ( ... )*
976                  for (;;) {
977                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 899 | Line 981 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
981                                  _t = _retTree;
982                          }
983                          else {
984 <                                goto _loop65;
984 >                                goto _loop66;
985                          }
986                          
987                  }
988 <                _loop65:;
988 >                _loop66:;
989                  } // ( ... )*
990 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
990 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991                  match(_t,ENDBLOCK);
992                  _t = _t->getNextSibling();
993 <                _t = __t63;
993 >                _t = __t64;
994                  _t = _t->getNextSibling();
995 < #line 196 "MDTreeParser.g"
995 > #line 203 "MDTreeParser.g"
996                  
997                  blockStack.top()->validate();
998                  blockStack.pop();
999                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1000                  currMoleculeStamp->addInversionStamp(currInversionStamp);
1001                  
1002 < #line 921 "MDTreeParser.cpp"
1002 > #line 1003 "MDTreeParser.cpp"
1003          }
1004          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005                  reportError(ex);
# Line 929 | Line 1011 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1011  
1012   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014 < #line 213 "MDTreeParser.g"
1014 > #line 220 "MDTreeParser.g"
1015          
1016          int index;
1017          
1018 < #line 937 "MDTreeParser.cpp"
1018 > #line 1019 "MDTreeParser.cpp"
1019          
1020          try {      // for error handling
1021 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1022 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1021 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1022 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023                  match(_t,RIGIDBODY);
1024                  _t = _t->getFirstChild();
1025                  index=intConst(_t);
1026                  _t = _retTree;
1027 < #line 217 "MDTreeParser.g"
1027 > #line 224 "MDTreeParser.g"
1028                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029 < #line 948 "MDTreeParser.cpp"
1029 > #line 1030 "MDTreeParser.cpp"
1030                  { // ( ... )*
1031                  for (;;) {
1032                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 954 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036                                  _t = _retTree;
1037                          }
1038                          else {
1039 <                                goto _loop71;
1039 >                                goto _loop72;
1040                          }
1041                          
1042                  }
1043 <                _loop71:;
1043 >                _loop72:;
1044                  } // ( ... )*
1045 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1045 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046                  match(_t,ENDBLOCK);
1047                  _t = _t->getNextSibling();
1048 <                _t = __t69;
1048 >                _t = __t70;
1049                  _t = _t->getNextSibling();
1050 < #line 219 "MDTreeParser.g"
1050 > #line 226 "MDTreeParser.g"
1051                  
1052                  blockStack.top()->validate();
1053                  blockStack.pop();
1054                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1055                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1056                  
1057 < #line 976 "MDTreeParser.cpp"
1057 > #line 1058 "MDTreeParser.cpp"
1058          }
1059          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060                  reportError(ex);
# Line 986 | Line 1068 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1068          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069          
1070          try {      // for error handling
1071 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1072 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1071 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1072 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073                  match(_t,CUTOFFGROUP);
1074                  _t = _t->getFirstChild();
1075 < #line 236 "MDTreeParser.g"
1075 > #line 243 "MDTreeParser.g"
1076                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077 < #line 996 "MDTreeParser.cpp"
1077 > #line 1078 "MDTreeParser.cpp"
1078                  { // ( ... )*
1079                  for (;;) {
1080                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1002 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084                                  _t = _retTree;
1085                          }
1086                          else {
1087 <                                goto _loop77;
1087 >                                goto _loop78;
1088                          }
1089                          
1090                  }
1091 <                _loop77:;
1091 >                _loop78:;
1092                  } // ( ... )*
1093 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1093 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094                  match(_t,ENDBLOCK);
1095                  _t = _t->getNextSibling();
1096 <                _t = __t75;
1096 >                _t = __t76;
1097                  _t = _t->getNextSibling();
1098 < #line 238 "MDTreeParser.g"
1098 > #line 245 "MDTreeParser.g"
1099                  
1100                  blockStack.top()->validate();
1101                  blockStack.pop();
1102                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1103                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1104                  
1105 < #line 1024 "MDTreeParser.cpp"
1105 > #line 1106 "MDTreeParser.cpp"
1106          }
1107          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108                  reportError(ex);
# Line 1032 | Line 1114 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1114  
1115   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117 < #line 255 "MDTreeParser.g"
1117 > #line 262 "MDTreeParser.g"
1118          int ival;
1119 < #line 1038 "MDTreeParser.cpp"
1119 > #line 1120 "MDTreeParser.cpp"
1120          
1121          try {      // for error handling
1122 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1123 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1122 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1123 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124                  match(_t,FRAGMENT);
1125                  _t = _t->getFirstChild();
1126                  ival=intConst(_t);
1127                  _t = _retTree;
1128 < #line 256 "MDTreeParser.g"
1128 > #line 263 "MDTreeParser.g"
1129                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130 < #line 1049 "MDTreeParser.cpp"
1130 > #line 1131 "MDTreeParser.cpp"
1131                  { // ( ... )*
1132                  for (;;) {
1133                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1055 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137                                  _t = _retTree;
1138                          }
1139                          else {
1140 <                                goto _loop83;
1140 >                                goto _loop84;
1141                          }
1142                          
1143                  }
1144 <                _loop83:;
1144 >                _loop84:;
1145                  } // ( ... )*
1146 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1146 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147                  match(_t,ENDBLOCK);
1148                  _t = _t->getNextSibling();
1149 <                _t = __t81;
1149 >                _t = __t82;
1150                  _t = _t->getNextSibling();
1151 < #line 258 "MDTreeParser.g"
1151 > #line 265 "MDTreeParser.g"
1152                  
1153                  blockStack.top()->validate();
1154                  blockStack.pop();
1155                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1156                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1157                  
1158 < #line 1077 "MDTreeParser.cpp"
1158 > #line 1159 "MDTreeParser.cpp"
1159          }
1160          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161                  reportError(ex);
# Line 1085 | Line 1167 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1167  
1168   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1169          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170 < #line 126 "MDTreeParser.g"
1170 > #line 133 "MDTreeParser.g"
1171          
1172          vector<RealType> dvec;
1173          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174          
1175          
1176 < #line 1095 "MDTreeParser.cpp"
1176 > #line 1177 "MDTreeParser.cpp"
1177          
1178          try {      // for error handling
1179                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1105 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187                  }
1188                  case POSITION:
1189                  {
1190 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t42 = _t;
1191 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1190 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1191 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1192                          match(_t,POSITION);
1193                          _t = _t->getFirstChild();
1194                          dvec=doubleNumberTuple(_t);
1195                          _t = _retTree;
1196 <                        _t = __t42;
1196 >                        _t = __t43;
1197                          _t = _t->getNextSibling();
1198 < #line 133 "MDTreeParser.g"
1198 > #line 140 "MDTreeParser.g"
1199                          currAtomStamp->setPosition(dvec);
1200 < #line 1119 "MDTreeParser.cpp"
1200 > #line 1201 "MDTreeParser.cpp"
1201                          break;
1202                  }
1203                  case ORIENTATION:
1204                  {
1205 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1206 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1205 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1206 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1207                          match(_t,ORIENTATION);
1208                          _t = _t->getFirstChild();
1209                          dvec=doubleNumberTuple(_t);
1210                          _t = _retTree;
1211 <                        _t = __t43;
1212 <                        _t = _t->getNextSibling();
1213 < #line 134 "MDTreeParser.g"
1211 >                        _t = __t44;
1212 >                        _t = _t->getNextSibling();
1213 > #line 141 "MDTreeParser.g"
1214                          currAtomStamp->setOrientation(dvec);
1215 < #line 1134 "MDTreeParser.cpp"
1215 > #line 1216 "MDTreeParser.cpp"
1216                          break;
1217                  }
1218                  default:
# Line 1148 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230   }
1231  
1232   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 < #line 271 "MDTreeParser.g"
1233 > #line 278 "MDTreeParser.g"
1234          vector<RealType> dvec;
1235 < #line 1154 "MDTreeParser.cpp"
1235 > #line 1236 "MDTreeParser.cpp"
1236          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237 < #line 271 "MDTreeParser.g"
1237 > #line 278 "MDTreeParser.g"
1238          
1239          RealType dval;
1240          
1241 < #line 1160 "MDTreeParser.cpp"
1241 > #line 1242 "MDTreeParser.cpp"
1242          
1243          try {      // for error handling
1244                  { // ( ... )+
1245 <                int _cnt87=0;
1245 >                int _cnt88=0;
1246                  for (;;) {
1247                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248                                  _t = ASTNULL;
1249                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250                                  dval=doubleNumber(_t);
1251                                  _t = _retTree;
1252 < #line 275 "MDTreeParser.g"
1252 > #line 282 "MDTreeParser.g"
1253                                  dvec.push_back(dval);
1254 < #line 1173 "MDTreeParser.cpp"
1254 > #line 1255 "MDTreeParser.cpp"
1255                          }
1256                          else {
1257 <                                if ( _cnt87>=1 ) { goto _loop87; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1257 >                                if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258                          }
1259                          
1260 <                        _cnt87++;
1260 >                        _cnt88++;
1261                  }
1262 <                _loop87:;
1262 >                _loop88:;
1263                  }  // ( ... )+
1264          }
1265          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1191 | Line 1273 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1273  
1274   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1275          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276 < #line 147 "MDTreeParser.g"
1276 > #line 154 "MDTreeParser.g"
1277          
1278          vector<int> ivec;
1279          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280          
1281 < #line 1200 "MDTreeParser.cpp"
1281 > #line 1282 "MDTreeParser.cpp"
1282          
1283          try {      // for error handling
1284                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1210 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292                  }
1293                  case MEMBERS:
1294                  {
1295 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1296 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1295 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1296 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1297                          match(_t,MEMBERS);
1298                          _t = _t->getFirstChild();
1299                          ivec=inttuple(_t);
1300                          _t = _retTree;
1301 <                        _t = __t49;
1301 >                        _t = __t50;
1302                          _t = _t->getNextSibling();
1303 < #line 153 "MDTreeParser.g"
1303 > #line 160 "MDTreeParser.g"
1304                          currBondStamp->setMembers(ivec);
1305 < #line 1224 "MDTreeParser.cpp"
1305 > #line 1306 "MDTreeParser.cpp"
1306                          break;
1307                  }
1308                  default:
# Line 1238 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320   }
1321  
1322   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323 < #line 278 "MDTreeParser.g"
1323 > #line 286 "MDTreeParser.g"
1324          vector<int> ivec;
1325 < #line 1244 "MDTreeParser.cpp"
1325 > #line 1326 "MDTreeParser.cpp"
1326          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327 < #line 278 "MDTreeParser.g"
1327 > #line 286 "MDTreeParser.g"
1328          
1329          int ival;
1330          
1331 < #line 1250 "MDTreeParser.cpp"
1331 > #line 1332 "MDTreeParser.cpp"
1332          
1333          try {      // for error handling
1334                  { // ( ... )+
1335 <                int _cnt90=0;
1335 >                int _cnt91=0;
1336                  for (;;) {
1337                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338                                  _t = ASTNULL;
1339                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340                                  ival=intConst(_t);
1341                                  _t = _retTree;
1342 < #line 282 "MDTreeParser.g"
1342 > #line 290 "MDTreeParser.g"
1343                                  ivec.push_back(ival);
1344 < #line 1263 "MDTreeParser.cpp"
1344 > #line 1345 "MDTreeParser.cpp"
1345                          }
1346                          else {
1347 <                                if ( _cnt90>=1 ) { goto _loop90; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1347 >                                if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348                          }
1349                          
1350 <                        _cnt90++;
1350 >                        _cnt91++;
1351                  }
1352 <                _loop90:;
1352 >                _loop91:;
1353                  }  // ( ... )+
1354          }
1355          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1281 | Line 1363 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1363  
1364   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1365          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366 < #line 166 "MDTreeParser.g"
1366 > #line 173 "MDTreeParser.g"
1367          
1368          vector<int> ivec;
1369          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370          
1371 < #line 1290 "MDTreeParser.cpp"
1371 > #line 1372 "MDTreeParser.cpp"
1372          
1373          try {      // for error handling
1374                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1300 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382                  }
1383                  case MEMBERS:
1384                  {
1385 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1386 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1385 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1386 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1387                          match(_t,MEMBERS);
1388                          _t = _t->getFirstChild();
1389                          ivec=inttuple(_t);
1390                          _t = _retTree;
1391 <                        _t = __t55;
1391 >                        _t = __t56;
1392                          _t = _t->getNextSibling();
1393 < #line 172 "MDTreeParser.g"
1393 > #line 179 "MDTreeParser.g"
1394                          currBendStamp->setMembers(ivec);
1395 < #line 1314 "MDTreeParser.cpp"
1395 > #line 1396 "MDTreeParser.cpp"
1396                          break;
1397                  }
1398                  default:
# Line 1329 | Line 1411 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1411  
1412   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1413          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414 < #line 185 "MDTreeParser.g"
1414 > #line 192 "MDTreeParser.g"
1415          
1416          vector<int> ivec;
1417          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418          
1419 < #line 1338 "MDTreeParser.cpp"
1419 > #line 1420 "MDTreeParser.cpp"
1420          
1421          try {      // for error handling
1422                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1348 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430                  }
1431                  case MEMBERS:
1432                  {
1433 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1434 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1433 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1434 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1435                          match(_t,MEMBERS);
1436                          _t = _t->getFirstChild();
1437                          ivec=inttuple(_t);
1438                          _t = _retTree;
1439 <                        _t = __t61;
1439 >                        _t = __t62;
1440                          _t = _t->getNextSibling();
1441 < #line 191 "MDTreeParser.g"
1441 > #line 198 "MDTreeParser.g"
1442                          currTorsionStamp->setMembers(ivec);
1443 < #line 1362 "MDTreeParser.cpp"
1443 > #line 1444 "MDTreeParser.cpp"
1444                          break;
1445                  }
1446                  default:
# Line 1377 | Line 1459 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1459  
1460   void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461          ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462 < #line 204 "MDTreeParser.g"
1462 > #line 211 "MDTreeParser.g"
1463          
1464          int icent;
1465          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466          
1467 < #line 1386 "MDTreeParser.cpp"
1467 > #line 1468 "MDTreeParser.cpp"
1468          
1469          try {      // for error handling
1470                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1396 | Line 1478 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1478                  }
1479                  case CENTER:
1480                  {
1481 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1482 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1481 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1482 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1483                          match(_t,CENTER);
1484                          _t = _t->getFirstChild();
1485                          icent=intConst(_t);
1486                          _t = _retTree;
1487 <                        _t = __t67;
1487 >                        _t = __t68;
1488                          _t = _t->getNextSibling();
1489 < #line 210 "MDTreeParser.g"
1489 > #line 217 "MDTreeParser.g"
1490                          currInversionStamp->setCenter(icent);
1491 < #line 1410 "MDTreeParser.cpp"
1491 > #line 1492 "MDTreeParser.cpp"
1492                          break;
1493                  }
1494                  default:
# Line 1425 | Line 1507 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1507  
1508   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510 < #line 227 "MDTreeParser.g"
1510 > #line 234 "MDTreeParser.g"
1511          
1512          vector<int> ivec;
1513          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514          
1515 < #line 1434 "MDTreeParser.cpp"
1515 > #line 1516 "MDTreeParser.cpp"
1516          
1517          try {      // for error handling
1518                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1444 | Line 1526 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1526                  }
1527                  case MEMBERS:
1528                  {
1529 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t73 = _t;
1530 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1529 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1530 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1531                          match(_t,MEMBERS);
1532                          _t = _t->getFirstChild();
1533                          ivec=inttuple(_t);
1534                          _t = _retTree;
1535 <                        _t = __t73;
1535 >                        _t = __t74;
1536                          _t = _t->getNextSibling();
1537 < #line 233 "MDTreeParser.g"
1537 > #line 240 "MDTreeParser.g"
1538                          currRigidBodyStamp->setMembers(ivec);
1539 < #line 1458 "MDTreeParser.cpp"
1539 > #line 1540 "MDTreeParser.cpp"
1540                          break;
1541                  }
1542                  default:
# Line 1473 | Line 1555 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1555  
1556   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1558 < #line 246 "MDTreeParser.g"
1558 > #line 253 "MDTreeParser.g"
1559          
1560          vector<int> ivec;
1561          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562          
1563 < #line 1482 "MDTreeParser.cpp"
1563 > #line 1564 "MDTreeParser.cpp"
1564          
1565          try {      // for error handling
1566                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1492 | Line 1574 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1574                  }
1575                  case MEMBERS:
1576                  {
1577 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t79 = _t;
1578 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1577 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1578 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1579                          match(_t,MEMBERS);
1580                          _t = _t->getFirstChild();
1581                          ivec=inttuple(_t);
1582                          _t = _retTree;
1583 <                        _t = __t79;
1583 >                        _t = __t80;
1584                          _t = _t->getNextSibling();
1585 < #line 252 "MDTreeParser.g"
1585 > #line 259 "MDTreeParser.g"
1586                          currCutoffGroupStamp->setMembers(ivec);
1587 < #line 1506 "MDTreeParser.cpp"
1587 > #line 1588 "MDTreeParser.cpp"
1588                          break;
1589                  }
1590                  default:
# Line 1534 | Line 1616 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1616          _retTree = _t;
1617   }
1618  
1537 – RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1538 – #line 292 "MDTreeParser.g"
1539 –        RealType dval;
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;
1544 –        
1545 –        try {      // for error handling
1546 –                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1547 –                        _t = ASTNULL;
1548 –                switch ( _t->getType()) {
1549 –                case NUM_INT:
1550 –                case NUM_LONG:
1551 –                {
1552 –                        ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1553 –                        intConst(_t);
1554 –                        _t = _retTree;
1555 – #line 294 "MDTreeParser.g"
1556 –                        dval = lexi_cast<RealType>(ic->getText());
1557 – #line 1558 "MDTreeParser.cpp"
1558 –                        break;
1559 –                }
1560 –                case NUM_FLOAT:
1561 –                case NUM_DOUBLE:
1562 –                {
1563 –                        fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1564 –                        floatConst(_t);
1565 –                        _t = _retTree;
1566 – #line 295 "MDTreeParser.g"
1567 –                        dval = lexi_cast<RealType>(fc->getText());
1568 – #line 1569 "MDTreeParser.cpp"
1569 –                        break;
1570 –                }
1571 –                default:
1572 –                {
1573 –                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1574 –                }
1575 –                }
1576 –        }
1577 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1578 –                reportError(ex);
1579 –                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1580 –                        _t = _t->getNextSibling();
1581 –        }
1582 –        _retTree = _t;
1583 –        return dval;
1584 – }
1585 –
1619   void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620   {
1621   }

Diff Legend

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