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 814 by tim, Fri Dec 16 02:57:00 2005 UTC vs.
Revision 1360 by cli2, Mon Sep 7 16:31:51 2009 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2   #include "MDTreeParser.hpp"
3   #include <antlr/Token.hpp>
4   #include <antlr/AST.hpp>
# Line 13 | Line 13 | void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)Re
13   }
14  
15   void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
16 <        ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
16 >        ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
17          
18          try {      // for error handling
19                  { // ( ... )*
# Line 44 | Line 44 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
44   }
45  
46   void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
47 <        ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
47 >        ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
48          
49          try {      // for error handling
50                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 74 | Line 74 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr
74                          _t = _retTree;
75                          break;
76                  }
77 +                case RESTRAINT:
78 +                {
79 +                        restraintblock(_t);
80 +                        _t = _retTree;
81 +                        break;
82 +                }
83                  default:
84                  {
85                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 89 | Line 95 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl
95   }
96  
97   void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
98 <        ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
98 >        ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
99          ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
100          
101          try {      // for error handling
# Line 114 | Line 120 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
120   }
121  
122   void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
123 <        ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
123 >        ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
124          
125          try {      // for error handling
126                  ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
127                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
128                  match(_t,COMPONENT);
129                  _t = _t->getFirstChild();
130 < #line 62 "MDTreeParser.g"
130 > #line 63 "MDTreeParser.g"
131                  Component* currComponet = new Component(); blockStack.push(currComponet);
132 < #line 127 "MDTreeParser.cpp"
132 > #line 133 "MDTreeParser.cpp"
133                  { // ( ... )*
134                  for (;;) {
135                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 144 | Line 150 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
150                  _t = _t->getNextSibling();
151                  _t = __t9;
152                  _t = _t->getNextSibling();
153 < #line 64 "MDTreeParser.g"
153 > #line 65 "MDTreeParser.g"
154                  blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
155 < #line 150 "MDTreeParser.cpp"
155 > #line 156 "MDTreeParser.cpp"
156          }
157          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
158                  reportError(ex);
# Line 157 | Line 163 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
163   }
164  
165   void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
166 <        ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
166 >        ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
167          
168          try {      // for error handling
169 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
169 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
170                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
171                  match(_t,MOLECULE);
172                  _t = _t->getFirstChild();
173 < #line 72 "MDTreeParser.g"
173 > #line 78 "MDTreeParser.g"
174                  MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
175 < #line 170 "MDTreeParser.cpp"
175 > #line 176 "MDTreeParser.cpp"
176                  { // ( ... )*
177                  for (;;) {
178                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 176 | Line 182 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
182                                  _t = _retTree;
183                          }
184                          else {
185 <                                goto _loop19;
185 >                                goto _loop23;
186                          }
187                          
188                  }
189 <                _loop19:;
189 >                _loop23:;
190                  } // ( ... )*
191                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
192                  match(_t,ENDBLOCK);
193                  _t = _t->getNextSibling();
194 <                _t = __t17;
194 >                _t = __t21;
195                  _t = _t->getNextSibling();
196 < #line 74 "MDTreeParser.g"
196 > #line 80 "MDTreeParser.g"
197                  blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
198 < #line 193 "MDTreeParser.cpp"
198 > #line 199 "MDTreeParser.cpp"
199          }
200          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
201                  reportError(ex);
# Line 200 | Line 206 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
206   }
207  
208   void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
209 <        ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
209 >        ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
210          
211          try {      // for error handling
212                  ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
213                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
214                  match(_t,ZCONSTRAINT);
215                  _t = _t->getFirstChild();
216 < #line 67 "MDTreeParser.g"
216 > #line 68 "MDTreeParser.g"
217                  ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
218 < #line 213 "MDTreeParser.cpp"
218 > #line 219 "MDTreeParser.cpp"
219                  { // ( ... )*
220                  for (;;) {
221                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 230 | Line 236 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
236                  _t = _t->getNextSibling();
237                  _t = __t13;
238                  _t = _t->getNextSibling();
239 < #line 69 "MDTreeParser.g"
239 > #line 70 "MDTreeParser.g"
240                  blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
241 < #line 236 "MDTreeParser.cpp"
241 > #line 242 "MDTreeParser.cpp"
242          }
243          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
244                  reportError(ex);
# Line 242 | Line 248 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
248          _retTree = _t;
249   }
250  
251 + void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
252 +        ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
253 +        
254 +        try {      // for error handling
255 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
256 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
257 +                match(_t,RESTRAINT);
258 +                _t = _t->getFirstChild();
259 + #line 73 "MDTreeParser.g"
260 +                RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
261 + #line 262 "MDTreeParser.cpp"
262 +                { // ( ... )*
263 +                for (;;) {
264 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
265 +                                _t = ASTNULL;
266 +                        if ((_t->getType() == ASSIGNEQUAL)) {
267 +                                assignment(_t);
268 +                                _t = _retTree;
269 +                        }
270 +                        else {
271 +                                goto _loop19;
272 +                        }
273 +                        
274 +                }
275 +                _loop19:;
276 +                } // ( ... )*
277 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
278 +                match(_t,ENDBLOCK);
279 +                _t = _t->getNextSibling();
280 +                _t = __t17;
281 +                _t = _t->getNextSibling();
282 + #line 75 "MDTreeParser.g"
283 +                blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
284 + #line 285 "MDTreeParser.cpp"
285 +        }
286 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
287 +                reportError(ex);
288 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
289 +                        _t = _t->getNextSibling();
290 +        }
291 +        _retTree = _t;
292 + }
293 +
294   void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
295          ANTLR_USE_NAMESPACE(antlr)RefAST id
296   ) {
297 <        ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
297 >        ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
298          ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
299          ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
300 < #line 47 "MDTreeParser.g"
300 > #line 48 "MDTreeParser.g"
301          
302          int ival;
303 <        double dval;
303 >        RealType dval;
304          
305 < #line 257 "MDTreeParser.cpp"
305 > #line 306 "MDTreeParser.cpp"
306          
307          try {      // for error handling
308                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 264 | Line 313 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
313                  {
314                          ival=intConst(_t);
315                          _t = _retTree;
316 < #line 52 "MDTreeParser.g"
316 > #line 53 "MDTreeParser.g"
317                          blockStack.top()->assign(id->getText(), ival);
318 < #line 270 "MDTreeParser.cpp"
318 > #line 319 "MDTreeParser.cpp"
319                          break;
320                  }
321                  case NUM_FLOAT:
# Line 274 | Line 323 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
323                  {
324                          dval=floatConst(_t);
325                          _t = _retTree;
326 < #line 53 "MDTreeParser.g"
326 > #line 54 "MDTreeParser.g"
327                          blockStack.top()->assign(id->getText(), dval);
328 < #line 280 "MDTreeParser.cpp"
328 > #line 329 "MDTreeParser.cpp"
329                          break;
330                  }
331                  case ID:
# Line 284 | Line 333 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
333                          str1 = _t;
334                          match(_t,ID);
335                          _t = _t->getNextSibling();
336 < #line 54 "MDTreeParser.g"
336 > #line 55 "MDTreeParser.g"
337                          blockStack.top()->assign(id->getText(), str1->getText());
338 < #line 290 "MDTreeParser.cpp"
338 > #line 339 "MDTreeParser.cpp"
339                          break;
340                  }
341                  case StringLiteral:
# Line 294 | Line 343 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
343                          str2 = _t;
344                          match(_t,StringLiteral);
345                          _t = _t->getNextSibling();
346 < #line 55 "MDTreeParser.g"
346 > #line 56 "MDTreeParser.g"
347                          std::string s =  str2->getText();
348                          s = s.substr(1, s.length()-2);
349                          blockStack.top()->assign(id->getText(),s);
350                          
351 < #line 303 "MDTreeParser.cpp"
351 > #line 352 "MDTreeParser.cpp"
352                          break;
353                  }
354                  default:
# Line 317 | Line 366 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
366   }
367  
368   int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
369 < #line 242 "MDTreeParser.g"
369 > #line 268 "MDTreeParser.g"
370          int ival;
371 < #line 323 "MDTreeParser.cpp"
372 <        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
371 > #line 372 "MDTreeParser.cpp"
372 >        ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
373          ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
374          ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
375          
# Line 333 | Line 382 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
382                          i1 = _t;
383                          match(_t,NUM_INT);
384                          _t = _t->getNextSibling();
385 < #line 243 "MDTreeParser.g"
385 > #line 269 "MDTreeParser.g"
386                          ival = lexi_cast<int>(i1->getText());
387 < #line 339 "MDTreeParser.cpp"
387 > #line 388 "MDTreeParser.cpp"
388                          break;
389                  }
390                  case NUM_LONG:
# Line 343 | Line 392 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
392                          i2 = _t;
393                          match(_t,NUM_LONG);
394                          _t = _t->getNextSibling();
395 < #line 244 "MDTreeParser.g"
395 > #line 270 "MDTreeParser.g"
396                          ival = lexi_cast<int>(i2->getText());
397 < #line 349 "MDTreeParser.cpp"
397 > #line 398 "MDTreeParser.cpp"
398                          break;
399                  }
400                  default:
# Line 363 | Line 412 | int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)
412          return ival;
413   }
414  
415 < double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416 < #line 256 "MDTreeParser.g"
417 <        double dval;
418 < #line 370 "MDTreeParser.cpp"
419 <        ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
415 > RealType  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416 > #line 282 "MDTreeParser.g"
417 >        RealType dval;
418 > #line 419 "MDTreeParser.cpp"
419 >        ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
420          ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
421          ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
422          
# Line 380 | Line 429 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
429                          d1 = _t;
430                          match(_t,NUM_FLOAT);
431                          _t = _t->getNextSibling();
432 < #line 257 "MDTreeParser.g"
433 <                        dval = lexi_cast<double>(d1->getText());
434 < #line 386 "MDTreeParser.cpp"
432 > #line 283 "MDTreeParser.g"
433 >                        dval = lexi_cast<RealType>(d1->getText());
434 > #line 435 "MDTreeParser.cpp"
435                          break;
436                  }
437                  case NUM_DOUBLE:
# Line 390 | Line 439 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
439                          d2 = _t;
440                          match(_t,NUM_DOUBLE);
441                          _t = _t->getNextSibling();
442 < #line 258 "MDTreeParser.g"
443 <                        dval = lexi_cast<double>(d2->getText());
444 < #line 396 "MDTreeParser.cpp"
442 > #line 284 "MDTreeParser.g"
443 >                        dval = lexi_cast<RealType>(d2->getText());
444 > #line 445 "MDTreeParser.cpp"
445                          break;
446                  }
447                  default:
# Line 411 | Line 460 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
460   }
461  
462   void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
463 <        ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
463 >        ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
464          
465          try {      // for error handling
466                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 447 | Line 496 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA
496                          _t = _retTree;
497                          break;
498                  }
499 +                case INVERSION:
500 +                {
501 +                        inversionblock(_t);
502 +                        _t = _retTree;
503 +                        break;
504 +                }
505                  case RIGIDBODY:
506                  {
507                          rigidbodyblock(_t);
# Line 480 | Line 535 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
535   }
536  
537   void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
538 <        ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539 < #line 87 "MDTreeParser.g"
538 >        ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539 > #line 94 "MDTreeParser.g"
540          
541          int index;
542          
543 < #line 489 "MDTreeParser.cpp"
543 > #line 544 "MDTreeParser.cpp"
544          
545          try {      // for error handling
546 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
547 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
546 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
547 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
548                  match(_t,ATOM);
549                  _t = _t->getFirstChild();
550                  index=intConst(_t);
551                  _t = _retTree;
552 < #line 91 "MDTreeParser.g"
552 > #line 98 "MDTreeParser.g"
553                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554 < #line 500 "MDTreeParser.cpp"
554 > #line 555 "MDTreeParser.cpp"
555                  { // ( ... )*
556                  for (;;) {
557                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 506 | Line 561 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
561                                  _t = _retTree;
562                          }
563                          else {
564 <                                goto _loop24;
564 >                                goto _loop28;
565                          }
566                          
567                  }
568 <                _loop24:;
568 >                _loop28:;
569                  } // ( ... )*
570 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
570 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
571                  match(_t,ENDBLOCK);
572                  _t = _t->getNextSibling();
573 <                _t = __t22;
573 >                _t = __t26;
574                  _t = _t->getNextSibling();
575 < #line 93 "MDTreeParser.g"
575 > #line 100 "MDTreeParser.g"
576                  
577                  blockStack.top()->validate();
578                  blockStack.pop();
579                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
580                  currMoleculeStamp->addAtomStamp(currAtomStamp);
581                  
582 < #line 528 "MDTreeParser.cpp"
582 > #line 583 "MDTreeParser.cpp"
583          }
584          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
585                  reportError(ex);
# Line 535 | Line 590 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
590   }
591  
592   void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
593 <        ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
593 >        ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
594          
595          try {      // for error handling
596 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
597 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
596 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
597 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
598                  match(_t,BOND);
599                  _t = _t->getFirstChild();
600 < #line 113 "MDTreeParser.g"
600 > #line 120 "MDTreeParser.g"
601                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602 < #line 548 "MDTreeParser.cpp"
602 > #line 603 "MDTreeParser.cpp"
603                  { // ( ... )*
604                  for (;;) {
605                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 554 | Line 609 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
609                                  _t = _retTree;
610                          }
611                          else {
612 <                                goto _loop31;
612 >                                goto _loop35;
613                          }
614                          
615                  }
616 <                _loop31:;
616 >                _loop35:;
617                  } // ( ... )*
618 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
618 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
619                  match(_t,ENDBLOCK);
620                  _t = _t->getNextSibling();
621 <                _t = __t29;
621 >                _t = __t33;
622                  _t = _t->getNextSibling();
623 < #line 115 "MDTreeParser.g"
623 > #line 122 "MDTreeParser.g"
624                  
625                  blockStack.pop();
626                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
627                  currMoleculeStamp->addBondStamp(currBondStamp);
628                  
629 < #line 575 "MDTreeParser.cpp"
629 > #line 630 "MDTreeParser.cpp"
630          }
631          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
632                  reportError(ex);
# Line 582 | Line 637 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
637   }
638  
639   void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
640 <        ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
640 >        ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
641          
642          try {      // for error handling
643 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
644 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
643 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
644 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
645                  match(_t,BEND);
646                  _t = _t->getFirstChild();
647 < #line 131 "MDTreeParser.g"
647 > #line 138 "MDTreeParser.g"
648                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649 < #line 595 "MDTreeParser.cpp"
649 > #line 650 "MDTreeParser.cpp"
650                  { // ( ... )*
651                  for (;;) {
652                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 601 | Line 656 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
656                                  _t = _retTree;
657                          }
658                          else {
659 <                                goto _loop37;
659 >                                goto _loop41;
660                          }
661                          
662                  }
663 <                _loop37:;
663 >                _loop41:;
664                  } // ( ... )*
665 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
665 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
666                  match(_t,ENDBLOCK);
667                  _t = _t->getNextSibling();
668 <                _t = __t35;
668 >                _t = __t39;
669                  _t = _t->getNextSibling();
670 < #line 133 "MDTreeParser.g"
670 > #line 140 "MDTreeParser.g"
671                  
672                  blockStack.top()->validate();
673                  blockStack.pop();
674                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
675                  currMoleculeStamp->addBendStamp(currBendStamp);
676                  
677 < #line 623 "MDTreeParser.cpp"
677 > #line 678 "MDTreeParser.cpp"
678          }
679          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
680                  reportError(ex);
# Line 630 | Line 685 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
685   }
686  
687   void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
688 <        ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
688 >        ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
689          
690          try {      // for error handling
691 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
692 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
691 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
692 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
693                  match(_t,TORSION);
694                  _t = _t->getFirstChild();
695 < #line 150 "MDTreeParser.g"
695 > #line 157 "MDTreeParser.g"
696                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697 < #line 643 "MDTreeParser.cpp"
697 > #line 698 "MDTreeParser.cpp"
698                  { // ( ... )*
699                  for (;;) {
700                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 649 | Line 704 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
704                                  _t = _retTree;
705                          }
706                          else {
707 <                                goto _loop43;
707 >                                goto _loop47;
708                          }
709                          
710                  }
711 <                _loop43:;
711 >                _loop47:;
712                  } // ( ... )*
713 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
713 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714                  match(_t,ENDBLOCK);
715                  _t = _t->getNextSibling();
716 <                _t = __t41;
716 >                _t = __t45;
717                  _t = _t->getNextSibling();
718 < #line 152 "MDTreeParser.g"
718 > #line 159 "MDTreeParser.g"
719                  
720                  blockStack.top()->validate();
721                  blockStack.pop();
722                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
724                  
725 < #line 671 "MDTreeParser.cpp"
725 > #line 726 "MDTreeParser.cpp"
726          }
727          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728                  reportError(ex);
# Line 677 | Line 732 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
732          _retTree = _t;
733   }
734  
735 + void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
736 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
737 +        
738 +        try {      // for error handling
739 +                ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
740 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741 +                match(_t,INVERSION);
742 +                _t = _t->getFirstChild();
743 + #line 176 "MDTreeParser.g"
744 +                InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
745 + #line 746 "MDTreeParser.cpp"
746 +                { // ( ... )*
747 +                for (;;) {
748 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
749 +                                _t = ASTNULL;
750 +                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
751 +                                inversionstatement(_t);
752 +                                _t = _retTree;
753 +                        }
754 +                        else {
755 +                                goto _loop53;
756 +                        }
757 +                        
758 +                }
759 +                _loop53:;
760 +                } // ( ... )*
761 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
762 +                match(_t,ENDBLOCK);
763 +                _t = _t->getNextSibling();
764 +                _t = __t51;
765 +                _t = _t->getNextSibling();
766 + #line 178 "MDTreeParser.g"
767 +                
768 +                blockStack.top()->validate();
769 +                blockStack.pop();
770 +                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771 +                currMoleculeStamp->addInversionStamp(currInversionStamp);
772 +                
773 + #line 774 "MDTreeParser.cpp"
774 +        }
775 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776 +                reportError(ex);
777 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
778 +                        _t = _t->getNextSibling();
779 +        }
780 +        _retTree = _t;
781 + }
782 +
783   void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785 < #line 169 "MDTreeParser.g"
784 >        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785 > #line 195 "MDTreeParser.g"
786          
787          int index;
788          
789 < #line 687 "MDTreeParser.cpp"
789 > #line 790 "MDTreeParser.cpp"
790          
791          try {      // for error handling
792 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
793 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
792 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
793 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
794                  match(_t,RIGIDBODY);
795                  _t = _t->getFirstChild();
796                  index=intConst(_t);
797                  _t = _retTree;
798 < #line 173 "MDTreeParser.g"
798 > #line 199 "MDTreeParser.g"
799                  RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800 < #line 698 "MDTreeParser.cpp"
800 > #line 801 "MDTreeParser.cpp"
801                  { // ( ... )*
802                  for (;;) {
803                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 704 | Line 807 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
807                                  _t = _retTree;
808                          }
809                          else {
810 <                                goto _loop49;
810 >                                goto _loop59;
811                          }
812                          
813                  }
814 <                _loop49:;
814 >                _loop59:;
815                  } // ( ... )*
816 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
816 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817                  match(_t,ENDBLOCK);
818                  _t = _t->getNextSibling();
819 <                _t = __t47;
819 >                _t = __t57;
820                  _t = _t->getNextSibling();
821 < #line 175 "MDTreeParser.g"
821 > #line 201 "MDTreeParser.g"
822                  
823                  blockStack.top()->validate();
824                  blockStack.pop();
825                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
826                  currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
827                  
828 < #line 726 "MDTreeParser.cpp"
828 > #line 829 "MDTreeParser.cpp"
829          }
830          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
831                  reportError(ex);
# Line 733 | Line 836 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
836   }
837  
838   void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
839 <        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
839 >        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
840          
841          try {      // for error handling
842 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
843 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
842 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
843 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
844                  match(_t,CUTOFFGROUP);
845                  _t = _t->getFirstChild();
846 < #line 192 "MDTreeParser.g"
846 > #line 218 "MDTreeParser.g"
847                  CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848 < #line 746 "MDTreeParser.cpp"
848 > #line 849 "MDTreeParser.cpp"
849                  { // ( ... )*
850                  for (;;) {
851                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 752 | Line 855 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
855                                  _t = _retTree;
856                          }
857                          else {
858 <                                goto _loop55;
858 >                                goto _loop65;
859                          }
860                          
861                  }
862 <                _loop55:;
862 >                _loop65:;
863                  } // ( ... )*
864 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
864 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865                  match(_t,ENDBLOCK);
866                  _t = _t->getNextSibling();
867 <                _t = __t53;
867 >                _t = __t63;
868                  _t = _t->getNextSibling();
869 < #line 194 "MDTreeParser.g"
869 > #line 220 "MDTreeParser.g"
870                  
871                  blockStack.top()->validate();
872                  blockStack.pop();
873                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
874                  currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
875                  
876 < #line 774 "MDTreeParser.cpp"
876 > #line 877 "MDTreeParser.cpp"
877          }
878          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
879                  reportError(ex);
# Line 781 | Line 884 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
884   }
885  
886   void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
887 <        ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888 < #line 211 "MDTreeParser.g"
887 >        ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888 > #line 237 "MDTreeParser.g"
889          int ival;
890 < #line 788 "MDTreeParser.cpp"
890 > #line 891 "MDTreeParser.cpp"
891          
892          try {      // for error handling
893 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
894 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
893 >                ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
894 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
895                  match(_t,FRAGMENT);
896                  _t = _t->getFirstChild();
897                  ival=intConst(_t);
898                  _t = _retTree;
899 < #line 212 "MDTreeParser.g"
899 > #line 238 "MDTreeParser.g"
900                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901 < #line 799 "MDTreeParser.cpp"
901 > #line 902 "MDTreeParser.cpp"
902                  { // ( ... )*
903                  for (;;) {
904                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 805 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
908                                  _t = _retTree;
909                          }
910                          else {
911 <                                goto _loop61;
911 >                                goto _loop71;
912                          }
913                          
914                  }
915 <                _loop61:;
915 >                _loop71:;
916                  } // ( ... )*
917 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
917 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918                  match(_t,ENDBLOCK);
919                  _t = _t->getNextSibling();
920 <                _t = __t59;
920 >                _t = __t69;
921                  _t = _t->getNextSibling();
922 < #line 214 "MDTreeParser.g"
922 > #line 240 "MDTreeParser.g"
923                  
924                  blockStack.top()->validate();
925                  blockStack.pop();
926                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
927                  currMoleculeStamp->addFragmentStamp(currFragmentStamp);
928                  
929 < #line 827 "MDTreeParser.cpp"
929 > #line 930 "MDTreeParser.cpp"
930          }
931          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
932                  reportError(ex);
# Line 834 | Line 937 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
937   }
938  
939   void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
940 <        ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941 < #line 101 "MDTreeParser.g"
940 >        ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941 > #line 108 "MDTreeParser.g"
942          
943 <        vector<double> dvec;
943 >        vector<RealType> dvec;
944          AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
945          
946          
947 < #line 845 "MDTreeParser.cpp"
947 > #line 948 "MDTreeParser.cpp"
948          
949          try {      // for error handling
950                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 855 | Line 958 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
958                  }
959                  case POSITION:
960                  {
961 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
962 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
961 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
962 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
963                          match(_t,POSITION);
964                          _t = _t->getFirstChild();
965                          dvec=doubleNumberTuple(_t);
966                          _t = _retTree;
967 <                        _t = __t26;
967 >                        _t = __t30;
968                          _t = _t->getNextSibling();
969 < #line 108 "MDTreeParser.g"
969 > #line 115 "MDTreeParser.g"
970                          currAtomStamp->setPosition(dvec);
971 < #line 869 "MDTreeParser.cpp"
971 > #line 972 "MDTreeParser.cpp"
972                          break;
973                  }
974                  case ORIENTATION:
975                  {
976 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
977 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
976 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
977 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978                          match(_t,ORIENTATION);
979                          _t = _t->getFirstChild();
980                          dvec=doubleNumberTuple(_t);
981                          _t = _retTree;
982 <                        _t = __t27;
982 >                        _t = __t31;
983                          _t = _t->getNextSibling();
984 < #line 109 "MDTreeParser.g"
984 > #line 116 "MDTreeParser.g"
985                          currAtomStamp->setOrientation(dvec);
986 < #line 884 "MDTreeParser.cpp"
986 > #line 987 "MDTreeParser.cpp"
987                          break;
988                  }
989                  default:
# Line 897 | Line 1000 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1000          _retTree = _t;
1001   }
1002  
1003 < vector<double>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004 < #line 227 "MDTreeParser.g"
1005 <        vector<double> dvec;
1006 < #line 904 "MDTreeParser.cpp"
1007 <        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008 < #line 227 "MDTreeParser.g"
1003 > vector<RealType>  MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004 > #line 253 "MDTreeParser.g"
1005 >        vector<RealType> dvec;
1006 > #line 1007 "MDTreeParser.cpp"
1007 >        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008 > #line 253 "MDTreeParser.g"
1009          
1010 <        double dval;
1010 >        RealType dval;
1011          
1012 < #line 910 "MDTreeParser.cpp"
1012 > #line 1013 "MDTreeParser.cpp"
1013          
1014          try {      // for error handling
1015                  { // ( ... )+
1016 <                int _cnt65=0;
1016 >                int _cnt75=0;
1017                  for (;;) {
1018                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1019                                  _t = ASTNULL;
1020                          if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1021                                  dval=doubleNumber(_t);
1022                                  _t = _retTree;
1023 < #line 231 "MDTreeParser.g"
1023 > #line 257 "MDTreeParser.g"
1024                                  dvec.push_back(dval);
1025 < #line 923 "MDTreeParser.cpp"
1025 > #line 1026 "MDTreeParser.cpp"
1026                          }
1027                          else {
1028 <                                if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1028 >                                if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1029                          }
1030                          
1031 <                        _cnt65++;
1031 >                        _cnt75++;
1032                  }
1033 <                _loop65:;
1033 >                _loop75:;
1034                  }  // ( ... )+
1035          }
1036          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 940 | Line 1043 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1043   }
1044  
1045   void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1046 <        ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047 < #line 122 "MDTreeParser.g"
1046 >        ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047 > #line 129 "MDTreeParser.g"
1048          
1049          vector<int> ivec;
1050          BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1051          
1052 < #line 950 "MDTreeParser.cpp"
1052 > #line 1053 "MDTreeParser.cpp"
1053          
1054          try {      // for error handling
1055                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 960 | Line 1063 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1063                  }
1064                  case MEMBERS:
1065                  {
1066 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1067 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
1066 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1067 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1068                          match(_t,MEMBERS);
1069                          _t = _t->getFirstChild();
1070                          ivec=inttuple(_t);
1071                          _t = _retTree;
1072 <                        _t = __t33;
1072 >                        _t = __t37;
1073                          _t = _t->getNextSibling();
1074 < #line 128 "MDTreeParser.g"
1074 > #line 135 "MDTreeParser.g"
1075                          currBondStamp->setMembers(ivec);
1076 < #line 974 "MDTreeParser.cpp"
1076 > #line 1077 "MDTreeParser.cpp"
1077                          break;
1078                  }
1079                  default:
# Line 988 | Line 1091 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1091   }
1092  
1093   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1094 < #line 234 "MDTreeParser.g"
1094 > #line 260 "MDTreeParser.g"
1095          vector<int> ivec;
1096 < #line 994 "MDTreeParser.cpp"
1097 <        ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098 < #line 234 "MDTreeParser.g"
1096 > #line 1097 "MDTreeParser.cpp"
1097 >        ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098 > #line 260 "MDTreeParser.g"
1099          
1100          int ival;
1101          
1102 < #line 1000 "MDTreeParser.cpp"
1102 > #line 1103 "MDTreeParser.cpp"
1103          
1104          try {      // for error handling
1105                  { // ( ... )+
1106 <                int _cnt68=0;
1106 >                int _cnt78=0;
1107                  for (;;) {
1108                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1109                                  _t = ASTNULL;
1110                          if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1111                                  ival=intConst(_t);
1112                                  _t = _retTree;
1113 < #line 238 "MDTreeParser.g"
1113 > #line 264 "MDTreeParser.g"
1114                                  ivec.push_back(ival);
1115 < #line 1013 "MDTreeParser.cpp"
1115 > #line 1116 "MDTreeParser.cpp"
1116                          }
1117                          else {
1118 <                                if ( _cnt68>=1 ) { goto _loop68; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1118 >                                if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1119                          }
1120                          
1121 <                        _cnt68++;
1121 >                        _cnt78++;
1122                  }
1123 <                _loop68:;
1123 >                _loop78:;
1124                  }  // ( ... )+
1125          }
1126          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1030 | Line 1133 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1133   }
1134  
1135   void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1136 <        ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137 < #line 141 "MDTreeParser.g"
1136 >        ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137 > #line 148 "MDTreeParser.g"
1138          
1139          vector<int> ivec;
1140          BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1141          
1142 < #line 1040 "MDTreeParser.cpp"
1142 > #line 1143 "MDTreeParser.cpp"
1143          
1144          try {      // for error handling
1145                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1050 | Line 1153 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1153                  }
1154                  case MEMBERS:
1155                  {
1156 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1157 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1156 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1157 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1158                          match(_t,MEMBERS);
1159                          _t = _t->getFirstChild();
1160                          ivec=inttuple(_t);
1161                          _t = _retTree;
1162 <                        _t = __t39;
1162 >                        _t = __t43;
1163                          _t = _t->getNextSibling();
1164 < #line 147 "MDTreeParser.g"
1164 > #line 154 "MDTreeParser.g"
1165                          currBendStamp->setMembers(ivec);
1166 < #line 1064 "MDTreeParser.cpp"
1166 > #line 1167 "MDTreeParser.cpp"
1167                          break;
1168                  }
1169                  default:
# Line 1078 | Line 1181 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1181   }
1182  
1183   void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1184 <        ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185 < #line 160 "MDTreeParser.g"
1184 >        ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185 > #line 167 "MDTreeParser.g"
1186          
1187          vector<int> ivec;
1188          TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1189          
1190 < #line 1088 "MDTreeParser.cpp"
1190 > #line 1191 "MDTreeParser.cpp"
1191          
1192          try {      // for error handling
1193                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1098 | Line 1201 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1201                  }
1202                  case MEMBERS:
1203                  {
1204 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1205 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1204 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1205 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1206                          match(_t,MEMBERS);
1207                          _t = _t->getFirstChild();
1208                          ivec=inttuple(_t);
1209                          _t = _retTree;
1210 <                        _t = __t45;
1210 >                        _t = __t49;
1211                          _t = _t->getNextSibling();
1212 < #line 166 "MDTreeParser.g"
1212 > #line 173 "MDTreeParser.g"
1213                          currTorsionStamp->setMembers(ivec);
1214 < #line 1112 "MDTreeParser.cpp"
1214 > #line 1215 "MDTreeParser.cpp"
1215                          break;
1216                  }
1217                  default:
# Line 1125 | Line 1228 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1228          _retTree = _t;
1229   }
1230  
1231 + void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1232 +        ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1233 + #line 186 "MDTreeParser.g"
1234 +        
1235 +        int icent;
1236 +        InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1237 +        
1238 + #line 1239 "MDTreeParser.cpp"
1239 +        
1240 +        try {      // for error handling
1241 +                if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1242 +                        _t = ASTNULL;
1243 +                switch ( _t->getType()) {
1244 +                case ASSIGNEQUAL:
1245 +                {
1246 +                        assignment(_t);
1247 +                        _t = _retTree;
1248 +                        break;
1249 +                }
1250 +                case CENTER:
1251 +                {
1252 +                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1253 +                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1254 +                        match(_t,CENTER);
1255 +                        _t = _t->getFirstChild();
1256 +                        icent=intConst(_t);
1257 +                        _t = _retTree;
1258 +                        _t = __t55;
1259 +                        _t = _t->getNextSibling();
1260 + #line 192 "MDTreeParser.g"
1261 +                        currInversionStamp->setCenter(icent);
1262 + #line 1263 "MDTreeParser.cpp"
1263 +                        break;
1264 +                }
1265 +                default:
1266 +                {
1267 +                        throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1268 +                }
1269 +                }
1270 +        }
1271 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1272 +                reportError(ex);
1273 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1274 +                        _t = _t->getNextSibling();
1275 +        }
1276 +        _retTree = _t;
1277 + }
1278 +
1279   void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281 < #line 183 "MDTreeParser.g"
1280 >        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281 > #line 209 "MDTreeParser.g"
1282          
1283          vector<int> ivec;
1284          RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1285          
1286 < #line 1136 "MDTreeParser.cpp"
1286 > #line 1287 "MDTreeParser.cpp"
1287          
1288          try {      // for error handling
1289                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1146 | Line 1297 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1297                  }
1298                  case MEMBERS:
1299                  {
1300 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1301 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1300 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1301 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1302                          match(_t,MEMBERS);
1303                          _t = _t->getFirstChild();
1304                          ivec=inttuple(_t);
1305                          _t = _retTree;
1306 <                        _t = __t51;
1306 >                        _t = __t61;
1307                          _t = _t->getNextSibling();
1308 < #line 189 "MDTreeParser.g"
1308 > #line 215 "MDTreeParser.g"
1309                          currRigidBodyStamp->setMembers(ivec);
1310 < #line 1160 "MDTreeParser.cpp"
1310 > #line 1311 "MDTreeParser.cpp"
1311                          break;
1312                  }
1313                  default:
# Line 1174 | Line 1325 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1325   }
1326  
1327   void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328 <        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 < #line 202 "MDTreeParser.g"
1328 >        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 > #line 228 "MDTreeParser.g"
1330          
1331          vector<int> ivec;
1332          CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1333          
1334 < #line 1184 "MDTreeParser.cpp"
1334 > #line 1335 "MDTreeParser.cpp"
1335          
1336          try {      // for error handling
1337                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1194 | Line 1345 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1345                  }
1346                  case MEMBERS:
1347                  {
1348 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1349 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1348 >                        ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1349 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1350                          match(_t,MEMBERS);
1351                          _t = _t->getFirstChild();
1352                          ivec=inttuple(_t);
1353                          _t = _retTree;
1354 <                        _t = __t57;
1354 >                        _t = __t67;
1355                          _t = _t->getNextSibling();
1356 < #line 208 "MDTreeParser.g"
1356 > #line 234 "MDTreeParser.g"
1357                          currCutoffGroupStamp->setMembers(ivec);
1358 < #line 1208 "MDTreeParser.cpp"
1358 > #line 1359 "MDTreeParser.cpp"
1359                          break;
1360                  }
1361                  default:
# Line 1222 | Line 1373 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1373   }
1374  
1375   void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376 <        ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1376 >        ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1377          
1378          try {      // for error handling
1379                  assignment(_t);
# Line 1236 | Line 1387 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1387          _retTree = _t;
1388   }
1389  
1390 < double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391 < #line 248 "MDTreeParser.g"
1392 <        double dval;
1393 < #line 1243 "MDTreeParser.cpp"
1394 <        ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
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          
# Line 1254 | Line 1405 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1405                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406                          intConst(_t);
1407                          _t = _retTree;
1408 < #line 250 "MDTreeParser.g"
1409 <                        dval = lexi_cast<double>(ic->getText());
1410 < #line 1260 "MDTreeParser.cpp"
1408 > #line 276 "MDTreeParser.g"
1409 >                        dval = lexi_cast<RealType>(ic->getText());
1410 > #line 1411 "MDTreeParser.cpp"
1411                          break;
1412                  }
1413                  case NUM_FLOAT:
# Line 1265 | Line 1416 | double  MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE
1416                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417                          floatConst(_t);
1418                          _t = _retTree;
1419 < #line 251 "MDTreeParser.g"
1420 <                        dval = lexi_cast<double>(fc->getText());
1421 < #line 1271 "MDTreeParser.cpp"
1419 > #line 277 "MDTreeParser.g"
1420 >                        dval = lexi_cast<RealType>(fc->getText());
1421 > #line 1422 "MDTreeParser.cpp"
1422                          break;
1423                  }
1424                  default:
# Line 1296 | Line 1447 | const char* MDTreeParser::tokenNames[] = {
1447          "\"component\"",
1448          "\"molecule\"",
1449          "\"zconstraint\"",
1450 +        "\"restraint\"",
1451          "\"atom\"",
1452          "\"bond\"",
1453          "\"bend\"",
1454          "\"torsion\"",
1455 +        "\"inversion\"",
1456          "\"rigidBody\"",
1457          "\"cutoffGroup\"",
1458          "\"fragment\"",
1459          "\"members\"",
1460 +        "\"center\"",
1461          "\"position\"",
1462          "\"orientation\"",
1463          "ENDBLOCK",
# Line 1343 | Line 1497 | const char* MDTreeParser::tokenNames[] = {
1497          0
1498   };
1499  
1500 < const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1501 < // "component" "molecule" "zconstraint" ASSIGNEQUAL
1500 > const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1501 > // "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL
1502   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1503 < const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1504 < // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1505 < // ASSIGNEQUAL
1503 > const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
1504 > // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1505 > // "fragment" ASSIGNEQUAL
1506   const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1507  
1508  

Diff Legend

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