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 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20110725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 80 | Line 80 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
80                          _t = _retTree;
81                          break;
82                  }
83 +                case FLUCQ:
84 +                {
85 +                        flucqblock(_t);
86 +                        _t = _retTree;
87 +                        break;
88 +                }
89 +                case RNEMD:
90 +                {
91 +                        rnemdblock(_t);
92 +                        _t = _retTree;
93 +                        break;
94 +                }
95                  default:
96                  {
97                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 127 | Line 139 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
139                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
140                  match(_t,COMPONENT);
141                  _t = _t->getFirstChild();
142 < #line 63 "MDTreeParser.g"
142 > #line 64 "MDTreeParser.g"
143                  Component* currComponet = new Component(); blockStack.push(currComponet);
144 < #line 133 "MDTreeParser.cpp"
144 > #line 145 "MDTreeParser.cpp"
145                  { // ( ... )*
146                  for (;;) {
147                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 150 | Line 162 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
162                  _t = _t->getNextSibling();
163                  _t = __t9;
164                  _t = _t->getNextSibling();
165 < #line 65 "MDTreeParser.g"
165 > #line 66 "MDTreeParser.g"
166                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
167 < #line 156 "MDTreeParser.cpp"
167 > #line 168 "MDTreeParser.cpp"
168          }
169          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
170                  reportError(ex);
# Line 166 | Line 178 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
178          ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
179          
180          try {      // for error handling
181 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
181 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
182                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
183                  match(_t,MOLECULE);
184                  _t = _t->getFirstChild();
185 < #line 78 "MDTreeParser.g"
185 > #line 90 "MDTreeParser.g"
186                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
187 < #line 176 "MDTreeParser.cpp"
187 > #line 188 "MDTreeParser.cpp"
188                  { // ( ... )*
189                  for (;;) {
190                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 182 | Line 194 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
194                                  _t = _retTree;
195                          }
196                          else {
197 <                                goto _loop23;
197 >                                goto _loop31;
198                          }
199                          
200                  }
201 <                _loop23:;
201 >                _loop31:;
202                  } // ( ... )*
203                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
204                  match(_t,ENDBLOCK);
205                  _t = _t->getNextSibling();
206 <                _t = __t21;
206 >                _t = __t29;
207                  _t = _t->getNextSibling();
208 < #line 80 "MDTreeParser.g"
208 > #line 92 "MDTreeParser.g"
209                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
210 < #line 199 "MDTreeParser.cpp"
210 > #line 211 "MDTreeParser.cpp"
211          }
212          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
213                  reportError(ex);
# Line 213 | Line 225 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
225                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
226                  match(_t,ZCONSTRAINT);
227                  _t = _t->getFirstChild();
228 < #line 68 "MDTreeParser.g"
228 > #line 69 "MDTreeParser.g"
229                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
230 < #line 219 "MDTreeParser.cpp"
230 > #line 231 "MDTreeParser.cpp"
231                  { // ( ... )*
232                  for (;;) {
233                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 236 | Line 248 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
248                  _t = _t->getNextSibling();
249                  _t = __t13;
250                  _t = _t->getNextSibling();
251 < #line 70 "MDTreeParser.g"
251 > #line 71 "MDTreeParser.g"
252                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
253 < #line 242 "MDTreeParser.cpp"
253 > #line 254 "MDTreeParser.cpp"
254          }
255          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
256                  reportError(ex);
# Line 256 | Line 268 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
268                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
269                  match(_t,RESTRAINT);
270                  _t = _t->getFirstChild();
271 < #line 73 "MDTreeParser.g"
271 > #line 74 "MDTreeParser.g"
272                  RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
273 < #line 262 "MDTreeParser.cpp"
273 > #line 274 "MDTreeParser.cpp"
274                  { // ( ... )*
275                  for (;;) {
276                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 279 | Line 291 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
291                  _t = _t->getNextSibling();
292                  _t = __t17;
293                  _t = _t->getNextSibling();
294 < #line 75 "MDTreeParser.g"
294 > #line 76 "MDTreeParser.g"
295                  blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
296 < #line 285 "MDTreeParser.cpp"
296 > #line 297 "MDTreeParser.cpp"
297 >        }
298 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
299 >                reportError(ex);
300 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
301 >                        _t = _t->getNextSibling();
302 >        }
303 >        _retTree = _t;
304 > }
305 >
306 > void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
307 >        ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
308 >        
309 >        try {      // for error handling
310 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
311 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
312 >                match(_t,FLUCQ);
313 >                _t = _t->getFirstChild();
314 > #line 79 "MDTreeParser.g"
315 >                FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
316 > #line 317 "MDTreeParser.cpp"
317 >                { // ( ... )*
318 >                for (;;) {
319 >                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
320 >                                _t = ASTNULL;
321 >                        if ((_t->getType() == ASSIGNEQUAL)) {
322 >                                assignment(_t);
323 >                                _t = _retTree;
324 >                        }
325 >                        else {
326 >                                goto _loop23;
327 >                        }
328 >                        
329 >                }
330 >                _loop23:;
331 >                } // ( ... )*
332 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
333 >                match(_t,ENDBLOCK);
334 >                _t = _t->getNextSibling();
335 >                _t = __t21;
336 >                _t = _t->getNextSibling();
337 > #line 81 "MDTreeParser.g"
338 >                blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
339 > #line 340 "MDTreeParser.cpp"
340          }
341          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
342                  reportError(ex);
# Line 291 | Line 346 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
346          _retTree = _t;
347   }
348  
349 + void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
350 +        ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
351 +        
352 +        try {      // for error handling
353 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t25 = _t;
354 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
355 +                match(_t,RNEMD);
356 +                _t = _t->getFirstChild();
357 + #line 84 "MDTreeParser.g"
358 +                RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
359 + #line 360 "MDTreeParser.cpp"
360 +                { // ( ... )*
361 +                for (;;) {
362 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
363 +                                _t = ASTNULL;
364 +                        if ((_t->getType() == ASSIGNEQUAL)) {
365 +                                assignment(_t);
366 +                                _t = _retTree;
367 +                        }
368 +                        else {
369 +                                goto _loop27;
370 +                        }
371 +                        
372 +                }
373 +                _loop27:;
374 +                } // ( ... )*
375 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
376 +                match(_t,ENDBLOCK);
377 +                _t = _t->getNextSibling();
378 +                _t = __t25;
379 +                _t = _t->getNextSibling();
380 + #line 86 "MDTreeParser.g"
381 +                blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
382 + #line 383 "MDTreeParser.cpp"
383 +        }
384 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
385 +                reportError(ex);
386 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
387 +                        _t = _t->getNextSibling();
388 +        }
389 +        _retTree = _t;
390 + }
391 +
392   void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
393          ANTLR_USE_NAMESPACE(antlr)RefAST id
394   ) {
395          ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
396          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
397          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
398 < #line 48 "MDTreeParser.g"
398 > #line 49 "MDTreeParser.g"
399          
400          int ival;
401          RealType dval;
402          
403 < #line 306 "MDTreeParser.cpp"
403 > #line 404 "MDTreeParser.cpp"
404          
405          try {      // for error handling
406                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 313 | Line 411 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
411                  {
412                          ival=intConst(_t);
413                          _t = _retTree;
414 < #line 53 "MDTreeParser.g"
414 > #line 54 "MDTreeParser.g"
415                          blockStack.top()->assign(id->getText(), ival);
416 < #line 319 "MDTreeParser.cpp"
416 > #line 417 "MDTreeParser.cpp"
417                          break;
418                  }
419                  case NUM_FLOAT:
# Line 323 | Line 421 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
421                  {
422                          dval=floatConst(_t);
423                          _t = _retTree;
424 < #line 54 "MDTreeParser.g"
424 > #line 55 "MDTreeParser.g"
425                          blockStack.top()->assign(id->getText(), dval);
426 < #line 329 "MDTreeParser.cpp"
426 > #line 427 "MDTreeParser.cpp"
427                          break;
428                  }
429                  case ID:
# Line 333 | Line 431 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
431                          str1 = _t;
432                          match(_t,ID);
433                          _t = _t->getNextSibling();
434 < #line 55 "MDTreeParser.g"
434 > #line 56 "MDTreeParser.g"
435                          blockStack.top()->assign(id->getText(), str1->getText());
436 < #line 339 "MDTreeParser.cpp"
436 > #line 437 "MDTreeParser.cpp"
437                          break;
438                  }
439                  case StringLiteral:
# Line 343 | Line 441 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
441                          str2 = _t;
442                          match(_t,StringLiteral);
443                          _t = _t->getNextSibling();
444 < #line 56 "MDTreeParser.g"
444 > #line 57 "MDTreeParser.g"
445                          std::string s =  str2->getText();
446                          s = s.substr(1, s.length()-2);
447                          blockStack.top()->assign(id->getText(),s);
448                          
449 < #line 352 "MDTreeParser.cpp"
449 > #line 450 "MDTreeParser.cpp"
450                          break;
451                  }
452                  default:
# Line 366 | Line 464 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
464   }
465  
466   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
467 < #line 268 "MDTreeParser.g"
467 > #line 280 "MDTreeParser.g"
468          int ival;
469 < #line 372 "MDTreeParser.cpp"
469 > #line 470 "MDTreeParser.cpp"
470          ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
471          ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
472          ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 382 | Line 480 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
480                          i1 = _t;
481                          match(_t,NUM_INT);
482                          _t = _t->getNextSibling();
483 < #line 269 "MDTreeParser.g"
483 > #line 281 "MDTreeParser.g"
484                          ival = lexi_cast<int>(i1->getText());
485 < #line 388 "MDTreeParser.cpp"
485 > #line 486 "MDTreeParser.cpp"
486                          break;
487                  }
488                  case NUM_LONG:
# Line 392 | Line 490 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
490                          i2 = _t;
491                          match(_t,NUM_LONG);
492                          _t = _t->getNextSibling();
493 < #line 270 "MDTreeParser.g"
493 > #line 282 "MDTreeParser.g"
494                          ival = lexi_cast<int>(i2->getText());
495 < #line 398 "MDTreeParser.cpp"
495 > #line 496 "MDTreeParser.cpp"
496                          break;
497                  }
498                  default:
# Line 413 | Line 511 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
511   }
512  
513   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
514 < #line 282 "MDTreeParser.g"
514 > #line 294 "MDTreeParser.g"
515          RealType dval;
516 < #line 419 "MDTreeParser.cpp"
516 > #line 517 "MDTreeParser.cpp"
517          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
518          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
519          ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 429 | Line 527 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
527                          d1 = _t;
528                          match(_t,NUM_FLOAT);
529                          _t = _t->getNextSibling();
530 < #line 283 "MDTreeParser.g"
530 > #line 295 "MDTreeParser.g"
531                          dval = lexi_cast<RealType>(d1->getText());
532 < #line 435 "MDTreeParser.cpp"
532 > #line 533 "MDTreeParser.cpp"
533                          break;
534                  }
535                  case NUM_DOUBLE:
# Line 439 | Line 537 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
537                          d2 = _t;
538                          match(_t,NUM_DOUBLE);
539                          _t = _t->getNextSibling();
540 < #line 284 "MDTreeParser.g"
540 > #line 296 "MDTreeParser.g"
541                          dval = lexi_cast<RealType>(d2->getText());
542 < #line 445 "MDTreeParser.cpp"
542 > #line 543 "MDTreeParser.cpp"
543                          break;
544                  }
545                  default:
# Line 536 | Line 634 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
634  
635   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
636          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
637 < #line 94 "MDTreeParser.g"
637 > #line 106 "MDTreeParser.g"
638          
639          int index;
640          
641 < #line 544 "MDTreeParser.cpp"
641 > #line 642 "MDTreeParser.cpp"
642          
643          try {      // for error handling
644 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
645 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
644 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
645 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
646                  match(_t,ATOM);
647                  _t = _t->getFirstChild();
648                  index=intConst(_t);
649                  _t = _retTree;
650 < #line 98 "MDTreeParser.g"
650 > #line 110 "MDTreeParser.g"
651                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
652 < #line 555 "MDTreeParser.cpp"
652 > #line 653 "MDTreeParser.cpp"
653                  { // ( ... )*
654                  for (;;) {
655                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 561 | Line 659 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
659                                  _t = _retTree;
660                          }
661                          else {
662 <                                goto _loop28;
662 >                                goto _loop36;
663                          }
664                          
665                  }
666 <                _loop28:;
666 >                _loop36:;
667                  } // ( ... )*
668 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
668 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
669                  match(_t,ENDBLOCK);
670                  _t = _t->getNextSibling();
671 <                _t = __t26;
671 >                _t = __t34;
672                  _t = _t->getNextSibling();
673 < #line 100 "MDTreeParser.g"
673 > #line 112 "MDTreeParser.g"
674                  
675                  blockStack.top()->validate();
676                  blockStack.pop();
677                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
678                  currMoleculeStamp->addAtomStamp(currAtomStamp);
679                  
680 < #line 583 "MDTreeParser.cpp"
680 > #line 681 "MDTreeParser.cpp"
681          }
682          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683                  reportError(ex);
# Line 593 | Line 691 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
691          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
692          
693          try {      // for error handling
694 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
695 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
694 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
695 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
696                  match(_t,BOND);
697                  _t = _t->getFirstChild();
698 < #line 120 "MDTreeParser.g"
698 > #line 132 "MDTreeParser.g"
699                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
700 < #line 603 "MDTreeParser.cpp"
700 > #line 701 "MDTreeParser.cpp"
701                  { // ( ... )*
702                  for (;;) {
703                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 609 | Line 707 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
707                                  _t = _retTree;
708                          }
709                          else {
710 <                                goto _loop35;
710 >                                goto _loop43;
711                          }
712                          
713                  }
714 <                _loop35:;
714 >                _loop43:;
715                  } // ( ... )*
716 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
716 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
717                  match(_t,ENDBLOCK);
718                  _t = _t->getNextSibling();
719 <                _t = __t33;
719 >                _t = __t41;
720                  _t = _t->getNextSibling();
721 < #line 122 "MDTreeParser.g"
721 > #line 134 "MDTreeParser.g"
722                  
723                  blockStack.pop();
724                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
725                  currMoleculeStamp->addBondStamp(currBondStamp);
726                  
727 < #line 630 "MDTreeParser.cpp"
727 > #line 728 "MDTreeParser.cpp"
728          }
729          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
730                  reportError(ex);
# Line 640 | Line 738 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
738          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
739          
740          try {      // for error handling
741 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
742 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
741 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
742 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
743                  match(_t,BEND);
744                  _t = _t->getFirstChild();
745 < #line 138 "MDTreeParser.g"
745 > #line 150 "MDTreeParser.g"
746                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
747 < #line 650 "MDTreeParser.cpp"
747 > #line 748 "MDTreeParser.cpp"
748                  { // ( ... )*
749                  for (;;) {
750                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 656 | Line 754 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
754                                  _t = _retTree;
755                          }
756                          else {
757 <                                goto _loop41;
757 >                                goto _loop49;
758                          }
759                          
760                  }
761 <                _loop41:;
761 >                _loop49:;
762                  } // ( ... )*
763 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
763 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
764                  match(_t,ENDBLOCK);
765                  _t = _t->getNextSibling();
766 <                _t = __t39;
766 >                _t = __t47;
767                  _t = _t->getNextSibling();
768 < #line 140 "MDTreeParser.g"
768 > #line 152 "MDTreeParser.g"
769                  
770                  blockStack.top()->validate();
771                  blockStack.pop();
772                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
773                  currMoleculeStamp->addBendStamp(currBendStamp);
774                  
775 < #line 678 "MDTreeParser.cpp"
775 > #line 776 "MDTreeParser.cpp"
776          }
777          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
778                  reportError(ex);
# Line 688 | Line 786 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
786          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
787          
788          try {      // for error handling
789 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
790 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
789 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
790 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
791                  match(_t,TORSION);
792                  _t = _t->getFirstChild();
793 < #line 157 "MDTreeParser.g"
793 > #line 169 "MDTreeParser.g"
794                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
795 < #line 698 "MDTreeParser.cpp"
795 > #line 796 "MDTreeParser.cpp"
796                  { // ( ... )*
797                  for (;;) {
798                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 704 | Line 802 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
802                                  _t = _retTree;
803                          }
804                          else {
805 <                                goto _loop47;
805 >                                goto _loop55;
806                          }
807                          
808                  }
809 <                _loop47:;
809 >                _loop55:;
810                  } // ( ... )*
811 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
811 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
812                  match(_t,ENDBLOCK);
813                  _t = _t->getNextSibling();
814 <                _t = __t45;
814 >                _t = __t53;
815                  _t = _t->getNextSibling();
816 < #line 159 "MDTreeParser.g"
816 > #line 171 "MDTreeParser.g"
817                  
818                  blockStack.top()->validate();
819                  blockStack.pop();
820                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
821                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
822                  
823 < #line 726 "MDTreeParser.cpp"
823 > #line 824 "MDTreeParser.cpp"
824          }
825          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
826                  reportError(ex);
# Line 736 | Line 834 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
834          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
835          
836          try {      // for error handling
837 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
838 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
837 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
838 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
839                  match(_t,INVERSION);
840                  _t = _t->getFirstChild();
841 < #line 176 "MDTreeParser.g"
841 > #line 188 "MDTreeParser.g"
842                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
843 < #line 746 "MDTreeParser.cpp"
843 > #line 844 "MDTreeParser.cpp"
844                  { // ( ... )*
845                  for (;;) {
846                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 752 | Line 850 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
850                                  _t = _retTree;
851                          }
852                          else {
853 <                                goto _loop53;
853 >                                goto _loop61;
854                          }
855                          
856                  }
857 <                _loop53:;
857 >                _loop61:;
858                  } // ( ... )*
859 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
859 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
860                  match(_t,ENDBLOCK);
861                  _t = _t->getNextSibling();
862 <                _t = __t51;
862 >                _t = __t59;
863                  _t = _t->getNextSibling();
864 < #line 178 "MDTreeParser.g"
864 > #line 190 "MDTreeParser.g"
865                  
866                  blockStack.top()->validate();
867                  blockStack.pop();
868                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
869                  currMoleculeStamp->addInversionStamp(currInversionStamp);
870                  
871 < #line 774 "MDTreeParser.cpp"
871 > #line 872 "MDTreeParser.cpp"
872          }
873          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
874                  reportError(ex);
# Line 782 | Line 880 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
880  
881   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
882          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
883 < #line 195 "MDTreeParser.g"
883 > #line 207 "MDTreeParser.g"
884          
885          int index;
886          
887 < #line 790 "MDTreeParser.cpp"
887 > #line 888 "MDTreeParser.cpp"
888          
889          try {      // for error handling
890 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
891 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
890 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
891 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
892                  match(_t,RIGIDBODY);
893                  _t = _t->getFirstChild();
894                  index=intConst(_t);
895                  _t = _retTree;
896 < #line 199 "MDTreeParser.g"
896 > #line 211 "MDTreeParser.g"
897                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
898 < #line 801 "MDTreeParser.cpp"
898 > #line 899 "MDTreeParser.cpp"
899                  { // ( ... )*
900                  for (;;) {
901                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 807 | Line 905 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
905                                  _t = _retTree;
906                          }
907                          else {
908 <                                goto _loop59;
908 >                                goto _loop67;
909                          }
910                          
911                  }
912 <                _loop59:;
912 >                _loop67:;
913                  } // ( ... )*
914 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
914 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
915                  match(_t,ENDBLOCK);
916                  _t = _t->getNextSibling();
917 <                _t = __t57;
917 >                _t = __t65;
918                  _t = _t->getNextSibling();
919 < #line 201 "MDTreeParser.g"
919 > #line 213 "MDTreeParser.g"
920                  
921                  blockStack.top()->validate();
922                  blockStack.pop();
923                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
924                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
925                  
926 < #line 829 "MDTreeParser.cpp"
926 > #line 927 "MDTreeParser.cpp"
927          }
928          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
929                  reportError(ex);
# Line 839 | Line 937 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
937          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
938          
939          try {      // for error handling
940 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
941 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
940 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
941 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
942                  match(_t,CUTOFFGROUP);
943                  _t = _t->getFirstChild();
944 < #line 218 "MDTreeParser.g"
944 > #line 230 "MDTreeParser.g"
945                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
946 < #line 849 "MDTreeParser.cpp"
946 > #line 947 "MDTreeParser.cpp"
947                  { // ( ... )*
948                  for (;;) {
949                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 855 | Line 953 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
953                                  _t = _retTree;
954                          }
955                          else {
956 <                                goto _loop65;
956 >                                goto _loop73;
957                          }
958                          
959                  }
960 <                _loop65:;
960 >                _loop73:;
961                  } // ( ... )*
962 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
962 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
963                  match(_t,ENDBLOCK);
964                  _t = _t->getNextSibling();
965 <                _t = __t63;
965 >                _t = __t71;
966                  _t = _t->getNextSibling();
967 < #line 220 "MDTreeParser.g"
967 > #line 232 "MDTreeParser.g"
968                  
969                  blockStack.top()->validate();
970                  blockStack.pop();
971                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
972                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
973                  
974 < #line 877 "MDTreeParser.cpp"
974 > #line 975 "MDTreeParser.cpp"
975          }
976          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
977                  reportError(ex);
# Line 885 | Line 983 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
983  
984   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
985          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
986 < #line 237 "MDTreeParser.g"
986 > #line 249 "MDTreeParser.g"
987          int ival;
988 < #line 891 "MDTreeParser.cpp"
988 > #line 989 "MDTreeParser.cpp"
989          
990          try {      // for error handling
991 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
992 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
991 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
992 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
993                  match(_t,FRAGMENT);
994                  _t = _t->getFirstChild();
995                  ival=intConst(_t);
996                  _t = _retTree;
997 < #line 238 "MDTreeParser.g"
997 > #line 250 "MDTreeParser.g"
998                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
999 < #line 902 "MDTreeParser.cpp"
999 > #line 1000 "MDTreeParser.cpp"
1000                  { // ( ... )*
1001                  for (;;) {
1002                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 908 | Line 1006 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1006                                  _t = _retTree;
1007                          }
1008                          else {
1009 <                                goto _loop71;
1009 >                                goto _loop79;
1010                          }
1011                          
1012                  }
1013 <                _loop71:;
1013 >                _loop79:;
1014                  } // ( ... )*
1015 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1015 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1016                  match(_t,ENDBLOCK);
1017                  _t = _t->getNextSibling();
1018 <                _t = __t69;
1018 >                _t = __t77;
1019                  _t = _t->getNextSibling();
1020 < #line 240 "MDTreeParser.g"
1020 > #line 252 "MDTreeParser.g"
1021                  
1022                  blockStack.top()->validate();
1023                  blockStack.pop();
1024                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1025                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1026                  
1027 < #line 930 "MDTreeParser.cpp"
1027 > #line 1028 "MDTreeParser.cpp"
1028          }
1029          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1030                  reportError(ex);
# Line 938 | Line 1036 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1036  
1037   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1038          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1039 < #line 108 "MDTreeParser.g"
1039 > #line 120 "MDTreeParser.g"
1040          
1041          vector<RealType> dvec;
1042          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1043          
1044          
1045 < #line 948 "MDTreeParser.cpp"
1045 > #line 1046 "MDTreeParser.cpp"
1046          
1047          try {      // for error handling
1048                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 958 | Line 1056 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1056                  }
1057                  case POSITION:
1058                  {
1059 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1060 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1059 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
1060 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1061                          match(_t,POSITION);
1062                          _t = _t->getFirstChild();
1063                          dvec=doubleNumberTuple(_t);
1064                          _t = _retTree;
1065 <                        _t = __t30;
1065 >                        _t = __t38;
1066                          _t = _t->getNextSibling();
1067 < #line 115 "MDTreeParser.g"
1067 > #line 127 "MDTreeParser.g"
1068                          currAtomStamp->setPosition(dvec);
1069 < #line 972 "MDTreeParser.cpp"
1069 > #line 1070 "MDTreeParser.cpp"
1070                          break;
1071                  }
1072                  case ORIENTATION:
1073                  {
1074 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1075 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1074 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1075 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1076                          match(_t,ORIENTATION);
1077                          _t = _t->getFirstChild();
1078                          dvec=doubleNumberTuple(_t);
1079                          _t = _retTree;
1080 <                        _t = __t31;
1080 >                        _t = __t39;
1081                          _t = _t->getNextSibling();
1082 < #line 116 "MDTreeParser.g"
1082 > #line 128 "MDTreeParser.g"
1083                          currAtomStamp->setOrientation(dvec);
1084 < #line 987 "MDTreeParser.cpp"
1084 > #line 1085 "MDTreeParser.cpp"
1085                          break;
1086                  }
1087                  default:
# Line 1001 | Line 1099 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1099   }
1100  
1101   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1102 < #line 253 "MDTreeParser.g"
1102 > #line 265 "MDTreeParser.g"
1103          vector<RealType> dvec;
1104 < #line 1007 "MDTreeParser.cpp"
1104 > #line 1105 "MDTreeParser.cpp"
1105          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1106 < #line 253 "MDTreeParser.g"
1106 > #line 265 "MDTreeParser.g"
1107          
1108          RealType dval;
1109          
1110 < #line 1013 "MDTreeParser.cpp"
1110 > #line 1111 "MDTreeParser.cpp"
1111          
1112          try {      // for error handling
1113                  { // ( ... )+
1114 <                int _cnt75=0;
1114 >                int _cnt83=0;
1115                  for (;;) {
1116                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1117                                  _t = ASTNULL;
1118                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1119                                  dval=doubleNumber(_t);
1120                                  _t = _retTree;
1121 < #line 257 "MDTreeParser.g"
1121 > #line 269 "MDTreeParser.g"
1122                                  dvec.push_back(dval);
1123 < #line 1026 "MDTreeParser.cpp"
1123 > #line 1124 "MDTreeParser.cpp"
1124                          }
1125                          else {
1126 <                                if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1126 >                                if ( _cnt83>=1 ) { goto _loop83; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1127                          }
1128                          
1129 <                        _cnt75++;
1129 >                        _cnt83++;
1130                  }
1131 <                _loop75:;
1131 >                _loop83:;
1132                  }  // ( ... )+
1133          }
1134          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1044 | Line 1142 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1142  
1143   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1144          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1145 < #line 129 "MDTreeParser.g"
1145 > #line 141 "MDTreeParser.g"
1146          
1147          vector<int> ivec;
1148          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1149          
1150 < #line 1053 "MDTreeParser.cpp"
1150 > #line 1151 "MDTreeParser.cpp"
1151          
1152          try {      // for error handling
1153                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1063 | Line 1161 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1161                  }
1162                  case MEMBERS:
1163                  {
1164 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1165 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1164 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1165 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1166                          match(_t,MEMBERS);
1167                          _t = _t->getFirstChild();
1168                          ivec=inttuple(_t);
1169                          _t = _retTree;
1170 <                        _t = __t37;
1170 >                        _t = __t45;
1171                          _t = _t->getNextSibling();
1172 < #line 135 "MDTreeParser.g"
1172 > #line 147 "MDTreeParser.g"
1173                          currBondStamp->setMembers(ivec);
1174 < #line 1077 "MDTreeParser.cpp"
1174 > #line 1175 "MDTreeParser.cpp"
1175                          break;
1176                  }
1177                  default:
# Line 1091 | Line 1189 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1189   }
1190  
1191   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1192 < #line 260 "MDTreeParser.g"
1192 > #line 272 "MDTreeParser.g"
1193          vector<int> ivec;
1194 < #line 1097 "MDTreeParser.cpp"
1194 > #line 1195 "MDTreeParser.cpp"
1195          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1196 < #line 260 "MDTreeParser.g"
1196 > #line 272 "MDTreeParser.g"
1197          
1198          int ival;
1199          
1200 < #line 1103 "MDTreeParser.cpp"
1200 > #line 1201 "MDTreeParser.cpp"
1201          
1202          try {      // for error handling
1203                  { // ( ... )+
1204 <                int _cnt78=0;
1204 >                int _cnt86=0;
1205                  for (;;) {
1206                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1207                                  _t = ASTNULL;
1208                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1209                                  ival=intConst(_t);
1210                                  _t = _retTree;
1211 < #line 264 "MDTreeParser.g"
1211 > #line 276 "MDTreeParser.g"
1212                                  ivec.push_back(ival);
1213 < #line 1116 "MDTreeParser.cpp"
1213 > #line 1214 "MDTreeParser.cpp"
1214                          }
1215                          else {
1216 <                                if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1216 >                                if ( _cnt86>=1 ) { goto _loop86; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1217                          }
1218                          
1219 <                        _cnt78++;
1219 >                        _cnt86++;
1220                  }
1221 <                _loop78:;
1221 >                _loop86:;
1222                  }  // ( ... )+
1223          }
1224          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1134 | Line 1232 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1232  
1233   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1234          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1235 < #line 148 "MDTreeParser.g"
1235 > #line 160 "MDTreeParser.g"
1236          
1237          vector<int> ivec;
1238          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1239          
1240 < #line 1143 "MDTreeParser.cpp"
1240 > #line 1241 "MDTreeParser.cpp"
1241          
1242          try {      // for error handling
1243                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1153 | Line 1251 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1251                  }
1252                  case MEMBERS:
1253                  {
1254 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1255 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1254 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1255 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1256                          match(_t,MEMBERS);
1257                          _t = _t->getFirstChild();
1258                          ivec=inttuple(_t);
1259                          _t = _retTree;
1260 <                        _t = __t43;
1260 >                        _t = __t51;
1261                          _t = _t->getNextSibling();
1262 < #line 154 "MDTreeParser.g"
1262 > #line 166 "MDTreeParser.g"
1263                          currBendStamp->setMembers(ivec);
1264 < #line 1167 "MDTreeParser.cpp"
1264 > #line 1265 "MDTreeParser.cpp"
1265                          break;
1266                  }
1267                  default:
# Line 1182 | Line 1280 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1280  
1281   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1282          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1283 < #line 167 "MDTreeParser.g"
1283 > #line 179 "MDTreeParser.g"
1284          
1285          vector<int> ivec;
1286          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1287          
1288 < #line 1191 "MDTreeParser.cpp"
1288 > #line 1289 "MDTreeParser.cpp"
1289          
1290          try {      // for error handling
1291                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1201 | Line 1299 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1299                  }
1300                  case MEMBERS:
1301                  {
1302 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1303 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1302 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1303 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1304                          match(_t,MEMBERS);
1305                          _t = _t->getFirstChild();
1306                          ivec=inttuple(_t);
1307                          _t = _retTree;
1308 <                        _t = __t49;
1308 >                        _t = __t57;
1309                          _t = _t->getNextSibling();
1310 < #line 173 "MDTreeParser.g"
1310 > #line 185 "MDTreeParser.g"
1311                          currTorsionStamp->setMembers(ivec);
1312 < #line 1215 "MDTreeParser.cpp"
1312 > #line 1313 "MDTreeParser.cpp"
1313                          break;
1314                  }
1315                  default:
# Line 1230 | Line 1328 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1328  
1329   void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1330          ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1331 < #line 186 "MDTreeParser.g"
1331 > #line 198 "MDTreeParser.g"
1332          
1333          int icent;
1334          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1335          
1336 < #line 1239 "MDTreeParser.cpp"
1336 > #line 1337 "MDTreeParser.cpp"
1337          
1338          try {      // for error handling
1339                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1249 | Line 1347 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1347                  }
1348                  case CENTER:
1349                  {
1350 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1351 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1350 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1351 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1352                          match(_t,CENTER);
1353                          _t = _t->getFirstChild();
1354                          icent=intConst(_t);
1355                          _t = _retTree;
1356 <                        _t = __t55;
1356 >                        _t = __t63;
1357                          _t = _t->getNextSibling();
1358 < #line 192 "MDTreeParser.g"
1358 > #line 204 "MDTreeParser.g"
1359                          currInversionStamp->setCenter(icent);
1360 < #line 1263 "MDTreeParser.cpp"
1360 > #line 1361 "MDTreeParser.cpp"
1361                          break;
1362                  }
1363                  default:
# Line 1278 | Line 1376 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1376  
1377   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1378          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1379 < #line 209 "MDTreeParser.g"
1379 > #line 221 "MDTreeParser.g"
1380          
1381          vector<int> ivec;
1382          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1383          
1384 < #line 1287 "MDTreeParser.cpp"
1384 > #line 1385 "MDTreeParser.cpp"
1385          
1386          try {      // for error handling
1387                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1297 | Line 1395 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1395                  }
1396                  case MEMBERS:
1397                  {
1398 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1399 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1398 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1399 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1400                          match(_t,MEMBERS);
1401                          _t = _t->getFirstChild();
1402                          ivec=inttuple(_t);
1403                          _t = _retTree;
1404 <                        _t = __t61;
1404 >                        _t = __t69;
1405                          _t = _t->getNextSibling();
1406 < #line 215 "MDTreeParser.g"
1406 > #line 227 "MDTreeParser.g"
1407                          currRigidBodyStamp->setMembers(ivec);
1408 < #line 1311 "MDTreeParser.cpp"
1408 > #line 1409 "MDTreeParser.cpp"
1409                          break;
1410                  }
1411                  default:
# Line 1326 | Line 1424 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1424  
1425   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1426          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1427 < #line 228 "MDTreeParser.g"
1427 > #line 240 "MDTreeParser.g"
1428          
1429          vector<int> ivec;
1430          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1431          
1432 < #line 1335 "MDTreeParser.cpp"
1432 > #line 1433 "MDTreeParser.cpp"
1433          
1434          try {      // for error handling
1435                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1345 | Line 1443 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1443                  }
1444                  case MEMBERS:
1445                  {
1446 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1447 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1446 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1447 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1448                          match(_t,MEMBERS);
1449                          _t = _t->getFirstChild();
1450                          ivec=inttuple(_t);
1451                          _t = _retTree;
1452 <                        _t = __t67;
1452 >                        _t = __t75;
1453                          _t = _t->getNextSibling();
1454 < #line 234 "MDTreeParser.g"
1454 > #line 246 "MDTreeParser.g"
1455                          currCutoffGroupStamp->setMembers(ivec);
1456 < #line 1359 "MDTreeParser.cpp"
1456 > #line 1457 "MDTreeParser.cpp"
1457                          break;
1458                  }
1459                  default:
# Line 1388 | Line 1486 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1486   }
1487  
1488   RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1489 < #line 274 "MDTreeParser.g"
1489 > #line 286 "MDTreeParser.g"
1490          RealType dval;
1491 < #line 1394 "MDTreeParser.cpp"
1491 > #line 1492 "MDTreeParser.cpp"
1492          ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1493          ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1494          ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 1405 | Line 1503 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1503                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1504                          intConst(_t);
1505                          _t = _retTree;
1506 < #line 276 "MDTreeParser.g"
1506 > #line 288 "MDTreeParser.g"
1507                          dval = lexi_cast<RealType>(ic->getText());
1508 < #line 1411 "MDTreeParser.cpp"
1508 > #line 1509 "MDTreeParser.cpp"
1509                          break;
1510                  }
1511                  case NUM_FLOAT:
# Line 1416 | Line 1514 | RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA
1514                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515                          floatConst(_t);
1516                          _t = _retTree;
1517 < #line 277 "MDTreeParser.g"
1517 > #line 289 "MDTreeParser.g"
1518                          dval = lexi_cast<RealType>(fc->getText());
1519 < #line 1422 "MDTreeParser.cpp"
1519 > #line 1520 "MDTreeParser.cpp"
1520                          break;
1521                  }
1522                  default:
# Line 1460 | Line 1558 | const char* MDTreeParser::tokenNames[] = {
1558          "\"center\"",
1559          "\"position\"",
1560          "\"orientation\"",
1561 +        "\"flucQ\"",
1562 +        "\"RNEMD\"",
1563          "ENDBLOCK",
1564          "ID",
1565          "ASSIGNEQUAL",
# Line 1497 | Line 1597 | const char* MDTreeParser::tokenNames[] = {
1597          0
1598   };
1599  
1600 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1601 < // "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL
1600 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 19923184UL, 0UL, 0UL, 0UL };
1601 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ASSIGNEQUAL
1602   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1603 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
1603 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1604   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1605   // "fragment" ASSIGNEQUAL
1606   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Diff Legend

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