ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/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 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 __t13 = _t;
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 69 "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 133 | Line 139 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(
139                                  _t = _retTree;
140                          }
141                          else {
142 <                                goto _loop15;
142 >                                goto _loop11;
143                          }
144                          
145                  }
146 <                _loop15:;
146 >                _loop11:;
147                  } // ( ... )*
148                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
149                  match(_t,ENDBLOCK);
150                  _t = _t->getNextSibling();
151 <                _t = __t13;
151 >                _t = __t9;
152                  _t = _t->getNextSibling();
153 < #line 71 "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 __t21 = _t;
170                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
171                  match(_t,MOLECULE);
172                  _t = _t->getFirstChild();
173 < #line 79 "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 187 | Line 193 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a
193                  _t = _t->getNextSibling();
194                  _t = __t21;
195                  _t = _t->getNextSibling();
196 < #line 81 "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 __t17 = _t;
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 74 "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 )
222 >                                _t = ASTNULL;
223 >                        if ((_t->getType() == ASSIGNEQUAL)) {
224 >                                assignment(_t);
225 >                                _t = _retTree;
226 >                        }
227 >                        else {
228 >                                goto _loop15;
229 >                        }
230 >                        
231 >                }
232 >                _loop15:;
233 >                } // ( ... )*
234 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
235 >                match(_t,ENDBLOCK);
236 >                _t = _t->getNextSibling();
237 >                _t = __t13;
238 >                _t = _t->getNextSibling();
239 > #line 70 "MDTreeParser.g"
240 >                blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
241 > #line 242 "MDTreeParser.cpp"
242 >        }
243 >        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
244 >                reportError(ex);
245 >                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
246 >                        _t = _t->getNextSibling();
247 >        }
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 )
# Line 225 | Line 274 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC
274                  }
275                  _loop19:;
276                  } // ( ... )*
277 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
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 76 "MDTreeParser.g"
283 <                blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
284 < #line 236 "MDTreeParser.cpp"
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);
# Line 245 | Line 294 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
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 48 "MDTreeParser.g"
301 +        
302 +        int ival;
303 +        RealType dval;
304 +        
305 + #line 306 "MDTreeParser.cpp"
306          
307          try {      // for error handling
308                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
309                          _t = ASTNULL;
310                  switch ( _t->getType()) {
311 <                case OCTALINT:
312 <                case DECIMALINT:
258 <                case HEXADECIMALINT:
259 <                case FLOATONE:
260 <                case FLOATTWO:
261 <                case MINUS:
311 >                case NUM_INT:
312 >                case NUM_LONG:
313                  {
314 <                        signedIntOrFloat(_t,id);
314 >                        ival=intConst(_t);
315                          _t = _retTree;
316 + #line 53 "MDTreeParser.g"
317 +                        blockStack.top()->assign(id->getText(), ival);
318 + #line 319 "MDTreeParser.cpp"
319                          break;
320                  }
321 +                case NUM_FLOAT:
322 +                case NUM_DOUBLE:
323 +                {
324 +                        dval=floatConst(_t);
325 +                        _t = _retTree;
326 + #line 54 "MDTreeParser.g"
327 +                        blockStack.top()->assign(id->getText(), dval);
328 + #line 329 "MDTreeParser.cpp"
329 +                        break;
330 +                }
331                  case ID:
332                  {
333                          str1 = _t;
334                          match(_t,ID);
335                          _t = _t->getNextSibling();
336 < #line 49 "MDTreeParser.g"
336 > #line 55 "MDTreeParser.g"
337                          blockStack.top()->assign(id->getText(), str1->getText());
338 < #line 275 "MDTreeParser.cpp"
338 > #line 339 "MDTreeParser.cpp"
339                          break;
340                  }
341                  case StringLiteral:
# Line 279 | Line 343 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
343                          str2 = _t;
344                          match(_t,StringLiteral);
345                          _t = _t->getNextSibling();
346 < #line 50 "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 288 "MDTreeParser.cpp"
351 > #line 352 "MDTreeParser.cpp"
352                          break;
353                  }
354                  default:
# Line 301 | Line 365 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)
365          _retTree = _t;
366   }
367  
368 < void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
369 <        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 <        
368 > int  MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
369 > #line 268 "MDTreeParser.g"
370          int ival;
371 <        double dval;
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          
317 – #line 318 "MDTreeParser.cpp"
318 –        
376          try {      // for error handling
377                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
378                          _t = ASTNULL;
379                  switch ( _t->getType()) {
380 <                case MINUS:
380 >                case NUM_INT:
381                  {
382 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
383 <                        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;
382 >                        i1 = _t;
383 >                        match(_t,NUM_INT);
384                          _t = _t->getNextSibling();
385 + #line 269 "MDTreeParser.g"
386 +                        ival = lexi_cast<int>(i1->getText());
387 + #line 388 "MDTreeParser.cpp"
388                          break;
389                  }
390 <                case OCTALINT:
367 <                case DECIMALINT:
368 <                case HEXADECIMALINT:
369 <                case FLOATONE:
370 <                case FLOATTWO:
390 >                case NUM_LONG:
391                  {
392 <                        {
393 <                        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 )
392 >                        i2 = _t;
393 >                        match(_t,NUM_LONG);
394                          _t = _t->getNextSibling();
395 <        }
396 <        _retTree = _t;
397 < }
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"
395 > #line 270 "MDTreeParser.g"
396 >                        ival = lexi_cast<int>(i2->getText());
397 > #line 398 "MDTreeParser.cpp"
398                          break;
399                  }
444 –                case DECIMALINT:
445 –                {
446 –                        dival = _t;
447 –                        match(_t,DECIMALINT);
448 –                        _t = _t->getNextSibling();
449 – #line 251 "MDTreeParser.g"
450 –                        ival = lexi_cast<int>(dival->getText());
451 – #line 452 "MDTreeParser.cpp"
452 –                        break;
453 –                }
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 –                }
400                  default:
401                  {
402                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
# Line 476 | 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 264 "MDTreeParser.g"
417 <        double dval;
418 < #line 483 "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 488 | Line 424 | double  MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a
424                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
425                          _t = ASTNULL;
426                  switch ( _t->getType()) {
427 <                case FLOATONE:
427 >                case NUM_FLOAT:
428                  {
429                          d1 = _t;
430 <                        match(_t,FLOATONE);
430 >                        match(_t,NUM_FLOAT);
431                          _t = _t->getNextSibling();
432 < #line 265 "MDTreeParser.g"
433 <                        dval = lexi_cast<double>(d1->getText());
434 < #line 499 "MDTreeParser.cpp"
432 > #line 283 "MDTreeParser.g"
433 >                        dval = lexi_cast<RealType>(d1->getText());
434 > #line 435 "MDTreeParser.cpp"
435                          break;
436                  }
437 <                case FLOATTWO:
437 >                case NUM_DOUBLE:
438                  {
439                          d2 = _t;
440 <                        match(_t,FLOATTWO);
440 >                        match(_t,NUM_DOUBLE);
441                          _t = _t->getNextSibling();
442 < #line 266 "MDTreeParser.g"
443 <                        dval = lexi_cast<double>(d2->getText());
444 < #line 509 "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 524 | 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 560 | 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 593 | 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;
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 602 "MDTreeParser.cpp"
543 > #line 544 "MDTreeParser.cpp"
544          
545          try {      // for error handling
546                  ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
547 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _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 98 "MDTreeParser.g"
553                  AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554 < #line 613 "MDTreeParser.cpp"
554 > #line 555 "MDTreeParser.cpp"
555                  { // ( ... )*
556                  for (;;) {
557                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 625 | Line 567 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
567                  }
568                  _loop28:;
569                  } // ( ... )*
570 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
570 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
571                  match(_t,ENDBLOCK);
572                  _t = _t->getNextSibling();
573                  _t = __t26;
# Line 637 | Line 579 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr
579                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
580                  currMoleculeStamp->addAtomStamp(currAtomStamp);
581                  
582 < #line 641 "MDTreeParser.cpp"
582 > #line 583 "MDTreeParser.cpp"
583          }
584          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
585                  reportError(ex);
# Line 648 | 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 __t33 = _t;
597 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
597 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
598                  match(_t,BOND);
599                  _t = _t->getFirstChild();
600   #line 120 "MDTreeParser.g"
601                  BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602 < #line 661 "MDTreeParser.cpp"
602 > #line 603 "MDTreeParser.cpp"
603                  { // ( ... )*
604                  for (;;) {
605                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 673 | Line 615 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
615                  }
616                  _loop35:;
617                  } // ( ... )*
618 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
618 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
619                  match(_t,ENDBLOCK);
620                  _t = _t->getNextSibling();
621                  _t = __t33;
# Line 684 | Line 626 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr
626                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
627                  currMoleculeStamp->addBondStamp(currBondStamp);
628                  
629 < #line 688 "MDTreeParser.cpp"
629 > #line 630 "MDTreeParser.cpp"
630          }
631          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
632                  reportError(ex);
# Line 695 | 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 __t39 = _t;
644 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
644 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
645                  match(_t,BEND);
646                  _t = _t->getFirstChild();
647   #line 138 "MDTreeParser.g"
648                  BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649 < #line 708 "MDTreeParser.cpp"
649 > #line 650 "MDTreeParser.cpp"
650                  { // ( ... )*
651                  for (;;) {
652                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 720 | Line 662 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
662                  }
663                  _loop41:;
664                  } // ( ... )*
665 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
665 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
666                  match(_t,ENDBLOCK);
667                  _t = _t->getNextSibling();
668                  _t = __t39;
# Line 732 | Line 674 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr
674                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
675                  currMoleculeStamp->addBendStamp(currBendStamp);
676                  
677 < #line 736 "MDTreeParser.cpp"
677 > #line 678 "MDTreeParser.cpp"
678          }
679          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
680                  reportError(ex);
# Line 743 | 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 __t45 = _t;
692 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
692 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
693                  match(_t,TORSION);
694                  _t = _t->getFirstChild();
695   #line 157 "MDTreeParser.g"
696                  TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697 < #line 756 "MDTreeParser.cpp"
697 > #line 698 "MDTreeParser.cpp"
698                  { // ( ... )*
699                  for (;;) {
700                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 768 | Line 710 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
710                  }
711                  _loop47:;
712                  } // ( ... )*
713 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
713 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714                  match(_t,ENDBLOCK);
715                  _t = _t->getNextSibling();
716                  _t = __t45;
# Line 780 | Line 722 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
722                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723                  currMoleculeStamp->addTorsionStamp(currTorsionStamp);
724                  
725 < #line 784 "MDTreeParser.cpp"
725 > #line 726 "MDTreeParser.cpp"
726          }
727          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728                  reportError(ex);
# Line 790 | Line 732 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an
732          _retTree = _t;
733   }
734  
735 < void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
736 <        ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
795 < #line 176 "MDTreeParser.g"
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          
797 –        int index;
798 –        
799 – #line 800 "MDTreeParser.cpp"
800 –        
738          try {      // for error handling
739                  ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
740 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
741 <                match(_t,RIGIDBODY);
740 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741 >                match(_t,INVERSION);
742                  _t = _t->getFirstChild();
743 <                index=intConst(_t);
744 <                _t = _retTree;
745 < #line 180 "MDTreeParser.g"
809 <                RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
810 < #line 811 "MDTreeParser.cpp"
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() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
751 <                                rigidbodystatement(_t);
750 >                        if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
751 >                                inversionstatement(_t);
752                                  _t = _retTree;
753                          }
754                          else {
# Line 823 | Line 758 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
758                  }
759                  _loop53:;
760                  } // ( ... )*
761 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
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 182 "MDTreeParser.g"
766 > #line 178 "MDTreeParser.g"
767                  
768                  blockStack.top()->validate();
769                  blockStack.pop();
770                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771 <                currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
771 >                currMoleculeStamp->addInversionStamp(currInversionStamp);
772                  
773 < #line 839 "MDTreeParser.cpp"
773 > #line 774 "MDTreeParser.cpp"
774          }
775          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776                  reportError(ex);
# Line 845 | Line 780 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(
780          _retTree = _t;
781   }
782  
783 < void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784 <        ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
783 > void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 790 "MDTreeParser.cpp"
790 +        
791          try {      // for error handling
792                  ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
793 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
794 <                match(_t,CUTOFFGROUP);
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 199 "MDTreeParser.g"
799 <                CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
800 < #line 859 "MDTreeParser.cpp"
799 >                RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800 > #line 801 "MDTreeParser.cpp"
801                  { // ( ... )*
802                  for (;;) {
803                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
804                                  _t = ASTNULL;
805                          if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
806 <                                cutoffgroupstatement(_t);
806 >                                rigidbodystatement(_t);
807                                  _t = _retTree;
808                          }
809                          else {
# Line 871 | Line 813 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
813                  }
814                  _loop59:;
815                  } // ( ... )*
816 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
816 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817                  match(_t,ENDBLOCK);
818                  _t = _t->getNextSibling();
819                  _t = __t57;
# Line 881 | Line 823 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC
823                  blockStack.top()->validate();
824                  blockStack.pop();
825                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
826 +                currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
827 +                
828 + #line 829 "MDTreeParser.cpp"
829 +        }
830 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
831 +                reportError(ex);
832 +                if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
833 +                        _t = _t->getNextSibling();
834 +        }
835 +        _retTree = _t;
836 + }
837 +
838 + void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _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 __t63 = _t;
843 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
844 +                match(_t,CUTOFFGROUP);
845 +                _t = _t->getFirstChild();
846 + #line 218 "MDTreeParser.g"
847 +                CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848 + #line 849 "MDTreeParser.cpp"
849 +                { // ( ... )*
850 +                for (;;) {
851 +                        if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
852 +                                _t = ASTNULL;
853 +                        if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
854 +                                cutoffgroupstatement(_t);
855 +                                _t = _retTree;
856 +                        }
857 +                        else {
858 +                                goto _loop65;
859 +                        }
860 +                        
861 +                }
862 +                _loop65:;
863 +                } // ( ... )*
864 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865 +                match(_t,ENDBLOCK);
866 +                _t = _t->getNextSibling();
867 +                _t = __t63;
868 +                _t = _t->getNextSibling();
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 887 "MDTreeParser.cpp"
876 > #line 877 "MDTreeParser.cpp"
877          }
878          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
879                  reportError(ex);
# Line 894 | 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 218 "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 901 "MDTreeParser.cpp"
890 > #line 891 "MDTreeParser.cpp"
891          
892          try {      // for error handling
893 <                ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
894 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_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 219 "MDTreeParser.g"
899 > #line 238 "MDTreeParser.g"
900                  FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901 < #line 912 "MDTreeParser.cpp"
901 > #line 902 "MDTreeParser.cpp"
902                  { // ( ... )*
903                  for (;;) {
904                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 918 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a
908                                  _t = _retTree;
909                          }
910                          else {
911 <                                goto _loop65;
911 >                                goto _loop71;
912                          }
913                          
914                  }
915 <                _loop65:;
915 >                _loop71:;
916                  } // ( ... )*
917 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
917 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918                  match(_t,ENDBLOCK);
919                  _t = _t->getNextSibling();
920 <                _t = __t63;
920 >                _t = __t69;
921                  _t = _t->getNextSibling();
922 < #line 221 "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 940 "MDTreeParser.cpp"
929 > #line 930 "MDTreeParser.cpp"
930          }
931          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
932                  reportError(ex);
# Line 947 | 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;
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 958 "MDTreeParser.cpp"
947 > #line 948 "MDTreeParser.cpp"
948          
949          try {      // for error handling
950                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 969 | Line 959 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
959                  case POSITION:
960                  {
961                          ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
962 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
962 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
963                          match(_t,POSITION);
964                          _t = _t->getFirstChild();
965 <                        dvec=signedNumberTuple(_t);
965 >                        dvec=doubleNumberTuple(_t);
966                          _t = _retTree;
967                          _t = __t30;
968                          _t = _t->getNextSibling();
969   #line 115 "MDTreeParser.g"
970                          currAtomStamp->setPosition(dvec);
971 < #line 982 "MDTreeParser.cpp"
971 > #line 972 "MDTreeParser.cpp"
972                          break;
973                  }
974                  case ORIENTATION:
975                  {
976                          ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
977 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
977 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978                          match(_t,ORIENTATION);
979                          _t = _t->getFirstChild();
980 <                        dvec=signedNumberTuple(_t);
980 >                        dvec=doubleNumberTuple(_t);
981                          _t = _retTree;
982                          _t = __t31;
983                          _t = _t->getNextSibling();
984   #line 116 "MDTreeParser.g"
985                          currAtomStamp->setOrientation(dvec);
986 < #line 997 "MDTreeParser.cpp"
986 > #line 987 "MDTreeParser.cpp"
987                          break;
988                  }
989                  default:
# Line 1010 | Line 1000 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a
1000          _retTree = _t;
1001   }
1002  
1003 < vector<double>  MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004 < #line 234 "MDTreeParser.g"
1005 <        vector<double> dvec;
1006 < #line 1017 "MDTreeParser.cpp"
1007 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008 < #line 234 "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 1023 "MDTreeParser.cpp"
1012 > #line 1013 "MDTreeParser.cpp"
1013          
1014          try {      // for error handling
1015                  { // ( ... )+
1016 <                int _cnt69=0;
1016 >                int _cnt75=0;
1017                  for (;;) {
1018                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1019                                  _t = ASTNULL;
1020 <                        if (((_t->getType() >= OCTALINT && _t->getType() <= FLOATTWO))) {
1021 <                                dval=signedNumber(_t);
1020 >                        if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1021 >                                dval=doubleNumber(_t);
1022                                  _t = _retTree;
1023 < #line 238 "MDTreeParser.g"
1023 > #line 257 "MDTreeParser.g"
1024                                  dvec.push_back(dval);
1025 < #line 1036 "MDTreeParser.cpp"
1025 > #line 1026 "MDTreeParser.cpp"
1026                          }
1027                          else {
1028 <                                if ( _cnt69>=1 ) { goto _loop69; } 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 <                        _cnt69++;
1031 >                        _cnt75++;
1032                  }
1033 <                _loop69:;
1033 >                _loop75:;
1034                  }  // ( ... )+
1035          }
1036          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1053 | 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;
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 1063 "MDTreeParser.cpp"
1052 > #line 1053 "MDTreeParser.cpp"
1053          
1054          try {      // for error handling
1055                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1074 | Line 1064 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1064                  case MEMBERS:
1065                  {
1066                          ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1067 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1067 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1068                          match(_t,MEMBERS);
1069                          _t = _t->getFirstChild();
1070                          ivec=inttuple(_t);
# Line 1083 | Line 1073 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a
1073                          _t = _t->getNextSibling();
1074   #line 135 "MDTreeParser.g"
1075                          currBondStamp->setMembers(ivec);
1076 < #line 1087 "MDTreeParser.cpp"
1076 > #line 1077 "MDTreeParser.cpp"
1077                          break;
1078                  }
1079                  default:
# Line 1101 | Line 1091 | vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPAC
1091   }
1092  
1093   vector<int>  MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1094 < #line 241 "MDTreeParser.g"
1094 > #line 260 "MDTreeParser.g"
1095          vector<int> ivec;
1096 < #line 1107 "MDTreeParser.cpp"
1097 <        ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098 < #line 241 "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 1113 "MDTreeParser.cpp"
1102 > #line 1103 "MDTreeParser.cpp"
1103          
1104          try {      // for error handling
1105                  { // ( ... )+
1106 <                int _cnt72=0;
1106 >                int _cnt78=0;
1107                  for (;;) {
1108                          if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1109                                  _t = ASTNULL;
1110 <                        if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) {
1110 >                        if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1111                                  ival=intConst(_t);
1112                                  _t = _retTree;
1113 < #line 245 "MDTreeParser.g"
1113 > #line 264 "MDTreeParser.g"
1114                                  ivec.push_back(ival);
1115 < #line 1126 "MDTreeParser.cpp"
1115 > #line 1116 "MDTreeParser.cpp"
1116                          }
1117                          else {
1118 <                                if ( _cnt72>=1 ) { goto _loop72; } 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 <                        _cnt72++;
1121 >                        _cnt78++;
1122                  }
1123 <                _loop72:;
1123 >                _loop78:;
1124                  }  // ( ... )+
1125          }
1126          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 1143 | 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;
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 1153 "MDTreeParser.cpp"
1142 > #line 1143 "MDTreeParser.cpp"
1143          
1144          try {      // for error handling
1145                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1164 | Line 1154 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1154                  case MEMBERS:
1155                  {
1156                          ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1157 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1157 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1158                          match(_t,MEMBERS);
1159                          _t = _t->getFirstChild();
1160                          ivec=inttuple(_t);
# Line 1173 | Line 1163 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a
1163                          _t = _t->getNextSibling();
1164   #line 154 "MDTreeParser.g"
1165                          currBendStamp->setMembers(ivec);
1166 < #line 1177 "MDTreeParser.cpp"
1166 > #line 1167 "MDTreeParser.cpp"
1167                          break;
1168                  }
1169                  default:
# Line 1191 | 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;
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 1201 "MDTreeParser.cpp"
1190 > #line 1191 "MDTreeParser.cpp"
1191          
1192          try {      // for error handling
1193                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1212 | Line 1202 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1202                  case MEMBERS:
1203                  {
1204                          ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1205 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1205 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1206                          match(_t,MEMBERS);
1207                          _t = _t->getFirstChild();
1208                          ivec=inttuple(_t);
# Line 1221 | Line 1211 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC
1211                          _t = _t->getNextSibling();
1212   #line 173 "MDTreeParser.g"
1213                          currTorsionStamp->setMembers(ivec);
1214 < #line 1225 "MDTreeParser.cpp"
1214 > #line 1215 "MDTreeParser.cpp"
1215                          break;
1216                  }
1217                  default:
# Line 1238 | 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 190 "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 1249 "MDTreeParser.cpp"
1286 > #line 1287 "MDTreeParser.cpp"
1287          
1288          try {      // for error handling
1289                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1259 | Line 1297 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP
1297                  }
1298                  case MEMBERS:
1299                  {
1300 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1301 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_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 = __t55;
1306 >                        _t = __t61;
1307                          _t = _t->getNextSibling();
1308 < #line 196 "MDTreeParser.g"
1308 > #line 215 "MDTreeParser.g"
1309                          currRigidBodyStamp->setMembers(ivec);
1310 < #line 1273 "MDTreeParser.cpp"
1310 > #line 1311 "MDTreeParser.cpp"
1311                          break;
1312                  }
1313                  default:
# Line 1287 | 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 209 "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 1297 "MDTreeParser.cpp"
1334 > #line 1335 "MDTreeParser.cpp"
1335          
1336          try {      // for error handling
1337                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
# Line 1307 | Line 1345 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME
1345                  }
1346                  case MEMBERS:
1347                  {
1348 <                        ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1349 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_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 = __t61;
1354 >                        _t = __t67;
1355                          _t = _t->getNextSibling();
1356 < #line 215 "MDTreeParser.g"
1356 > #line 234 "MDTreeParser.g"
1357                          currCutoffGroupStamp->setMembers(ivec);
1358 < #line 1321 "MDTreeParser.cpp"
1358 > #line 1359 "MDTreeParser.cpp"
1359                          break;
1360                  }
1361                  default:
# Line 1335 | 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 1349 | Line 1387 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA
1387          _retTree = _t;
1388   }
1389  
1390 < double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391 < #line 256 "MDTreeParser.g"
1392 <        double dval;
1393 < #line 1356 "MDTreeParser.cpp"
1394 <        ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_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 1361 | Line 1399 | double  MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE
1399                  if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1400                          _t = ASTNULL;
1401                  switch ( _t->getType()) {
1402 <                case OCTALINT:
1403 <                case DECIMALINT:
1366 <                case HEXADECIMALINT:
1402 >                case NUM_INT:
1403 >                case NUM_LONG:
1404                  {
1405                          ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406                          intConst(_t);
1407                          _t = _retTree;
1408 < #line 258 "MDTreeParser.g"
1409 <                        dval = lexi_cast<double>(ic->getText());
1410 < #line 1374 "MDTreeParser.cpp"
1408 > #line 276 "MDTreeParser.g"
1409 >                        dval = lexi_cast<RealType>(ic->getText());
1410 > #line 1411 "MDTreeParser.cpp"
1411                          break;
1412                  }
1413 <                case FLOATONE:
1414 <                case FLOATTWO:
1413 >                case NUM_FLOAT:
1414 >                case NUM_DOUBLE:
1415                  {
1416                          fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417                          floatConst(_t);
1418                          _t = _retTree;
1419 < #line 259 "MDTreeParser.g"
1420 <                        dval = lexi_cast<double>(fc->getText());
1421 < #line 1385 "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 1410 | 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 1432 | Line 1472 | const char* MDTreeParser::tokenNames[] = {
1472          "LPAREN",
1473          "RPAREN",
1474          "COMMA",
1475 <        "OCTALINT",
1476 <        "DECIMALINT",
1477 <        "HEXADECIMALINT",
1478 <        "FLOATONE",
1439 <        "FLOATTWO",
1475 >        "NUM_INT",
1476 >        "NUM_LONG",
1477 >        "NUM_FLOAT",
1478 >        "NUM_DOUBLE",
1479          "DOT",
1480          "COLON",
1481          "QUESTIONMARK",
# Line 1449 | Line 1488 | const char* MDTreeParser::tokenNames[] = {
1488          "CharLiteral",
1489          "EndOfLine",
1490          "Escape",
1491 +        "Vocabulary",
1492          "Digit",
1493          "Decimal",
1494 <        "LongSuffix",
1495 <        "UnsignedSuffix",
1496 <        "FloatSuffix",
1457 <        "Exponent",
1458 <        "Vocabulary",
1459 <        "Number",
1460 <        "MINUS",
1494 >        "HEX_DIGIT",
1495 >        "EXPONENT",
1496 >        "FLOAT_SUFFIX",
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