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

Comparing trunk/src/mdParser/MDTreeParser.cpp (file contents):
Revision 810 by tim, Wed Dec 14 18:02:28 2005 UTC vs.
Revision 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.4: "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 117 | Line 117 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
117          ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
118          
119          try {      // for error handling
120 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
120 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
121                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
122                  match(_t,COMPONENT);
123                  _t = _t->getFirstChild();
124 < #line 69 "MDTreeParser.g"
124 > #line 62 "MDTreeParser.g"
125                  Component* currComponet = new Component(); blockStack.push(currComponet);
126   #line 127 "MDTreeParser.cpp"
127                  { // ( ... )*
# Line 133 | Line 133 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
133                                  _t = _retTree;
134                          }
135                          else {
136 <                                goto _loop15;
136 >                                goto _loop11;
137                          }
138                          
139                  }
140 <                _loop15:;
140 >                _loop11:;
141                  } // ( ... )*
142                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
143                  match(_t,ENDBLOCK);
144                  _t = _t->getNextSibling();
145 <                _t = __t13;
145 >                _t = __t9;
146                  _t = _t->getNextSibling();
147 < #line 71 "MDTreeParser.g"
147 > #line 64 "MDTreeParser.g"
148                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
149   #line 150 "MDTreeParser.cpp"
150          }
# Line 160 | Line 160 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
160          ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
161          
162          try {      // for error handling
163 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
163 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
164                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
165                  match(_t,MOLECULE);
166                  _t = _t->getFirstChild();
167 < #line 79 "MDTreeParser.g"
167 > #line 72 "MDTreeParser.g"
168                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
169   #line 170 "MDTreeParser.cpp"
170                  { // ( ... )*
# Line 176 | Line 176 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
176                                  _t = _retTree;
177                          }
178                          else {
179 <                                goto _loop23;
179 >                                goto _loop19;
180                          }
181                          
182                  }
183 <                _loop23:;
183 >                _loop19:;
184                  } // ( ... )*
185                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
186                  match(_t,ENDBLOCK);
187                  _t = _t->getNextSibling();
188 <                _t = __t21;
188 >                _t = __t17;
189                  _t = _t->getNextSibling();
190 < #line 81 "MDTreeParser.g"
190 > #line 74 "MDTreeParser.g"
191                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
192   #line 193 "MDTreeParser.cpp"
193          }
# Line 203 | Line 203 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
203          ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
204          
205          try {      // for error handling
206 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
206 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
207                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
208                  match(_t,ZCONSTRAINT);
209                  _t = _t->getFirstChild();
210 < #line 74 "MDTreeParser.g"
210 > #line 67 "MDTreeParser.g"
211                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
212   #line 213 "MDTreeParser.cpp"
213                  { // ( ... )*
# Line 219 | Line 219 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
219                                  _t = _retTree;
220                          }
221                          else {
222 <                                goto _loop19;
222 >                                goto _loop15;
223                          }
224                          
225                  }
226 <                _loop19:;
226 >                _loop15:;
227                  } // ( ... )*
228                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
229                  match(_t,ENDBLOCK);
230                  _t = _t->getNextSibling();
231 <                _t = __t17;
231 >                _t = __t13;
232                  _t = _t->getNextSibling();
233 < #line 76 "MDTreeParser.g"
233 > #line 69 "MDTreeParser.g"
234                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
235   #line 236 "MDTreeParser.cpp"
236          }
# Line 248 | Line 248 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
248          ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
249          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
250          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
251 + #line 47 "MDTreeParser.g"
252          
253 +        int ival;
254 +        RealType dval;
255 +        
256 + #line 257 "MDTreeParser.cpp"
257 +        
258          try {      // for error handling
259                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
260                          _t = ASTNULL;
261                  switch ( _t->getType()) {
262 <                case OCTALINT:
263 <                case DECIMALINT:
258 <                case HEXADECIMALINT:
259 <                case FLOATONE:
260 <                case FLOATTWO:
261 <                case MINUS:
262 >                case NUM_INT:
263 >                case NUM_LONG:
264                  {
265 <                        signedIntOrFloat(_t,id);
265 >                        ival=intConst(_t);
266                          _t = _retTree;
267 + #line 52 "MDTreeParser.g"
268 +                        blockStack.top()->assign(id->getText(), ival);
269 + #line 270 "MDTreeParser.cpp"
270                          break;
271                  }
272 +                case NUM_FLOAT:
273 +                case NUM_DOUBLE:
274 +                {
275 +                        dval=floatConst(_t);
276 +                        _t = _retTree;
277 + #line 53 "MDTreeParser.g"
278 +                        blockStack.top()->assign(id->getText(), dval);
279 + #line 280 "MDTreeParser.cpp"
280 +                        break;
281 +                }
282                  case ID:
283                  {
284                          str1 = _t;
285                          match(_t,ID);
286                          _t = _t->getNextSibling();
287 < #line 49 "MDTreeParser.g"
287 > #line 54 "MDTreeParser.g"
288                          blockStack.top()->assign(id->getText(), str1->getText());
289 < #line 275 "MDTreeParser.cpp"
289 > #line 290 "MDTreeParser.cpp"
290                          break;
291                  }
292                  case StringLiteral:
# Line 279 | Line 294 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
294                          str2 = _t;
295                          match(_t,StringLiteral);
296                          _t = _t->getNextSibling();
297 < #line 50 "MDTreeParser.g"
297 > #line 55 "MDTreeParser.g"
298                          std::string s =  str2->getText();
299                          s = s.substr(1, s.length()-2);
300                          blockStack.top()->assign(id->getText(),s);
301                          
302 < #line 288 "MDTreeParser.cpp"
302 > #line 303 "MDTreeParser.cpp"
303                          break;
304                  }
305                  default:
# Line 301 | Line 316 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
316          _retTree = _t;
317   }
318  
319 < void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
320 <        ANTLR_USE_NAMESPACE(antlr)RefAST id
306 < ) {
307 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedIntOrFloat_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
308 <        ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
309 <        ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST;
310 <        ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
311 <        ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
312 < #line 56 "MDTreeParser.g"
313 <        
319 > int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
320 > #line 262 "MDTreeParser.g"
321          int ival;
322 <        double dval;
322 > #line 323 "MDTreeParser.cpp"
323 >        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
324 >        ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
325 >        ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
326          
317 – #line 318 "MDTreeParser.cpp"
318 –        
327          try {      // for error handling
328                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
329                          _t = ASTNULL;
330                  switch ( _t->getType()) {
331 <                case MINUS:
331 >                case NUM_INT:
332                  {
333 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
334 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
327 <                        match(_t,MINUS);
328 <                        _t = _t->getFirstChild();
329 <                        {
330 <                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
331 <                                _t = ASTNULL;
332 <                        switch ( _t->getType()) {
333 <                        case OCTALINT:
334 <                        case DECIMALINT:
335 <                        case HEXADECIMALINT:
336 <                        {
337 <                                icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
338 <                                intConst(_t);
339 <                                _t = _retTree;
340 < #line 61 "MDTreeParser.g"
341 <                                ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival);
342 < #line 343 "MDTreeParser.cpp"
343 <                                break;
344 <                        }
345 <                        case FLOATONE:
346 <                        case FLOATTWO:
347 <                        {
348 <                                fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
349 <                                floatConst(_t);
350 <                                _t = _retTree;
351 <                                break;
352 <                        }
353 <                        default:
354 <                        {
355 <                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
356 <                        }
357 <                        }
358 <                        }
359 < #line 62 "MDTreeParser.g"
360 <                        dval = lexi_cast<double>(fcMinus->getText());dval = -dval;  blockStack.top()->assign(id->getText(), dval);
361 < #line 362 "MDTreeParser.cpp"
362 <                        _t = __t9;
333 >                        i1 = _t;
334 >                        match(_t,NUM_INT);
335                          _t = _t->getNextSibling();
336 + #line 263 "MDTreeParser.g"
337 +                        ival = lexi_cast<int>(i1->getText());
338 + #line 339 "MDTreeParser.cpp"
339                          break;
340                  }
341 <                case OCTALINT:
367 <                case DECIMALINT:
368 <                case HEXADECIMALINT:
369 <                case FLOATONE:
370 <                case FLOATTWO:
341 >                case NUM_LONG:
342                  {
343 <                        {
344 <                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
374 <                                _t = ASTNULL;
375 <                        switch ( _t->getType()) {
376 <                        case OCTALINT:
377 <                        case DECIMALINT:
378 <                        case HEXADECIMALINT:
379 <                        {
380 <                                ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
381 <                                intConst(_t);
382 <                                _t = _retTree;
383 < #line 64 "MDTreeParser.g"
384 <                                ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival);
385 < #line 386 "MDTreeParser.cpp"
386 <                                break;
387 <                        }
388 <                        case FLOATONE:
389 <                        case FLOATTWO:
390 <                        {
391 <                                fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
392 <                                floatConst(_t);
393 <                                _t = _retTree;
394 < #line 65 "MDTreeParser.g"
395 <                                dval = lexi_cast<double>(fc->getText());  blockStack.top()->assign(id->getText(), dval);
396 < #line 397 "MDTreeParser.cpp"
397 <                                break;
398 <                        }
399 <                        default:
400 <                        {
401 <                                throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
402 <                        }
403 <                        }
404 <                        }
405 <                        break;
406 <                }
407 <                default:
408 <                {
409 <                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
410 <                }
411 <                }
412 <        }
413 <        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
414 <                reportError(ex);
415 <                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
416 <                        _t = _t->getNextSibling();
417 <        }
418 <        _retTree = _t;
419 < }
420 <
421 < int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
422 < #line 249 "MDTreeParser.g"
423 <        int ival;
424 < #line 425 "MDTreeParser.cpp"
425 <        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
426 <        ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST;
427 <        ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST;
428 <        ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST;
429 <        
430 <        try {      // for error handling
431 <                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
432 <                        _t = ASTNULL;
433 <                switch ( _t->getType()) {
434 <                case OCTALINT:
435 <                {
436 <                        oival = _t;
437 <                        match(_t,OCTALINT);
438 <                        _t = _t->getNextSibling();
439 < #line 250 "MDTreeParser.g"
440 <                        ival = lexi_cast<int>(oival->getText());
441 < #line 442 "MDTreeParser.cpp"
442 <                        break;
443 <                }
444 <                case DECIMALINT:
445 <                {
446 <                        dival = _t;
447 <                        match(_t,DECIMALINT);
343 >                        i2 = _t;
344 >                        match(_t,NUM_LONG);
345                          _t = _t->getNextSibling();
346 < #line 251 "MDTreeParser.g"
347 <                        ival = lexi_cast<int>(dival->getText());
348 < #line 452 "MDTreeParser.cpp"
346 > #line 264 "MDTreeParser.g"
347 >                        ival = lexi_cast<int>(i2->getText());
348 > #line 349 "MDTreeParser.cpp"
349                          break;
350                  }
454 –                case HEXADECIMALINT:
455 –                {
456 –                        hival = _t;
457 –                        match(_t,HEXADECIMALINT);
458 –                        _t = _t->getNextSibling();
459 – #line 252 "MDTreeParser.g"
460 –                        ival = lexi_cast<int>(hival->getText());
461 – #line 462 "MDTreeParser.cpp"
462 –                        break;
463 –                }
351                  default:
352                  {
353                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 476 | Line 363 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
363          return ival;
364   }
365  
366 < double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 < #line 264 "MDTreeParser.g"
368 <        double dval;
369 < #line 483 "MDTreeParser.cpp"
366 > RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 > #line 276 "MDTreeParser.g"
368 >        RealType dval;
369 > #line 370 "MDTreeParser.cpp"
370          ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
371          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
372          ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
# Line 488 | Line 375 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
375                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
376                          _t = ASTNULL;
377                  switch ( _t->getType()) {
378 <                case FLOATONE:
378 >                case NUM_FLOAT:
379                  {
380                          d1 = _t;
381 <                        match(_t,FLOATONE);
381 >                        match(_t,NUM_FLOAT);
382                          _t = _t->getNextSibling();
383 < #line 265 "MDTreeParser.g"
384 <                        dval = lexi_cast<double>(d1->getText());
385 < #line 499 "MDTreeParser.cpp"
383 > #line 277 "MDTreeParser.g"
384 >                        dval = lexi_cast<RealType>(d1->getText());
385 > #line 386 "MDTreeParser.cpp"
386                          break;
387                  }
388 <                case FLOATTWO:
388 >                case NUM_DOUBLE:
389                  {
390                          d2 = _t;
391 <                        match(_t,FLOATTWO);
391 >                        match(_t,NUM_DOUBLE);
392                          _t = _t->getNextSibling();
393 < #line 266 "MDTreeParser.g"
394 <                        dval = lexi_cast<double>(d2->getText());
395 < #line 509 "MDTreeParser.cpp"
393 > #line 278 "MDTreeParser.g"
394 >                        dval = lexi_cast<RealType>(d2->getText());
395 > #line 396 "MDTreeParser.cpp"
396                          break;
397                  }
398                  default:
# Line 560 | Line 447 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
447                          _t = _retTree;
448                          break;
449                  }
450 +                case INVERSION:
451 +                {
452 +                        inversionblock(_t);
453 +                        _t = _retTree;
454 +                        break;
455 +                }
456                  case RIGIDBODY:
457                  {
458                          rigidbodyblock(_t);
# Line 594 | Line 487 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
487  
488   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
489          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
490 < #line 94 "MDTreeParser.g"
490 > #line 88 "MDTreeParser.g"
491          
492          int index;
493          
494 < #line 602 "MDTreeParser.cpp"
494 > #line 495 "MDTreeParser.cpp"
495          
496          try {      // for error handling
497 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
498 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
497 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
498 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
499                  match(_t,ATOM);
500                  _t = _t->getFirstChild();
501                  index=intConst(_t);
502                  _t = _retTree;
503 < #line 98 "MDTreeParser.g"
503 > #line 92 "MDTreeParser.g"
504                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
505 < #line 613 "MDTreeParser.cpp"
505 > #line 506 "MDTreeParser.cpp"
506                  { // ( ... )*
507                  for (;;) {
508                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 619 | Line 512 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
512                                  _t = _retTree;
513                          }
514                          else {
515 <                                goto _loop28;
515 >                                goto _loop24;
516                          }
517                          
518                  }
519 <                _loop28:;
519 >                _loop24:;
520                  } // ( ... )*
521 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
521 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
522                  match(_t,ENDBLOCK);
523                  _t = _t->getNextSibling();
524 <                _t = __t26;
524 >                _t = __t22;
525                  _t = _t->getNextSibling();
526 < #line 100 "MDTreeParser.g"
526 > #line 94 "MDTreeParser.g"
527                  
528                  blockStack.top()->validate();
529                  blockStack.pop();
530                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
531                  currMoleculeStamp->addAtomStamp(currAtomStamp);
532                  
533 < #line 641 "MDTreeParser.cpp"
533 > #line 534 "MDTreeParser.cpp"
534          }
535          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
536                  reportError(ex);
# Line 651 | Line 544 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
544          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
545          
546          try {      // for error handling
547 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
548 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
547 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
548 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
549                  match(_t,BOND);
550                  _t = _t->getFirstChild();
551 < #line 120 "MDTreeParser.g"
551 > #line 114 "MDTreeParser.g"
552                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
553 < #line 661 "MDTreeParser.cpp"
553 > #line 554 "MDTreeParser.cpp"
554                  { // ( ... )*
555                  for (;;) {
556                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 667 | Line 560 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
560                                  _t = _retTree;
561                          }
562                          else {
563 <                                goto _loop35;
563 >                                goto _loop31;
564                          }
565                          
566                  }
567 <                _loop35:;
567 >                _loop31:;
568                  } // ( ... )*
569 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
569 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
570                  match(_t,ENDBLOCK);
571                  _t = _t->getNextSibling();
572 <                _t = __t33;
572 >                _t = __t29;
573                  _t = _t->getNextSibling();
574 < #line 122 "MDTreeParser.g"
574 > #line 116 "MDTreeParser.g"
575                  
576                  blockStack.pop();
577                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
578                  currMoleculeStamp->addBondStamp(currBondStamp);
579                  
580 < #line 688 "MDTreeParser.cpp"
580 > #line 581 "MDTreeParser.cpp"
581          }
582          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
583                  reportError(ex);
# Line 698 | Line 591 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
591          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
592          
593          try {      // for error handling
594 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
595 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
594 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
595 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
596                  match(_t,BEND);
597                  _t = _t->getFirstChild();
598 < #line 138 "MDTreeParser.g"
598 > #line 132 "MDTreeParser.g"
599                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
600 < #line 708 "MDTreeParser.cpp"
600 > #line 601 "MDTreeParser.cpp"
601                  { // ( ... )*
602                  for (;;) {
603                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 714 | Line 607 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
607                                  _t = _retTree;
608                          }
609                          else {
610 <                                goto _loop41;
610 >                                goto _loop37;
611                          }
612                          
613                  }
614 <                _loop41:;
614 >                _loop37:;
615                  } // ( ... )*
616 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
616 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
617                  match(_t,ENDBLOCK);
618                  _t = _t->getNextSibling();
619 <                _t = __t39;
619 >                _t = __t35;
620                  _t = _t->getNextSibling();
621 < #line 140 "MDTreeParser.g"
621 > #line 134 "MDTreeParser.g"
622                  
623                  blockStack.top()->validate();
624                  blockStack.pop();
625                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
626                  currMoleculeStamp->addBendStamp(currBendStamp);
627                  
628 < #line 736 "MDTreeParser.cpp"
628 > #line 629 "MDTreeParser.cpp"
629          }
630          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
631                  reportError(ex);
# Line 746 | Line 639 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
639          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
640          
641          try {      // for error handling
642 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
643 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
642 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
643 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
644                  match(_t,TORSION);
645                  _t = _t->getFirstChild();
646 < #line 157 "MDTreeParser.g"
646 > #line 151 "MDTreeParser.g"
647                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
648 < #line 756 "MDTreeParser.cpp"
648 > #line 649 "MDTreeParser.cpp"
649                  { // ( ... )*
650                  for (;;) {
651                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 762 | Line 655 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
655                                  _t = _retTree;
656                          }
657                          else {
658 <                                goto _loop47;
658 >                                goto _loop43;
659                          }
660                          
661                  }
662 <                _loop47:;
662 >                _loop43:;
663                  } // ( ... )*
664 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
664 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
665                  match(_t,ENDBLOCK);
666                  _t = _t->getNextSibling();
667 <                _t = __t45;
667 >                _t = __t41;
668                  _t = _t->getNextSibling();
669 < #line 159 "MDTreeParser.g"
669 > #line 153 "MDTreeParser.g"
670                  
671                  blockStack.top()->validate();
672                  blockStack.pop();
673                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
674                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
675                  
676 < #line 784 "MDTreeParser.cpp"
676 > #line 677 "MDTreeParser.cpp"
677          }
678          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
679                  reportError(ex);
# Line 790 | Line 683 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
683          _retTree = _t;
684   }
685  
686 + void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
687 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
688 +        
689 +        try {      // for error handling
690 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
691 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
692 +                match(_t,INVERSION);
693 +                _t = _t->getFirstChild();
694 + #line 170 "MDTreeParser.g"
695 +                InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
696 + #line 697 "MDTreeParser.cpp"
697 +                { // ( ... )*
698 +                for (;;) {
699 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
700 +                                _t = ASTNULL;
701 +                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
702 +                                inversionstatement(_t);
703 +                                _t = _retTree;
704 +                        }
705 +                        else {
706 +                                goto _loop49;
707 +                        }
708 +                        
709 +                }
710 +                _loop49:;
711 +                } // ( ... )*
712 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
713 +                match(_t,ENDBLOCK);
714 +                _t = _t->getNextSibling();
715 +                _t = __t47;
716 +                _t = _t->getNextSibling();
717 + #line 172 "MDTreeParser.g"
718 +                
719 +                blockStack.top()->validate();
720 +                blockStack.pop();
721 +                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
722 +                currMoleculeStamp->addInversionStamp(currInversionStamp);
723 +                
724 + #line 725 "MDTreeParser.cpp"
725 +        }
726 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
727 +                reportError(ex);
728 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
729 +                        _t = _t->getNextSibling();
730 +        }
731 +        _retTree = _t;
732 + }
733 +
734   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
735          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
736 < #line 176 "MDTreeParser.g"
736 > #line 189 "MDTreeParser.g"
737          
738          int index;
739          
740 < #line 800 "MDTreeParser.cpp"
740 > #line 741 "MDTreeParser.cpp"
741          
742          try {      // for error handling
743 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
744 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
743 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
744 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745                  match(_t,RIGIDBODY);
746                  _t = _t->getFirstChild();
747                  index=intConst(_t);
748                  _t = _retTree;
749 < #line 180 "MDTreeParser.g"
749 > #line 193 "MDTreeParser.g"
750                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
751 < #line 811 "MDTreeParser.cpp"
751 > #line 752 "MDTreeParser.cpp"
752                  { // ( ... )*
753                  for (;;) {
754                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 817 | Line 758 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
758                                  _t = _retTree;
759                          }
760                          else {
761 <                                goto _loop53;
761 >                                goto _loop55;
762                          }
763                          
764                  }
765 <                _loop53:;
765 >                _loop55:;
766                  } // ( ... )*
767 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
767 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
768                  match(_t,ENDBLOCK);
769                  _t = _t->getNextSibling();
770 <                _t = __t51;
770 >                _t = __t53;
771                  _t = _t->getNextSibling();
772 < #line 182 "MDTreeParser.g"
772 > #line 195 "MDTreeParser.g"
773                  
774                  blockStack.top()->validate();
775                  blockStack.pop();
776                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
777                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
778                  
779 < #line 839 "MDTreeParser.cpp"
779 > #line 780 "MDTreeParser.cpp"
780          }
781          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
782                  reportError(ex);
# Line 849 | Line 790 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
790          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
791          
792          try {      // for error handling
793 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
794 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
793 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
794 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
795                  match(_t,CUTOFFGROUP);
796                  _t = _t->getFirstChild();
797 < #line 199 "MDTreeParser.g"
797 > #line 212 "MDTreeParser.g"
798                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
799 < #line 859 "MDTreeParser.cpp"
799 > #line 800 "MDTreeParser.cpp"
800                  { // ( ... )*
801                  for (;;) {
802                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 865 | Line 806 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
806                                  _t = _retTree;
807                          }
808                          else {
809 <                                goto _loop59;
809 >                                goto _loop61;
810                          }
811                          
812                  }
813 <                _loop59:;
813 >                _loop61:;
814                  } // ( ... )*
815 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
815 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
816                  match(_t,ENDBLOCK);
817                  _t = _t->getNextSibling();
818 <                _t = __t57;
818 >                _t = __t59;
819                  _t = _t->getNextSibling();
820 < #line 201 "MDTreeParser.g"
820 > #line 214 "MDTreeParser.g"
821                  
822                  blockStack.top()->validate();
823                  blockStack.pop();
824                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
825                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
826                  
827 < #line 887 "MDTreeParser.cpp"
827 > #line 828 "MDTreeParser.cpp"
828          }
829          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
830                  reportError(ex);
# Line 895 | Line 836 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
836  
837   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
838          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
839 < #line 218 "MDTreeParser.g"
839 > #line 231 "MDTreeParser.g"
840          int ival;
841 < #line 901 "MDTreeParser.cpp"
841 > #line 842 "MDTreeParser.cpp"
842          
843          try {      // for error handling
844 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
845 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
844 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
845 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
846                  match(_t,FRAGMENT);
847                  _t = _t->getFirstChild();
848                  ival=intConst(_t);
849                  _t = _retTree;
850 < #line 219 "MDTreeParser.g"
850 > #line 232 "MDTreeParser.g"
851                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
852 < #line 912 "MDTreeParser.cpp"
852 > #line 853 "MDTreeParser.cpp"
853                  { // ( ... )*
854                  for (;;) {
855                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 918 | Line 859 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
859                                  _t = _retTree;
860                          }
861                          else {
862 <                                goto _loop65;
862 >                                goto _loop67;
863                          }
864                          
865                  }
866 <                _loop65:;
866 >                _loop67:;
867                  } // ( ... )*
868 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
868 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
869                  match(_t,ENDBLOCK);
870                  _t = _t->getNextSibling();
871 <                _t = __t63;
871 >                _t = __t65;
872                  _t = _t->getNextSibling();
873 < #line 221 "MDTreeParser.g"
873 > #line 234 "MDTreeParser.g"
874                  
875                  blockStack.top()->validate();
876                  blockStack.pop();
877                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
878                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
879                  
880 < #line 940 "MDTreeParser.cpp"
880 > #line 881 "MDTreeParser.cpp"
881          }
882          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
883                  reportError(ex);
# Line 948 | Line 889 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
889  
890   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
891          ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
892 < #line 108 "MDTreeParser.g"
892 > #line 102 "MDTreeParser.g"
893          
894 <        vector<double> dvec;
894 >        vector<RealType> dvec;
895          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
896          
897          
898 < #line 958 "MDTreeParser.cpp"
898 > #line 899 "MDTreeParser.cpp"
899          
900          try {      // for error handling
901                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 968 | Line 909 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
909                  }
910                  case POSITION:
911                  {
912 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
913 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
912 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
913 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
914                          match(_t,POSITION);
915                          _t = _t->getFirstChild();
916 <                        dvec=signedNumberTuple(_t);
916 >                        dvec=doubleNumberTuple(_t);
917                          _t = _retTree;
918 <                        _t = __t30;
918 >                        _t = __t26;
919                          _t = _t->getNextSibling();
920 < #line 115 "MDTreeParser.g"
920 > #line 109 "MDTreeParser.g"
921                          currAtomStamp->setPosition(dvec);
922 < #line 982 "MDTreeParser.cpp"
922 > #line 923 "MDTreeParser.cpp"
923                          break;
924                  }
925                  case ORIENTATION:
926                  {
927 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
928 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
927 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
928 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
929                          match(_t,ORIENTATION);
930                          _t = _t->getFirstChild();
931 <                        dvec=signedNumberTuple(_t);
931 >                        dvec=doubleNumberTuple(_t);
932                          _t = _retTree;
933 <                        _t = __t31;
933 >                        _t = __t27;
934                          _t = _t->getNextSibling();
935 < #line 116 "MDTreeParser.g"
935 > #line 110 "MDTreeParser.g"
936                          currAtomStamp->setOrientation(dvec);
937 < #line 997 "MDTreeParser.cpp"
937 > #line 938 "MDTreeParser.cpp"
938                          break;
939                  }
940                  default:
# Line 1010 | Line 951 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
951          _retTree = _t;
952   }
953  
954 < vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
955 < #line 234 "MDTreeParser.g"
956 <        vector<double> dvec;
957 < #line 1017 "MDTreeParser.cpp"
958 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
959 < #line 234 "MDTreeParser.g"
954 > vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
955 > #line 247 "MDTreeParser.g"
956 >        vector<RealType> dvec;
957 > #line 958 "MDTreeParser.cpp"
958 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
959 > #line 247 "MDTreeParser.g"
960          
961 <        double dval;
961 >        RealType dval;
962          
963 < #line 1023 "MDTreeParser.cpp"
963 > #line 964 "MDTreeParser.cpp"
964          
965          try {      // for error handling
966                  { // ( ... )+
967 <                int _cnt69=0;
967 >                int _cnt71=0;
968                  for (;;) {
969                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
970                                  _t = ASTNULL;
971 <                        if (((_t->getType() >= OCTALINT && _t->getType() <= FLOATTWO))) {
972 <                                dval=signedNumber(_t);
971 >                        if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
972 >                                dval=doubleNumber(_t);
973                                  _t = _retTree;
974 < #line 238 "MDTreeParser.g"
974 > #line 251 "MDTreeParser.g"
975                                  dvec.push_back(dval);
976 < #line 1036 "MDTreeParser.cpp"
976 > #line 977 "MDTreeParser.cpp"
977                          }
978                          else {
979 <                                if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
979 >                                if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
980                          }
981                          
982 <                        _cnt69++;
982 >                        _cnt71++;
983                  }
984 <                _loop69:;
984 >                _loop71:;
985                  }  // ( ... )+
986          }
987          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1054 | Line 995 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
995  
996   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
997          ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
998 < #line 129 "MDTreeParser.g"
998 > #line 123 "MDTreeParser.g"
999          
1000          vector<int> ivec;
1001          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1002          
1003 < #line 1063 "MDTreeParser.cpp"
1003 > #line 1004 "MDTreeParser.cpp"
1004          
1005          try {      // for error handling
1006                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1073 | Line 1014 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1014                  }
1015                  case MEMBERS:
1016                  {
1017 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1018 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1017 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1018 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1019                          match(_t,MEMBERS);
1020                          _t = _t->getFirstChild();
1021                          ivec=inttuple(_t);
1022                          _t = _retTree;
1023 <                        _t = __t37;
1023 >                        _t = __t33;
1024                          _t = _t->getNextSibling();
1025 < #line 135 "MDTreeParser.g"
1025 > #line 129 "MDTreeParser.g"
1026                          currBondStamp->setMembers(ivec);
1027 < #line 1087 "MDTreeParser.cpp"
1027 > #line 1028 "MDTreeParser.cpp"
1028                          break;
1029                  }
1030                  default:
# Line 1101 | Line 1042 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1042   }
1043  
1044   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1045 < #line 241 "MDTreeParser.g"
1045 > #line 254 "MDTreeParser.g"
1046          vector<int> ivec;
1047 < #line 1107 "MDTreeParser.cpp"
1047 > #line 1048 "MDTreeParser.cpp"
1048          ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1049 < #line 241 "MDTreeParser.g"
1049 > #line 254 "MDTreeParser.g"
1050          
1051          int ival;
1052          
1053 < #line 1113 "MDTreeParser.cpp"
1053 > #line 1054 "MDTreeParser.cpp"
1054          
1055          try {      // for error handling
1056                  { // ( ... )+
1057 <                int _cnt72=0;
1057 >                int _cnt74=0;
1058                  for (;;) {
1059                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1060                                  _t = ASTNULL;
1061 <                        if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1061 >                        if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1062                                  ival=intConst(_t);
1063                                  _t = _retTree;
1064 < #line 245 "MDTreeParser.g"
1064 > #line 258 "MDTreeParser.g"
1065                                  ivec.push_back(ival);
1066 < #line 1126 "MDTreeParser.cpp"
1066 > #line 1067 "MDTreeParser.cpp"
1067                          }
1068                          else {
1069 <                                if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1069 >                                if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1070                          }
1071                          
1072 <                        _cnt72++;
1072 >                        _cnt74++;
1073                  }
1074 <                _loop72:;
1074 >                _loop74:;
1075                  }  // ( ... )+
1076          }
1077          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1144 | Line 1085 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1085  
1086   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1087          ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088 < #line 148 "MDTreeParser.g"
1088 > #line 142 "MDTreeParser.g"
1089          
1090          vector<int> ivec;
1091          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1092          
1093 < #line 1153 "MDTreeParser.cpp"
1093 > #line 1094 "MDTreeParser.cpp"
1094          
1095          try {      // for error handling
1096                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1163 | Line 1104 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1104                  }
1105                  case MEMBERS:
1106                  {
1107 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1108 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1107 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1108 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1109                          match(_t,MEMBERS);
1110                          _t = _t->getFirstChild();
1111                          ivec=inttuple(_t);
1112                          _t = _retTree;
1113 <                        _t = __t43;
1113 >                        _t = __t39;
1114                          _t = _t->getNextSibling();
1115 < #line 154 "MDTreeParser.g"
1115 > #line 148 "MDTreeParser.g"
1116                          currBendStamp->setMembers(ivec);
1117 < #line 1177 "MDTreeParser.cpp"
1117 > #line 1118 "MDTreeParser.cpp"
1118                          break;
1119                  }
1120                  default:
# Line 1192 | Line 1133 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1133  
1134   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1135          ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1136 < #line 167 "MDTreeParser.g"
1136 > #line 161 "MDTreeParser.g"
1137          
1138          vector<int> ivec;
1139          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1140          
1141 < #line 1201 "MDTreeParser.cpp"
1141 > #line 1142 "MDTreeParser.cpp"
1142          
1143          try {      // for error handling
1144                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1211 | Line 1152 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1152                  }
1153                  case MEMBERS:
1154                  {
1155 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1156 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1155 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1156 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1157                          match(_t,MEMBERS);
1158                          _t = _t->getFirstChild();
1159                          ivec=inttuple(_t);
1160                          _t = _retTree;
1161 <                        _t = __t49;
1161 >                        _t = __t45;
1162                          _t = _t->getNextSibling();
1163 < #line 173 "MDTreeParser.g"
1163 > #line 167 "MDTreeParser.g"
1164                          currTorsionStamp->setMembers(ivec);
1165 < #line 1225 "MDTreeParser.cpp"
1165 > #line 1166 "MDTreeParser.cpp"
1166                          break;
1167                  }
1168                  default:
# Line 1238 | Line 1179 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1179          _retTree = _t;
1180   }
1181  
1182 + void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1183 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1184 + #line 180 "MDTreeParser.g"
1185 +        
1186 +        int icent;
1187 +        InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1188 +        
1189 + #line 1190 "MDTreeParser.cpp"
1190 +        
1191 +        try {      // for error handling
1192 +                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1193 +                        _t = ASTNULL;
1194 +                switch ( _t->getType()) {
1195 +                case ASSIGNEQUAL:
1196 +                {
1197 +                        assignment(_t);
1198 +                        _t = _retTree;
1199 +                        break;
1200 +                }
1201 +                case CENTER:
1202 +                {
1203 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1204 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1205 +                        match(_t,CENTER);
1206 +                        _t = _t->getFirstChild();
1207 +                        icent=intConst(_t);
1208 +                        _t = _retTree;
1209 +                        _t = __t51;
1210 +                        _t = _t->getNextSibling();
1211 + #line 186 "MDTreeParser.g"
1212 +                        currInversionStamp->setCenter(icent);
1213 + #line 1214 "MDTreeParser.cpp"
1214 +                        break;
1215 +                }
1216 +                default:
1217 +                {
1218 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1219 +                }
1220 +                }
1221 +        }
1222 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1223 +                reportError(ex);
1224 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1225 +                        _t = _t->getNextSibling();
1226 +        }
1227 +        _retTree = _t;
1228 + }
1229 +
1230   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1231          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1232 < #line 190 "MDTreeParser.g"
1232 > #line 203 "MDTreeParser.g"
1233          
1234          vector<int> ivec;
1235          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1236          
1237 < #line 1249 "MDTreeParser.cpp"
1237 > #line 1238 "MDTreeParser.cpp"
1238          
1239          try {      // for error handling
1240                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1259 | Line 1248 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1248                  }
1249                  case MEMBERS:
1250                  {
1251 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1252 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1251 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1252 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1253                          match(_t,MEMBERS);
1254                          _t = _t->getFirstChild();
1255                          ivec=inttuple(_t);
1256                          _t = _retTree;
1257 <                        _t = __t55;
1257 >                        _t = __t57;
1258                          _t = _t->getNextSibling();
1259 < #line 196 "MDTreeParser.g"
1259 > #line 209 "MDTreeParser.g"
1260                          currRigidBodyStamp->setMembers(ivec);
1261 < #line 1273 "MDTreeParser.cpp"
1261 > #line 1262 "MDTreeParser.cpp"
1262                          break;
1263                  }
1264                  default:
# Line 1288 | Line 1277 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1277  
1278   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1279          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1280 < #line 209 "MDTreeParser.g"
1280 > #line 222 "MDTreeParser.g"
1281          
1282          vector<int> ivec;
1283          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1284          
1285 < #line 1297 "MDTreeParser.cpp"
1285 > #line 1286 "MDTreeParser.cpp"
1286          
1287          try {      // for error handling
1288                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1307 | Line 1296 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1296                  }
1297                  case MEMBERS:
1298                  {
1299 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1300 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1299 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1300 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1301                          match(_t,MEMBERS);
1302                          _t = _t->getFirstChild();
1303                          ivec=inttuple(_t);
1304                          _t = _retTree;
1305 <                        _t = __t61;
1305 >                        _t = __t63;
1306                          _t = _t->getNextSibling();
1307 < #line 215 "MDTreeParser.g"
1307 > #line 228 "MDTreeParser.g"
1308                          currCutoffGroupStamp->setMembers(ivec);
1309 < #line 1321 "MDTreeParser.cpp"
1309 > #line 1310 "MDTreeParser.cpp"
1310                          break;
1311                  }
1312                  default:
# Line 1349 | Line 1338 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1338          _retTree = _t;
1339   }
1340  
1341 < double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342 < #line 256 "MDTreeParser.g"
1343 <        double dval;
1344 < #line 1356 "MDTreeParser.cpp"
1345 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1341 > RealType  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342 > #line 268 "MDTreeParser.g"
1343 >        RealType dval;
1344 > #line 1345 "MDTreeParser.cpp"
1345 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1346          ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1347          ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1348          
# Line 1361 | Line 1350 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1350                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1351                          _t = ASTNULL;
1352                  switch ( _t->getType()) {
1353 <                case OCTALINT:
1354 <                case DECIMALINT:
1366 <                case HEXADECIMALINT:
1353 >                case NUM_INT:
1354 >                case NUM_LONG:
1355                  {
1356                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357                          intConst(_t);
1358                          _t = _retTree;
1359 < #line 258 "MDTreeParser.g"
1360 <                        dval = lexi_cast<double>(ic->getText());
1361 < #line 1374 "MDTreeParser.cpp"
1359 > #line 270 "MDTreeParser.g"
1360 >                        dval = lexi_cast<RealType>(ic->getText());
1361 > #line 1362 "MDTreeParser.cpp"
1362                          break;
1363                  }
1364 <                case FLOATONE:
1365 <                case FLOATTWO:
1364 >                case NUM_FLOAT:
1365 >                case NUM_DOUBLE:
1366                  {
1367                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1368                          floatConst(_t);
1369                          _t = _retTree;
1370 < #line 259 "MDTreeParser.g"
1371 <                        dval = lexi_cast<double>(fc->getText());
1372 < #line 1385 "MDTreeParser.cpp"
1370 > #line 271 "MDTreeParser.g"
1371 >                        dval = lexi_cast<RealType>(fc->getText());
1372 > #line 1373 "MDTreeParser.cpp"
1373                          break;
1374                  }
1375                  default:
# Line 1414 | Line 1402 | const char* MDTreeParser::tokenNames[] = {
1402          "\"bond\"",
1403          "\"bend\"",
1404          "\"torsion\"",
1405 +        "\"inversion\"",
1406          "\"rigidBody\"",
1407          "\"cutoffGroup\"",
1408          "\"fragment\"",
1409          "\"members\"",
1410 +        "\"center\"",
1411          "\"position\"",
1412          "\"orientation\"",
1413          "ENDBLOCK",
# Line 1432 | Line 1422 | const char* MDTreeParser::tokenNames[] = {
1422          "LPAREN",
1423          "RPAREN",
1424          "COMMA",
1425 <        "OCTALINT",
1426 <        "DECIMALINT",
1427 <        "HEXADECIMALINT",
1428 <        "FLOATONE",
1439 <        "FLOATTWO",
1425 >        "NUM_INT",
1426 >        "NUM_LONG",
1427 >        "NUM_FLOAT",
1428 >        "NUM_DOUBLE",
1429          "DOT",
1430          "COLON",
1431          "QUESTIONMARK",
# Line 1449 | Line 1438 | const char* MDTreeParser::tokenNames[] = {
1438          "CharLiteral",
1439          "EndOfLine",
1440          "Escape",
1441 +        "Vocabulary",
1442          "Digit",
1443          "Decimal",
1444 <        "LongSuffix",
1445 <        "UnsignedSuffix",
1446 <        "FloatSuffix",
1457 <        "Exponent",
1458 <        "Vocabulary",
1459 <        "Number",
1460 <        "MINUS",
1444 >        "HEX_DIGIT",
1445 >        "EXPONENT",
1446 >        "FLOAT_SUFFIX",
1447          0
1448   };
1449  
1450 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1450 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1451   // "component" "molecule" "zconstraint" ASSIGNEQUAL
1452   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1453 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1454 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1455 < // ASSIGNEQUAL
1453 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1454 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1455 > // "fragment" ASSIGNEQUAL
1456   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1457  
1458  

Diff Legend

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