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 1776 by gezelter, Thu Aug 9 15:52:59 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "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 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 +                case MINIMIZER:
96 +                {
97 +                        minimizerblock(_t);
98 +                        _t = _retTree;
99 +                        break;
100 +                }
101                  default:
102                  {
103                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 123 | 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 63 "MDTreeParser.g"
148 > #line 72 "MDTreeParser.g"
149                  Component* currComponet = new Component(); blockStack.push(currComponet);
150 < #line 133 "MDTreeParser.cpp"
150 > #line 151 "MDTreeParser.cpp"
151                  { // ( ... )*
152                  for (;;) {
153                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 139 | 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 65 "MDTreeParser.g"
171 > #line 74 "MDTreeParser.g"
172                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173 < #line 156 "MDTreeParser.cpp"
173 > #line 174 "MDTreeParser.cpp"
174          }
175          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176                  reportError(ex);
# Line 166 | 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 __t21 = _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 78 "MDTreeParser.g"
191 > #line 103 "MDTreeParser.g"
192                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193 < #line 176 "MDTreeParser.cpp"
193 > #line 194 "MDTreeParser.cpp"
194                  { // ( ... )*
195                  for (;;) {
196                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 182 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
200                                  _t = _retTree;
201                          }
202                          else {
203 <                                goto _loop23;
203 >                                goto _loop36;
204                          }
205                          
206                  }
207 <                _loop23:;
207 >                _loop36:;
208                  } // ( ... )*
209                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210                  match(_t,ENDBLOCK);
211                  _t = _t->getNextSibling();
212 <                _t = __t21;
212 >                _t = __t34;
213                  _t = _t->getNextSibling();
214 < #line 80 "MDTreeParser.g"
214 > #line 105 "MDTreeParser.g"
215                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216 < #line 199 "MDTreeParser.cpp"
216 > #line 217 "MDTreeParser.cpp"
217          }
218          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219                  reportError(ex);
# Line 209 | 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 68 "MDTreeParser.g"
234 > #line 77 "MDTreeParser.g"
235                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236 < #line 219 "MDTreeParser.cpp"
236 > #line 237 "MDTreeParser.cpp"
237                  { // ( ... )*
238                  for (;;) {
239                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 225 | 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 70 "MDTreeParser.g"
257 > #line 79 "MDTreeParser.g"
258                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259 < #line 242 "MDTreeParser.cpp"
259 > #line 260 "MDTreeParser.cpp"
260          }
261          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262                  reportError(ex);
# Line 252 | 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 73 "MDTreeParser.g"
277 > #line 82 "MDTreeParser.g"
278                  RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279 < #line 262 "MDTreeParser.cpp"
279 > #line 280 "MDTreeParser.cpp"
280                  { // ( ... )*
281                  for (;;) {
282                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 268 | 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 75 "MDTreeParser.g"
300 > #line 84 "MDTreeParser.g"
301                  blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302 < #line 285 "MDTreeParser.cpp"
302 > #line 303 "MDTreeParser.cpp"
303 >        }
304 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305 >                reportError(ex);
306 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
307 >                        _t = _t->getNextSibling();
308 >        }
309 >        _retTree = _t;
310 > }
311 >
312 > void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t22 = _t;
317 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
318 >                match(_t,FLUCQ);
319 >                _t = _t->getFirstChild();
320 > #line 87 "MDTreeParser.g"
321 >                FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
322 > #line 323 "MDTreeParser.cpp"
323 >                { // ( ... )*
324 >                for (;;) {
325 >                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
326 >                                _t = ASTNULL;
327 >                        if ((_t->getType() == ASSIGNEQUAL)) {
328 >                                assignment(_t);
329 >                                _t = _retTree;
330 >                        }
331 >                        else {
332 >                                goto _loop24;
333 >                        }
334 >                        
335 >                }
336 >                _loop24:;
337 >                } // ( ... )*
338 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
339 >                match(_t,ENDBLOCK);
340 >                _t = _t->getNextSibling();
341 >                _t = __t22;
342 >                _t = _t->getNextSibling();
343 > #line 89 "MDTreeParser.g"
344 >                blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
345 > #line 346 "MDTreeParser.cpp"
346          }
347          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
348                  reportError(ex);
# Line 291 | Line 352 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(
352          _retTree = _t;
353   }
354  
355 + void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t26 = _t;
360 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
361 +                match(_t,RNEMD);
362 +                _t = _t->getFirstChild();
363 + #line 92 "MDTreeParser.g"
364 +                RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);
365 + #line 366 "MDTreeParser.cpp"
366 +                { // ( ... )*
367 +                for (;;) {
368 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
369 +                                _t = ASTNULL;
370 +                        if ((_t->getType() == ASSIGNEQUAL)) {
371 +                                assignment(_t);
372 +                                _t = _retTree;
373 +                        }
374 +                        else {
375 +                                goto _loop28;
376 +                        }
377 +                        
378 +                }
379 +                _loop28:;
380 +                } // ( ... )*
381 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
382 +                match(_t,ENDBLOCK);
383 +                _t = _t->getNextSibling();
384 +                _t = __t26;
385 +                _t = _t->getNextSibling();
386 + #line 94 "MDTreeParser.g"
387 +                blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
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 )
436 +                        _t = _t->getNextSibling();
437 +        }
438 +        _retTree = _t;
439 + }
440 +
441   void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
442          ANTLR_USE_NAMESPACE(antlr)RefAST id
443   ) {
444          ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
445          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
446          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
447 < #line 48 "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 306 "MDTreeParser.cpp"
453 > #line 454 "MDTreeParser.cpp"
454          
455          try {      // for error handling
456                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 313 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
461                  {
462                          ival=intConst(_t);
463                          _t = _retTree;
464 < #line 53 "MDTreeParser.g"
464 > #line 56 "MDTreeParser.g"
465                          blockStack.top()->assign(id->getText(), ival);
466 < #line 319 "MDTreeParser.cpp"
466 > #line 467 "MDTreeParser.cpp"
467                          break;
468                  }
469                  case NUM_FLOAT:
# Line 323 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
471                  {
472                          dval=floatConst(_t);
473                          _t = _retTree;
474 < #line 54 "MDTreeParser.g"
474 > #line 57 "MDTreeParser.g"
475                          blockStack.top()->assign(id->getText(), dval);
476 < #line 329 "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 55 "MDTreeParser.g"
516 > #line 64 "MDTreeParser.g"
517                          blockStack.top()->assign(id->getText(), str1->getText());
518 < #line 339 "MDTreeParser.cpp"
518 > #line 519 "MDTreeParser.cpp"
519                          break;
520                  }
521                  case StringLiteral:
# Line 343 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
523                          str2 = _t;
524                          match(_t,StringLiteral);
525                          _t = _t->getNextSibling();
526 < #line 56 "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 352 "MDTreeParser.cpp"
531 > #line 532 "MDTreeParser.cpp"
532                          break;
533                  }
534                  default:
# Line 366 | Line 546 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
546   }
547  
548   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549 < #line 268 "MDTreeParser.g"
549 > #line 294 "MDTreeParser.g"
550          int ival;
551 < #line 372 "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 382 | Line 562 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
562                          i1 = _t;
563                          match(_t,NUM_INT);
564                          _t = _t->getNextSibling();
565 < #line 269 "MDTreeParser.g"
565 > #line 295 "MDTreeParser.g"
566                          ival = lexi_cast<int>(i1->getText());
567 < #line 388 "MDTreeParser.cpp"
567 > #line 568 "MDTreeParser.cpp"
568                          break;
569                  }
570                  case NUM_LONG:
# Line 392 | Line 572 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
572                          i2 = _t;
573                          match(_t,NUM_LONG);
574                          _t = _t->getNextSibling();
575 < #line 270 "MDTreeParser.g"
575 > #line 296 "MDTreeParser.g"
576                          ival = lexi_cast<int>(i2->getText());
577 < #line 398 "MDTreeParser.cpp"
577 > #line 578 "MDTreeParser.cpp"
578                          break;
579                  }
580                  default:
# Line 413 | Line 593 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
593   }
594  
595   RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596 < #line 282 "MDTreeParser.g"
596 > #line 306 "MDTreeParser.g"
597          RealType dval;
598 < #line 419 "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 429 | Line 609 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
609                          d1 = _t;
610                          match(_t,NUM_FLOAT);
611                          _t = _t->getNextSibling();
612 < #line 283 "MDTreeParser.g"
612 > #line 307 "MDTreeParser.g"
613                          dval = lexi_cast<RealType>(d1->getText());
614 < #line 435 "MDTreeParser.cpp"
614 > #line 615 "MDTreeParser.cpp"
615                          break;
616                  }
617                  case NUM_DOUBLE:
# Line 439 | Line 619 | RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE
619                          d2 = _t;
620                          match(_t,NUM_DOUBLE);
621                          _t = _t->getNextSibling();
622 < #line 284 "MDTreeParser.g"
622 > #line 308 "MDTreeParser.g"
623                          dval = lexi_cast<RealType>(d2->getText());
624 < #line 445 "MDTreeParser.cpp"
624 > #line 625 "MDTreeParser.cpp"
625                          break;
626                  }
627                  default:
# Line 459 | 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 536 | 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 94 "MDTreeParser.g"
768 > #line 119 "MDTreeParser.g"
769          
770          int index;
771          
772 < #line 544 "MDTreeParser.cpp"
772 > #line 773 "MDTreeParser.cpp"
773          
774          try {      // for error handling
775 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
776 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_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 98 "MDTreeParser.g"
781 > #line 123 "MDTreeParser.g"
782                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783 < #line 555 "MDTreeParser.cpp"
783 > #line 784 "MDTreeParser.cpp"
784                  { // ( ... )*
785                  for (;;) {
786                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 561 | Line 790 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
790                                  _t = _retTree;
791                          }
792                          else {
793 <                                goto _loop28;
793 >                                goto _loop41;
794                          }
795                          
796                  }
797 <                _loop28:;
797 >                _loop41:;
798                  } // ( ... )*
799 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
799 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800                  match(_t,ENDBLOCK);
801                  _t = _t->getNextSibling();
802 <                _t = __t26;
802 >                _t = __t39;
803                  _t = _t->getNextSibling();
804 < #line 100 "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 583 "MDTreeParser.cpp"
811 > #line 812 "MDTreeParser.cpp"
812          }
813          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814                  reportError(ex);
# Line 593 | 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 __t33 = _t;
826 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_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 120 "MDTreeParser.g"
829 > #line 145 "MDTreeParser.g"
830                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831 < #line 603 "MDTreeParser.cpp"
831 > #line 832 "MDTreeParser.cpp"
832                  { // ( ... )*
833                  for (;;) {
834                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 609 | Line 838 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
838                                  _t = _retTree;
839                          }
840                          else {
841 <                                goto _loop35;
841 >                                goto _loop48;
842                          }
843                          
844                  }
845 <                _loop35:;
845 >                _loop48:;
846                  } // ( ... )*
847 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
847 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848                  match(_t,ENDBLOCK);
849                  _t = _t->getNextSibling();
850 <                _t = __t33;
850 >                _t = __t46;
851                  _t = _t->getNextSibling();
852 < #line 122 "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 630 "MDTreeParser.cpp"
858 > #line 859 "MDTreeParser.cpp"
859          }
860          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861                  reportError(ex);
# Line 640 | 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 __t39 = _t;
873 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_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 138 "MDTreeParser.g"
876 > #line 163 "MDTreeParser.g"
877                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878 < #line 650 "MDTreeParser.cpp"
878 > #line 879 "MDTreeParser.cpp"
879                  { // ( ... )*
880                  for (;;) {
881                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 656 | Line 885 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
885                                  _t = _retTree;
886                          }
887                          else {
888 <                                goto _loop41;
888 >                                goto _loop54;
889                          }
890                          
891                  }
892 <                _loop41:;
892 >                _loop54:;
893                  } // ( ... )*
894 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
894 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895                  match(_t,ENDBLOCK);
896                  _t = _t->getNextSibling();
897 <                _t = __t39;
897 >                _t = __t52;
898                  _t = _t->getNextSibling();
899 < #line 140 "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 678 "MDTreeParser.cpp"
906 > #line 907 "MDTreeParser.cpp"
907          }
908          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909                  reportError(ex);
# Line 688 | 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 __t45 = _t;
921 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_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 157 "MDTreeParser.g"
924 > #line 182 "MDTreeParser.g"
925                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926 < #line 698 "MDTreeParser.cpp"
926 > #line 927 "MDTreeParser.cpp"
927                  { // ( ... )*
928                  for (;;) {
929                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 704 | Line 933 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
933                                  _t = _retTree;
934                          }
935                          else {
936 <                                goto _loop47;
936 >                                goto _loop60;
937                          }
938                          
939                  }
940 <                _loop47:;
940 >                _loop60:;
941                  } // ( ... )*
942 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
942 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943                  match(_t,ENDBLOCK);
944                  _t = _t->getNextSibling();
945 <                _t = __t45;
945 >                _t = __t58;
946                  _t = _t->getNextSibling();
947 < #line 159 "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 726 "MDTreeParser.cpp"
954 > #line 955 "MDTreeParser.cpp"
955          }
956          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957                  reportError(ex);
# Line 736 | 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 __t51 = _t;
969 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_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 176 "MDTreeParser.g"
972 > #line 201 "MDTreeParser.g"
973                  InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974 < #line 746 "MDTreeParser.cpp"
974 > #line 975 "MDTreeParser.cpp"
975                  { // ( ... )*
976                  for (;;) {
977                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 752 | Line 981 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(
981                                  _t = _retTree;
982                          }
983                          else {
984 <                                goto _loop53;
984 >                                goto _loop66;
985                          }
986                          
987                  }
988 <                _loop53:;
988 >                _loop66:;
989                  } // ( ... )*
990 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
990 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991                  match(_t,ENDBLOCK);
992                  _t = _t->getNextSibling();
993 <                _t = __t51;
993 >                _t = __t64;
994                  _t = _t->getNextSibling();
995 < #line 178 "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 774 "MDTreeParser.cpp"
1002 > #line 1003 "MDTreeParser.cpp"
1003          }
1004          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005                  reportError(ex);
# Line 782 | 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 195 "MDTreeParser.g"
1014 > #line 220 "MDTreeParser.g"
1015          
1016          int index;
1017          
1018 < #line 790 "MDTreeParser.cpp"
1018 > #line 1019 "MDTreeParser.cpp"
1019          
1020          try {      // for error handling
1021 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1022 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_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 199 "MDTreeParser.g"
1027 > #line 224 "MDTreeParser.g"
1028                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029 < #line 801 "MDTreeParser.cpp"
1029 > #line 1030 "MDTreeParser.cpp"
1030                  { // ( ... )*
1031                  for (;;) {
1032                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 807 | Line 1036 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
1036                                  _t = _retTree;
1037                          }
1038                          else {
1039 <                                goto _loop59;
1039 >                                goto _loop72;
1040                          }
1041                          
1042                  }
1043 <                _loop59:;
1043 >                _loop72:;
1044                  } // ( ... )*
1045 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
1045 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046                  match(_t,ENDBLOCK);
1047                  _t = _t->getNextSibling();
1048 <                _t = __t57;
1048 >                _t = __t70;
1049                  _t = _t->getNextSibling();
1050 < #line 201 "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 829 "MDTreeParser.cpp"
1057 > #line 1058 "MDTreeParser.cpp"
1058          }
1059          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060                  reportError(ex);
# Line 839 | 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 __t63 = _t;
1072 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_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 218 "MDTreeParser.g"
1075 > #line 243 "MDTreeParser.g"
1076                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077 < #line 849 "MDTreeParser.cpp"
1077 > #line 1078 "MDTreeParser.cpp"
1078                  { // ( ... )*
1079                  for (;;) {
1080                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 855 | Line 1084 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
1084                                  _t = _retTree;
1085                          }
1086                          else {
1087 <                                goto _loop65;
1087 >                                goto _loop78;
1088                          }
1089                          
1090                  }
1091 <                _loop65:;
1091 >                _loop78:;
1092                  } // ( ... )*
1093 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
1093 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094                  match(_t,ENDBLOCK);
1095                  _t = _t->getNextSibling();
1096 <                _t = __t63;
1096 >                _t = __t76;
1097                  _t = _t->getNextSibling();
1098 < #line 220 "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 877 "MDTreeParser.cpp"
1105 > #line 1106 "MDTreeParser.cpp"
1106          }
1107          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108                  reportError(ex);
# Line 885 | 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 237 "MDTreeParser.g"
1117 > #line 262 "MDTreeParser.g"
1118          int ival;
1119 < #line 891 "MDTreeParser.cpp"
1119 > #line 1120 "MDTreeParser.cpp"
1120          
1121          try {      // for error handling
1122 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1123 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_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 238 "MDTreeParser.g"
1128 > #line 263 "MDTreeParser.g"
1129                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130 < #line 902 "MDTreeParser.cpp"
1130 > #line 1131 "MDTreeParser.cpp"
1131                  { // ( ... )*
1132                  for (;;) {
1133                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 908 | Line 1137 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
1137                                  _t = _retTree;
1138                          }
1139                          else {
1140 <                                goto _loop71;
1140 >                                goto _loop84;
1141                          }
1142                          
1143                  }
1144 <                _loop71:;
1144 >                _loop84:;
1145                  } // ( ... )*
1146 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1146 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147                  match(_t,ENDBLOCK);
1148                  _t = _t->getNextSibling();
1149 <                _t = __t69;
1149 >                _t = __t82;
1150                  _t = _t->getNextSibling();
1151 < #line 240 "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 930 "MDTreeParser.cpp"
1158 > #line 1159 "MDTreeParser.cpp"
1159          }
1160          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161                  reportError(ex);
# Line 938 | 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 108 "MDTreeParser.g"
1170 > #line 133 "MDTreeParser.g"
1171          
1172          vector<RealType> dvec;
1173          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
1174          
1175          
1176 < #line 948 "MDTreeParser.cpp"
1176 > #line 1177 "MDTreeParser.cpp"
1177          
1178          try {      // for error handling
1179                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 958 | Line 1187 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1187                  }
1188                  case POSITION:
1189                  {
1190 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
1191 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_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 = __t30;
1196 >                        _t = __t43;
1197                          _t = _t->getNextSibling();
1198 < #line 115 "MDTreeParser.g"
1198 > #line 140 "MDTreeParser.g"
1199                          currAtomStamp->setPosition(dvec);
1200 < #line 972 "MDTreeParser.cpp"
1200 > #line 1201 "MDTreeParser.cpp"
1201                          break;
1202                  }
1203                  case ORIENTATION:
1204                  {
1205 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
1206 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_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 = __t31;
1211 >                        _t = __t44;
1212                          _t = _t->getNextSibling();
1213 < #line 116 "MDTreeParser.g"
1213 > #line 141 "MDTreeParser.g"
1214                          currAtomStamp->setOrientation(dvec);
1215 < #line 987 "MDTreeParser.cpp"
1215 > #line 1216 "MDTreeParser.cpp"
1216                          break;
1217                  }
1218                  default:
# Line 1001 | Line 1230 | vector<RealType>  MDTreeParser::doubleNumberTuple(ANTL
1230   }
1231  
1232   vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 < #line 253 "MDTreeParser.g"
1233 > #line 278 "MDTreeParser.g"
1234          vector<RealType> dvec;
1235 < #line 1007 "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 253 "MDTreeParser.g"
1237 > #line 278 "MDTreeParser.g"
1238          
1239          RealType dval;
1240          
1241 < #line 1013 "MDTreeParser.cpp"
1241 > #line 1242 "MDTreeParser.cpp"
1242          
1243          try {      // for error handling
1244                  { // ( ... )+
1245 <                int _cnt75=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 257 "MDTreeParser.g"
1252 > #line 282 "MDTreeParser.g"
1253                                  dvec.push_back(dval);
1254 < #line 1026 "MDTreeParser.cpp"
1254 > #line 1255 "MDTreeParser.cpp"
1255                          }
1256                          else {
1257 <                                if ( _cnt75>=1 ) { goto _loop75; } 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 <                        _cnt75++;
1260 >                        _cnt88++;
1261                  }
1262 <                _loop75:;
1262 >                _loop88:;
1263                  }  // ( ... )+
1264          }
1265          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1044 | 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 129 "MDTreeParser.g"
1276 > #line 154 "MDTreeParser.g"
1277          
1278          vector<int> ivec;
1279          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280          
1281 < #line 1053 "MDTreeParser.cpp"
1281 > #line 1282 "MDTreeParser.cpp"
1282          
1283          try {      // for error handling
1284                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1063 | Line 1292 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1292                  }
1293                  case MEMBERS:
1294                  {
1295 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1296 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 = __t37;
1301 >                        _t = __t50;
1302                          _t = _t->getNextSibling();
1303 < #line 135 "MDTreeParser.g"
1303 > #line 160 "MDTreeParser.g"
1304                          currBondStamp->setMembers(ivec);
1305 < #line 1077 "MDTreeParser.cpp"
1305 > #line 1306 "MDTreeParser.cpp"
1306                          break;
1307                  }
1308                  default:
# Line 1091 | Line 1320 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1320   }
1321  
1322   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323 < #line 260 "MDTreeParser.g"
1323 > #line 286 "MDTreeParser.g"
1324          vector<int> ivec;
1325 < #line 1097 "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 260 "MDTreeParser.g"
1327 > #line 286 "MDTreeParser.g"
1328          
1329          int ival;
1330          
1331 < #line 1103 "MDTreeParser.cpp"
1331 > #line 1332 "MDTreeParser.cpp"
1332          
1333          try {      // for error handling
1334                  { // ( ... )+
1335 <                int _cnt78=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 264 "MDTreeParser.g"
1342 > #line 290 "MDTreeParser.g"
1343                                  ivec.push_back(ival);
1344 < #line 1116 "MDTreeParser.cpp"
1344 > #line 1345 "MDTreeParser.cpp"
1345                          }
1346                          else {
1347 <                                if ( _cnt78>=1 ) { goto _loop78; } 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 <                        _cnt78++;
1350 >                        _cnt91++;
1351                  }
1352 <                _loop78:;
1352 >                _loop91:;
1353                  }  // ( ... )+
1354          }
1355          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1134 | 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 148 "MDTreeParser.g"
1366 > #line 173 "MDTreeParser.g"
1367          
1368          vector<int> ivec;
1369          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370          
1371 < #line 1143 "MDTreeParser.cpp"
1371 > #line 1372 "MDTreeParser.cpp"
1372          
1373          try {      // for error handling
1374                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1153 | Line 1382 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1382                  }
1383                  case MEMBERS:
1384                  {
1385 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1386 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_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 = __t43;
1391 >                        _t = __t56;
1392                          _t = _t->getNextSibling();
1393 < #line 154 "MDTreeParser.g"
1393 > #line 179 "MDTreeParser.g"
1394                          currBendStamp->setMembers(ivec);
1395 < #line 1167 "MDTreeParser.cpp"
1395 > #line 1396 "MDTreeParser.cpp"
1396                          break;
1397                  }
1398                  default:
# Line 1182 | 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 167 "MDTreeParser.g"
1414 > #line 192 "MDTreeParser.g"
1415          
1416          vector<int> ivec;
1417          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418          
1419 < #line 1191 "MDTreeParser.cpp"
1419 > #line 1420 "MDTreeParser.cpp"
1420          
1421          try {      // for error handling
1422                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1201 | Line 1430 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1430                  }
1431                  case MEMBERS:
1432                  {
1433 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1434 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_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 = __t49;
1439 >                        _t = __t62;
1440                          _t = _t->getNextSibling();
1441 < #line 173 "MDTreeParser.g"
1441 > #line 198 "MDTreeParser.g"
1442                          currTorsionStamp->setMembers(ivec);
1443 < #line 1215 "MDTreeParser.cpp"
1443 > #line 1444 "MDTreeParser.cpp"
1444                          break;
1445                  }
1446                  default:
# Line 1230 | 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 186 "MDTreeParser.g"
1462 > #line 211 "MDTreeParser.g"
1463          
1464          int icent;
1465          InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466          
1467 < #line 1239 "MDTreeParser.cpp"
1467 > #line 1468 "MDTreeParser.cpp"
1468          
1469          try {      // for error handling
1470                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1249 | Line 1478 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP
1478                  }
1479                  case CENTER:
1480                  {
1481 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1482 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_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 = __t55;
1487 >                        _t = __t68;
1488                          _t = _t->getNextSibling();
1489 < #line 192 "MDTreeParser.g"
1489 > #line 217 "MDTreeParser.g"
1490                          currInversionStamp->setCenter(icent);
1491 < #line 1263 "MDTreeParser.cpp"
1491 > #line 1492 "MDTreeParser.cpp"
1492                          break;
1493                  }
1494                  default:
# Line 1278 | 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 209 "MDTreeParser.g"
1510 > #line 234 "MDTreeParser.g"
1511          
1512          vector<int> ivec;
1513          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514          
1515 < #line 1287 "MDTreeParser.cpp"
1515 > #line 1516 "MDTreeParser.cpp"
1516          
1517          try {      // for error handling
1518                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1297 | Line 1526 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1526                  }
1527                  case MEMBERS:
1528                  {
1529 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1530 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_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 = __t61;
1535 >                        _t = __t74;
1536                          _t = _t->getNextSibling();
1537 < #line 215 "MDTreeParser.g"
1537 > #line 240 "MDTreeParser.g"
1538                          currRigidBodyStamp->setMembers(ivec);
1539 < #line 1311 "MDTreeParser.cpp"
1539 > #line 1540 "MDTreeParser.cpp"
1540                          break;
1541                  }
1542                  default:
# Line 1326 | 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 228 "MDTreeParser.g"
1558 > #line 253 "MDTreeParser.g"
1559          
1560          vector<int> ivec;
1561          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562          
1563 < #line 1335 "MDTreeParser.cpp"
1563 > #line 1564 "MDTreeParser.cpp"
1564          
1565          try {      // for error handling
1566                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1345 | Line 1574 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1574                  }
1575                  case MEMBERS:
1576                  {
1577 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1578 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_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 = __t67;
1583 >                        _t = __t80;
1584                          _t = _t->getNextSibling();
1585 < #line 234 "MDTreeParser.g"
1585 > #line 259 "MDTreeParser.g"
1586                          currCutoffGroupStamp->setMembers(ivec);
1587 < #line 1359 "MDTreeParser.cpp"
1587 > #line 1588 "MDTreeParser.cpp"
1588                          break;
1589                  }
1590                  default:
# Line 1387 | Line 1616 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1616          _retTree = _t;
1617   }
1618  
1390 – RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391 – #line 274 "MDTreeParser.g"
1392 –        RealType dval;
1393 – #line 1394 "MDTreeParser.cpp"
1394 –        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1395 –        ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1396 –        ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 –        
1398 –        try {      // for error handling
1399 –                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1400 –                        _t = ASTNULL;
1401 –                switch ( _t->getType()) {
1402 –                case NUM_INT:
1403 –                case NUM_LONG:
1404 –                {
1405 –                        ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406 –                        intConst(_t);
1407 –                        _t = _retTree;
1408 – #line 276 "MDTreeParser.g"
1409 –                        dval = lexi_cast<RealType>(ic->getText());
1410 – #line 1411 "MDTreeParser.cpp"
1411 –                        break;
1412 –                }
1413 –                case NUM_FLOAT:
1414 –                case NUM_DOUBLE:
1415 –                {
1416 –                        fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417 –                        floatConst(_t);
1418 –                        _t = _retTree;
1419 – #line 277 "MDTreeParser.g"
1420 –                        dval = lexi_cast<RealType>(fc->getText());
1421 – #line 1422 "MDTreeParser.cpp"
1422 –                        break;
1423 –                }
1424 –                default:
1425 –                {
1426 –                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1427 –                }
1428 –                }
1429 –        }
1430 –        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1431 –                reportError(ex);
1432 –                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1433 –                        _t = _t->getNextSibling();
1434 –        }
1435 –        _retTree = _t;
1436 –        return dval;
1437 – }
1438 –
1619   void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620   {
1621   }
# Line 1460 | Line 1640 | const char* MDTreeParser::tokenNames[] = {
1640          "\"center\"",
1641          "\"position\"",
1642          "\"orientation\"",
1643 +        "\"flucQ\"",
1644 +        "\"RNEMD\"",
1645 +        "\"minimizer\"",
1646          "ENDBLOCK",
1647          "ID",
1648          "ASSIGNEQUAL",
# Line 1497 | Line 1680 | const char* MDTreeParser::tokenNames[] = {
1680          0
1681   };
1682  
1683 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1684 < // "component" "molecule" "zconstraint" "restraint" 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_[] = { 4259584UL, 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