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

Comparing branches/development/src/mdParser/MDTreeParser.cpp (file contents):
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC vs.
Revision 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 92 | Line 92 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
92                          _t = _retTree;
93                          break;
94                  }
95 +                case MINIMIZER:
96 +                {
97 +                        minimizerblock(_t);
98 +                        _t = _retTree;
99 +                        break;
100 +                }
101                  default:
102                  {
103                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 135 | 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 64 "MDTreeParser.g"
148 > #line 72 "MDTreeParser.g"
149                  Component* currComponet = new Component(); blockStack.push(currComponet);
150 < #line 145 "MDTreeParser.cpp"
150 > #line 151 "MDTreeParser.cpp"
151                  { // ( ... )*
152                  for (;;) {
153                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 151 | 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 66 "MDTreeParser.g"
171 > #line 74 "MDTreeParser.g"
172                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173 < #line 168 "MDTreeParser.cpp"
173 > #line 174 "MDTreeParser.cpp"
174          }
175          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176                  reportError(ex);
# Line 178 | Line 184 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
184          ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
185          
186          try {      // for error handling
187 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
187 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
188                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189                  match(_t,MOLECULE);
190                  _t = _t->getFirstChild();
191 < #line 90 "MDTreeParser.g"
191 > #line 103 "MDTreeParser.g"
192                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193 < #line 188 "MDTreeParser.cpp"
193 > #line 194 "MDTreeParser.cpp"
194                  { // ( ... )*
195                  for (;;) {
196                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 194 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200                                  _t = _retTree;
201                          }
202                          else {
203 <                                goto _loop31;
203 >                                goto _loop36;
204                          }
205                          
206                  }
207 <                _loop31:;
207 >                _loop36:;
208                  } // ( ... )*
209                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210                  match(_t,ENDBLOCK);
211                  _t = _t->getNextSibling();
212 <                _t = __t29;
212 >                _t = __t34;
213                  _t = _t->getNextSibling();
214 < #line 92 "MDTreeParser.g"
214 > #line 105 "MDTreeParser.g"
215                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216 < #line 211 "MDTreeParser.cpp"
216 > #line 217 "MDTreeParser.cpp"
217          }
218          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219                  reportError(ex);
# Line 221 | 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 69 "MDTreeParser.g"
234 > #line 77 "MDTreeParser.g"
235                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236 < #line 231 "MDTreeParser.cpp"
236 > #line 237 "MDTreeParser.cpp"
237                  { // ( ... )*
238                  for (;;) {
239                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 237 | 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 71 "MDTreeParser.g"
257 > #line 79 "MDTreeParser.g"
258                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259 < #line 254 "MDTreeParser.cpp"
259 > #line 260 "MDTreeParser.cpp"
260          }
261          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262                  reportError(ex);
# Line 264 | 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 74 "MDTreeParser.g"
277 > #line 82 "MDTreeParser.g"
278                  RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279 < #line 274 "MDTreeParser.cpp"
279 > #line 280 "MDTreeParser.cpp"
280                  { // ( ... )*
281                  for (;;) {
282                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 280 | 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 76 "MDTreeParser.g"
300 > #line 84 "MDTreeParser.g"
301                  blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302 < #line 297 "MDTreeParser.cpp"
302 > #line 303 "MDTreeParser.cpp"
303          }
304          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305                  reportError(ex);
# Line 307 | 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 79 "MDTreeParser.g"
320 > #line 87 "MDTreeParser.g"
321                  FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322 < #line 317 "MDTreeParser.cpp"
322 > #line 323 "MDTreeParser.cpp"
323                  { // ( ... )*
324                  for (;;) {
325                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 323 | 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 81 "MDTreeParser.g"
343 > #line 89 "MDTreeParser.g"
344                  blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345 < #line 340 "MDTreeParser.cpp"
345 > #line 346 "MDTreeParser.cpp"
346          }
347          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348                  reportError(ex);
# Line 350 | 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 84 "MDTreeParser.g"
363 > #line 92 "MDTreeParser.g"
364                  RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365 < #line 360 "MDTreeParser.cpp"
365 > #line 366 "MDTreeParser.cpp"
366                  { // ( ... )*
367                  for (;;) {
368                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 366 | 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 86 "MDTreeParser.g"
386 > #line 94 "MDTreeParser.g"
387                  blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
388 < #line 383 "MDTreeParser.cpp"
388 > #line 389 "MDTreeParser.cpp"
389 >        }
390 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
391 >                reportError(ex);
392 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
393 >                        _t = _t->getNextSibling();
394          }
395 +        _retTree = _t;
396 + }
397 +
398 + void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
399 +        ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
400 +        
401 +        try {      // for error handling
402 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
403 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
404 +                match(_t,MINIMIZER);
405 +                _t = _t->getFirstChild();
406 + #line 97 "MDTreeParser.g"
407 +                MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
408 + #line 409 "MDTreeParser.cpp"
409 +                { // ( ... )*
410 +                for (;;) {
411 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
412 +                                _t = ASTNULL;
413 +                        if ((_t->getType() == ASSIGNEQUAL)) {
414 +                                assignment(_t);
415 +                                _t = _retTree;
416 +                        }
417 +                        else {
418 +                                goto _loop32;
419 +                        }
420 +                        
421 +                }
422 +                _loop32:;
423 +                } // ( ... )*
424 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
425 +                match(_t,ENDBLOCK);
426 +                _t = _t->getNextSibling();
427 +                _t = __t30;
428 +                _t = _t->getNextSibling();
429 + #line 99 "MDTreeParser.g"
430 +                blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
431 + #line 432 "MDTreeParser.cpp"
432 +        }
433          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
434                  reportError(ex);
435                  if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 395 | Line 444 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
444          ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447 < #line 49 "MDTreeParser.g"
447 > #line 50 "MDTreeParser.g"
448          
449          int ival;
450 <        RealType dval;
450 >        RealType dval, x, y, z;
451 >        Vector3d dvec;
452          
453 < #line 404 "MDTreeParser.cpp"
453 > #line 454 "MDTreeParser.cpp"
454          
455          try {      // for error handling
456                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 411 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
461                  {
462                          ival=intConst(_t);
463                          _t = _retTree;
464 < #line 54 "MDTreeParser.g"
464 > #line 56 "MDTreeParser.g"
465                          blockStack.top()->assign(id->getText(), ival);
466 < #line 417 "MDTreeParser.cpp"
466 > #line 467 "MDTreeParser.cpp"
467                          break;
468                  }
469                  case NUM_FLOAT:
# Line 421 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
471                  {
472                          dval=floatConst(_t);
473                          _t = _retTree;
474 < #line 55 "MDTreeParser.g"
474 > #line 57 "MDTreeParser.g"
475                          blockStack.top()->assign(id->getText(), dval);
476 < #line 427 "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 56 "MDTreeParser.g"
516 > #line 64 "MDTreeParser.g"
517                          blockStack.top()->assign(id->getText(), str1->getText());
518 < #line 437 "MDTreeParser.cpp"
518 > #line 519 "MDTreeParser.cpp"
519                          break;
520                  }
521                  case StringLiteral:
# Line 441 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523                          str2 = _t;
524                          match(_t,StringLiteral);
525                          _t = _t->getNextSibling();
526 < #line 57 "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 450 "MDTreeParser.cpp"
531 > #line 532 "MDTreeParser.cpp"
532                          break;
533                  }
534                  default:
# Line 464 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546   }
547  
548   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549 < #line 280 "MDTreeParser.g"
549 > #line 294 "MDTreeParser.g"
550          int ival;
551 < #line 470 "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 480 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562                          i1 = _t;
563                          match(_t,NUM_INT);
564                          _t = _t->getNextSibling();
565 < #line 281 "MDTreeParser.g"
565 > #line 295 "MDTreeParser.g"
566                          ival = lexi_cast<int>(i1->getText());
567 < #line 486 "MDTreeParser.cpp"
567 > #line 568 "MDTreeParser.cpp"
568                          break;
569                  }
570                  case NUM_LONG:
# Line 490 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572                          i2 = _t;
573                          match(_t,NUM_LONG);
574                          _t = _t->getNextSibling();
575 < #line 282 "MDTreeParser.g"
575 > #line 296 "MDTreeParser.g"
576                          ival = lexi_cast<int>(i2->getText());
577 < #line 496 "MDTreeParser.cpp"
577 > #line 578 "MDTreeParser.cpp"
578                          break;
579                  }
580                  default:
# Line 511 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593   }
594  
595   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596 < #line 294 "MDTreeParser.g"
596 > #line 306 "MDTreeParser.g"
597          RealType dval;
598 < #line 517 "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 527 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609                          d1 = _t;
610                          match(_t,NUM_FLOAT);
611                          _t = _t->getNextSibling();
612 < #line 295 "MDTreeParser.g"
612 > #line 307 "MDTreeParser.g"
613                          dval = lexi_cast<RealType>(d1->getText());
614 < #line 533 "MDTreeParser.cpp"
614 > #line 615 "MDTreeParser.cpp"
615                          break;
616                  }
617                  case NUM_DOUBLE:
# Line 537 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619                          d2 = _t;
620                          match(_t,NUM_DOUBLE);
621                          _t = _t->getNextSibling();
622 < #line 296 "MDTreeParser.g"
622 > #line 308 "MDTreeParser.g"
623                          dval = lexi_cast<RealType>(d2->getText());
624 < #line 543 "MDTreeParser.cpp"
624 > #line 625 "MDTreeParser.cpp"
625                          break;
626                  }
627                  default:
# Line 557 | Line 639 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
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);
679 +                }
680 +                }
681 +        }
682 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683 +                reportError(ex);
684 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
685 +                        _t = _t->getNextSibling();
686 +        }
687 +        _retTree = _t;
688 +        return dval;
689 + }
690 +
691   void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
692          ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
693          
# Line 634 | 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 106 "MDTreeParser.g"
768 > #line 119 "MDTreeParser.g"
769          
770          int index;
771          
772 < #line 642 "MDTreeParser.cpp"
772 > #line 773 "MDTreeParser.cpp"
773          
774          try {      // for error handling
775 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_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 110 "MDTreeParser.g"
781 > #line 123 "MDTreeParser.g"
782                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783 < #line 653 "MDTreeParser.cpp"
783 > #line 784 "MDTreeParser.cpp"
784                  { // ( ... )*
785                  for (;;) {
786                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 659 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790                                  _t = _retTree;
791                          }
792                          else {
793 <                                goto _loop36;
793 >                                goto _loop41;
794                          }
795                          
796                  }
797 <                _loop36:;
797 >                _loop41:;
798                  } // ( ... )*
799 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
799 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800                  match(_t,ENDBLOCK);
801                  _t = _t->getNextSibling();
802 <                _t = __t34;
802 >                _t = __t39;
803                  _t = _t->getNextSibling();
804 < #line 112 "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 681 "MDTreeParser.cpp"
811 > #line 812 "MDTreeParser.cpp"
812          }
813          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814                  reportError(ex);
# Line 691 | 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 __t41 = _t;
826 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_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 132 "MDTreeParser.g"
829 > #line 145 "MDTreeParser.g"
830                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831 < #line 701 "MDTreeParser.cpp"
831 > #line 832 "MDTreeParser.cpp"
832                  { // ( ... )*
833                  for (;;) {
834                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 707 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838                                  _t = _retTree;
839                          }
840                          else {
841 <                                goto _loop43;
841 >                                goto _loop48;
842                          }
843                          
844                  }
845 <                _loop43:;
845 >                _loop48:;
846                  } // ( ... )*
847 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
847 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848                  match(_t,ENDBLOCK);
849                  _t = _t->getNextSibling();
850 <                _t = __t41;
850 >                _t = __t46;
851                  _t = _t->getNextSibling();
852 < #line 134 "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 728 "MDTreeParser.cpp"
858 > #line 859 "MDTreeParser.cpp"
859          }
860          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861                  reportError(ex);
# Line 738 | 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 __t47 = _t;
873 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_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 150 "MDTreeParser.g"
876 > #line 163 "MDTreeParser.g"
877                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878 < #line 748 "MDTreeParser.cpp"
878 > #line 879 "MDTreeParser.cpp"
879                  { // ( ... )*
880                  for (;;) {
881                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 754 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885                                  _t = _retTree;
886                          }
887                          else {
888 <                                goto _loop49;
888 >                                goto _loop54;
889                          }
890                          
891                  }
892 <                _loop49:;
892 >                _loop54:;
893                  } // ( ... )*
894 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
894 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895                  match(_t,ENDBLOCK);
896                  _t = _t->getNextSibling();
897 <                _t = __t47;
897 >                _t = __t52;
898                  _t = _t->getNextSibling();
899 < #line 152 "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 776 "MDTreeParser.cpp"
906 > #line 907 "MDTreeParser.cpp"
907          }
908          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909                  reportError(ex);
# Line 786 | 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 __t53 = _t;
921 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_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 169 "MDTreeParser.g"
924 > #line 182 "MDTreeParser.g"
925                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926 < #line 796 "MDTreeParser.cpp"
926 > #line 927 "MDTreeParser.cpp"
927                  { // ( ... )*
928                  for (;;) {
929                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 802 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933                                  _t = _retTree;
934                          }
935                          else {
936 <                                goto _loop55;
936 >                                goto _loop60;
937                          }
938                          
939                  }
940 <                _loop55:;
940 >                _loop60:;
941                  } // ( ... )*
942 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
942 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943                  match(_t,ENDBLOCK);
944                  _t = _t->getNextSibling();
945 <                _t = __t53;
945 >                _t = __t58;
946                  _t = _t->getNextSibling();
947 < #line 171 "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 824 "MDTreeParser.cpp"
954 > #line 955 "MDTreeParser.cpp"
955          }
956          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957                  reportError(ex);
# Line 834 | 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 __t59 = _t;
969 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_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 188 "MDTreeParser.g"
972 > #line 201 "MDTreeParser.g"
973                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974 < #line 844 "MDTreeParser.cpp"
974 > #line 975 "MDTreeParser.cpp"
975                  { // ( ... )*
976                  for (;;) {
977                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 850 | Line 981 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
981                                  _t = _retTree;
982                          }
983                          else {
984 <                                goto _loop61;
984 >                                goto _loop66;
985                          }
986                          
987                  }
988 <                _loop61:;
988 >                _loop66:;
989                  } // ( ... )*
990 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
990 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991                  match(_t,ENDBLOCK);
992                  _t = _t->getNextSibling();
993 <                _t = __t59;
993 >                _t = __t64;
994                  _t = _t->getNextSibling();
995 < #line 190 "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 872 "MDTreeParser.cpp"
1002 > #line 1003 "MDTreeParser.cpp"
1003          }
1004          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005                  reportError(ex);
# Line 880 | 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 207 "MDTreeParser.g"
1014 > #line 220 "MDTreeParser.g"
1015          
1016          int index;
1017          
1018 < #line 888 "MDTreeParser.cpp"
1018 > #line 1019 "MDTreeParser.cpp"
1019          
1020          try {      // for error handling
1021 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
1022 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_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 211 "MDTreeParser.g"
1027 > #line 224 "MDTreeParser.g"
1028                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029 < #line 899 "MDTreeParser.cpp"
1029 > #line 1030 "MDTreeParser.cpp"
1030                  { // ( ... )*
1031                  for (;;) {
1032                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 905 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036                                  _t = _retTree;
1037                          }
1038                          else {
1039 <                                goto _loop67;
1039 >                                goto _loop72;
1040                          }
1041                          
1042                  }
1043 <                _loop67:;
1043 >                _loop72:;
1044                  } // ( ... )*
1045 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1045 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046                  match(_t,ENDBLOCK);
1047                  _t = _t->getNextSibling();
1048 <                _t = __t65;
1048 >                _t = __t70;
1049                  _t = _t->getNextSibling();
1050 < #line 213 "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 927 "MDTreeParser.cpp"
1057 > #line 1058 "MDTreeParser.cpp"
1058          }
1059          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060                  reportError(ex);
# Line 937 | 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 __t71 = _t;
1072 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_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 230 "MDTreeParser.g"
1075 > #line 243 "MDTreeParser.g"
1076                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077 < #line 947 "MDTreeParser.cpp"
1077 > #line 1078 "MDTreeParser.cpp"
1078                  { // ( ... )*
1079                  for (;;) {
1080                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 953 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084                                  _t = _retTree;
1085                          }
1086                          else {
1087 <                                goto _loop73;
1087 >                                goto _loop78;
1088                          }
1089                          
1090                  }
1091 <                _loop73:;
1091 >                _loop78:;
1092                  } // ( ... )*
1093 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1093 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094                  match(_t,ENDBLOCK);
1095                  _t = _t->getNextSibling();
1096 <                _t = __t71;
1096 >                _t = __t76;
1097                  _t = _t->getNextSibling();
1098 < #line 232 "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 975 "MDTreeParser.cpp"
1105 > #line 1106 "MDTreeParser.cpp"
1106          }
1107          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108                  reportError(ex);
# Line 983 | 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 249 "MDTreeParser.g"
1117 > #line 262 "MDTreeParser.g"
1118          int ival;
1119 < #line 989 "MDTreeParser.cpp"
1119 > #line 1120 "MDTreeParser.cpp"
1120          
1121          try {      // for error handling
1122 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1123 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 250 "MDTreeParser.g"
1128 > #line 263 "MDTreeParser.g"
1129                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130 < #line 1000 "MDTreeParser.cpp"
1130 > #line 1131 "MDTreeParser.cpp"
1131                  { // ( ... )*
1132                  for (;;) {
1133                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1006 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137                                  _t = _retTree;
1138                          }
1139                          else {
1140 <                                goto _loop79;
1140 >                                goto _loop84;
1141                          }
1142                          
1143                  }
1144 <                _loop79:;
1144 >                _loop84:;
1145                  } // ( ... )*
1146 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1146 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147                  match(_t,ENDBLOCK);
1148                  _t = _t->getNextSibling();
1149 <                _t = __t77;
1149 >                _t = __t82;
1150                  _t = _t->getNextSibling();
1151 < #line 252 "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 1028 "MDTreeParser.cpp"
1158 > #line 1159 "MDTreeParser.cpp"
1159          }
1160          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161                  reportError(ex);
# Line 1036 | 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 120 "MDTreeParser.g"
1170 > #line 133 "MDTreeParser.g"
1171          
1172          vector<RealType> dvec;
1173          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174          
1175          
1176 < #line 1046 "MDTreeParser.cpp"
1176 > #line 1177 "MDTreeParser.cpp"
1177          
1178          try {      // for error handling
1179                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1056 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187                  }
1188                  case POSITION:
1189                  {
1190 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t38 = _t;
1191 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_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 = __t38;
1196 >                        _t = __t43;
1197                          _t = _t->getNextSibling();
1198 < #line 127 "MDTreeParser.g"
1198 > #line 140 "MDTreeParser.g"
1199                          currAtomStamp->setPosition(dvec);
1200 < #line 1070 "MDTreeParser.cpp"
1200 > #line 1201 "MDTreeParser.cpp"
1201                          break;
1202                  }
1203                  case ORIENTATION:
1204                  {
1205 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1206 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_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 = __t39;
1211 >                        _t = __t44;
1212                          _t = _t->getNextSibling();
1213 < #line 128 "MDTreeParser.g"
1213 > #line 141 "MDTreeParser.g"
1214                          currAtomStamp->setOrientation(dvec);
1215 < #line 1085 "MDTreeParser.cpp"
1215 > #line 1216 "MDTreeParser.cpp"
1216                          break;
1217                  }
1218                  default:
# Line 1099 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230   }
1231  
1232   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 < #line 265 "MDTreeParser.g"
1233 > #line 278 "MDTreeParser.g"
1234          vector<RealType> dvec;
1235 < #line 1105 "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 265 "MDTreeParser.g"
1237 > #line 278 "MDTreeParser.g"
1238          
1239          RealType dval;
1240          
1241 < #line 1111 "MDTreeParser.cpp"
1241 > #line 1242 "MDTreeParser.cpp"
1242          
1243          try {      // for error handling
1244                  { // ( ... )+
1245 <                int _cnt83=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 269 "MDTreeParser.g"
1252 > #line 282 "MDTreeParser.g"
1253                                  dvec.push_back(dval);
1254 < #line 1124 "MDTreeParser.cpp"
1254 > #line 1255 "MDTreeParser.cpp"
1255                          }
1256                          else {
1257 <                                if ( _cnt83>=1 ) { goto _loop83; } 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 <                        _cnt83++;
1260 >                        _cnt88++;
1261                  }
1262 <                _loop83:;
1262 >                _loop88:;
1263                  }  // ( ... )+
1264          }
1265          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1142 | 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 141 "MDTreeParser.g"
1276 > #line 154 "MDTreeParser.g"
1277          
1278          vector<int> ivec;
1279          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280          
1281 < #line 1151 "MDTreeParser.cpp"
1281 > #line 1282 "MDTreeParser.cpp"
1282          
1283          try {      // for error handling
1284                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1161 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292                  }
1293                  case MEMBERS:
1294                  {
1295 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1296 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_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 = __t45;
1301 >                        _t = __t50;
1302                          _t = _t->getNextSibling();
1303 < #line 147 "MDTreeParser.g"
1303 > #line 160 "MDTreeParser.g"
1304                          currBondStamp->setMembers(ivec);
1305 < #line 1175 "MDTreeParser.cpp"
1305 > #line 1306 "MDTreeParser.cpp"
1306                          break;
1307                  }
1308                  default:
# Line 1189 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320   }
1321  
1322   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323 < #line 272 "MDTreeParser.g"
1323 > #line 286 "MDTreeParser.g"
1324          vector<int> ivec;
1325 < #line 1195 "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 272 "MDTreeParser.g"
1327 > #line 286 "MDTreeParser.g"
1328          
1329          int ival;
1330          
1331 < #line 1201 "MDTreeParser.cpp"
1331 > #line 1332 "MDTreeParser.cpp"
1332          
1333          try {      // for error handling
1334                  { // ( ... )+
1335 <                int _cnt86=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 276 "MDTreeParser.g"
1342 > #line 290 "MDTreeParser.g"
1343                                  ivec.push_back(ival);
1344 < #line 1214 "MDTreeParser.cpp"
1344 > #line 1345 "MDTreeParser.cpp"
1345                          }
1346                          else {
1347 <                                if ( _cnt86>=1 ) { goto _loop86; } 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 <                        _cnt86++;
1350 >                        _cnt91++;
1351                  }
1352 <                _loop86:;
1352 >                _loop91:;
1353                  }  // ( ... )+
1354          }
1355          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1232 | 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 160 "MDTreeParser.g"
1366 > #line 173 "MDTreeParser.g"
1367          
1368          vector<int> ivec;
1369          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370          
1371 < #line 1241 "MDTreeParser.cpp"
1371 > #line 1372 "MDTreeParser.cpp"
1372          
1373          try {      // for error handling
1374                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1251 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382                  }
1383                  case MEMBERS:
1384                  {
1385 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1386 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_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 = __t51;
1391 >                        _t = __t56;
1392                          _t = _t->getNextSibling();
1393 < #line 166 "MDTreeParser.g"
1393 > #line 179 "MDTreeParser.g"
1394                          currBendStamp->setMembers(ivec);
1395 < #line 1265 "MDTreeParser.cpp"
1395 > #line 1396 "MDTreeParser.cpp"
1396                          break;
1397                  }
1398                  default:
# Line 1280 | 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 179 "MDTreeParser.g"
1414 > #line 192 "MDTreeParser.g"
1415          
1416          vector<int> ivec;
1417          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418          
1419 < #line 1289 "MDTreeParser.cpp"
1419 > #line 1420 "MDTreeParser.cpp"
1420          
1421          try {      // for error handling
1422                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1299 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430                  }
1431                  case MEMBERS:
1432                  {
1433 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1434 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_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 = __t57;
1439 >                        _t = __t62;
1440                          _t = _t->getNextSibling();
1441 < #line 185 "MDTreeParser.g"
1441 > #line 198 "MDTreeParser.g"
1442                          currTorsionStamp->setMembers(ivec);
1443 < #line 1313 "MDTreeParser.cpp"
1443 > #line 1444 "MDTreeParser.cpp"
1444                          break;
1445                  }
1446                  default:
# Line 1328 | 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 198 "MDTreeParser.g"
1462 > #line 211 "MDTreeParser.g"
1463          
1464          int icent;
1465          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466          
1467 < #line 1337 "MDTreeParser.cpp"
1467 > #line 1468 "MDTreeParser.cpp"
1468          
1469          try {      // for error handling
1470                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1347 | Line 1478 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1478                  }
1479                  case CENTER:
1480                  {
1481 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1482 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_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 = __t63;
1487 >                        _t = __t68;
1488                          _t = _t->getNextSibling();
1489 < #line 204 "MDTreeParser.g"
1489 > #line 217 "MDTreeParser.g"
1490                          currInversionStamp->setCenter(icent);
1491 < #line 1361 "MDTreeParser.cpp"
1491 > #line 1492 "MDTreeParser.cpp"
1492                          break;
1493                  }
1494                  default:
# Line 1376 | 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 221 "MDTreeParser.g"
1510 > #line 234 "MDTreeParser.g"
1511          
1512          vector<int> ivec;
1513          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514          
1515 < #line 1385 "MDTreeParser.cpp"
1515 > #line 1516 "MDTreeParser.cpp"
1516          
1517          try {      // for error handling
1518                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1395 | Line 1526 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1526                  }
1527                  case MEMBERS:
1528                  {
1529 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1530 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_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 = __t69;
1535 >                        _t = __t74;
1536                          _t = _t->getNextSibling();
1537 < #line 227 "MDTreeParser.g"
1537 > #line 240 "MDTreeParser.g"
1538                          currRigidBodyStamp->setMembers(ivec);
1539 < #line 1409 "MDTreeParser.cpp"
1539 > #line 1540 "MDTreeParser.cpp"
1540                          break;
1541                  }
1542                  default:
# Line 1424 | 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 240 "MDTreeParser.g"
1558 > #line 253 "MDTreeParser.g"
1559          
1560          vector<int> ivec;
1561          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562          
1563 < #line 1433 "MDTreeParser.cpp"
1563 > #line 1564 "MDTreeParser.cpp"
1564          
1565          try {      // for error handling
1566                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1443 | Line 1574 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1574                  }
1575                  case MEMBERS:
1576                  {
1577 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1578 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_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 = __t75;
1583 >                        _t = __t80;
1584                          _t = _t->getNextSibling();
1585 < #line 246 "MDTreeParser.g"
1585 > #line 259 "MDTreeParser.g"
1586                          currCutoffGroupStamp->setMembers(ivec);
1587 < #line 1457 "MDTreeParser.cpp"
1587 > #line 1588 "MDTreeParser.cpp"
1588                          break;
1589                  }
1590                  default:
# Line 1485 | Line 1616 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1616          _retTree = _t;
1617   }
1618  
1488 – RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1489 – #line 286 "MDTreeParser.g"
1490 –        RealType dval;
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;
1495 –        
1496 –        try {      // for error handling
1497 –                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1498 –                        _t = ASTNULL;
1499 –                switch ( _t->getType()) {
1500 –                case NUM_INT:
1501 –                case NUM_LONG:
1502 –                {
1503 –                        ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1504 –                        intConst(_t);
1505 –                        _t = _retTree;
1506 – #line 288 "MDTreeParser.g"
1507 –                        dval = lexi_cast<RealType>(ic->getText());
1508 – #line 1509 "MDTreeParser.cpp"
1509 –                        break;
1510 –                }
1511 –                case NUM_FLOAT:
1512 –                case NUM_DOUBLE:
1513 –                {
1514 –                        fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515 –                        floatConst(_t);
1516 –                        _t = _retTree;
1517 – #line 289 "MDTreeParser.g"
1518 –                        dval = lexi_cast<RealType>(fc->getText());
1519 – #line 1520 "MDTreeParser.cpp"
1520 –                        break;
1521 –                }
1522 –                default:
1523 –                {
1524 –                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1525 –                }
1526 –                }
1527 –        }
1528 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1529 –                reportError(ex);
1530 –                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1531 –                        _t = _t->getNextSibling();
1532 –        }
1533 –        _retTree = _t;
1534 –        return dval;
1535 – }
1536 –
1619   void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620   {
1621   }
# Line 1560 | Line 1642 | const char* MDTreeParser::tokenNames[] = {
1642          "\"orientation\"",
1643          "\"flucQ\"",
1644          "\"RNEMD\"",
1645 +        "\"minimizer\"",
1646          "ENDBLOCK",
1647          "ID",
1648          "ASSIGNEQUAL",
# Line 1597 | Line 1680 | const char* MDTreeParser::tokenNames[] = {
1680          0
1681   };
1682  
1683 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 19923184UL, 0UL, 0UL, 0UL };
1684 < // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ASSIGNEQUAL
1683 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1684 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1685 > // ASSIGNEQUAL
1686   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1687 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 16842496UL, 0UL, 0UL, 0UL };
1687 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1688   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1689   // "fragment" ASSIGNEQUAL
1690   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);

Diff Legend

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