# | Line 1 | Line 1 | |
---|---|---|
1 | < | /* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */ |
1 | > | /* $ANTLR 2.7.7 (20140107): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */ |
2 | #include "MDTreeParser.hpp" | |
3 | #include <antlr/Token.hpp> | |
4 | #include <antlr/AST.hpp> | |
# | Line 80 | Line 80 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr | |
80 | _t = _retTree; | |
81 | break; | |
82 | } | |
83 | + | case FLUCQ: |
84 | + | { |
85 | + | flucqblock(_t); |
86 | + | _t = _retTree; |
87 | + | break; |
88 | + | } |
89 | + | case RNEMD: |
90 | + | { |
91 | + | rnemdblock(_t); |
92 | + | _t = _retTree; |
93 | + | break; |
94 | + | } |
95 | + | case MINIMIZER: |
96 | + | { |
97 | + | minimizerblock(_t); |
98 | + | _t = _retTree; |
99 | + | break; |
100 | + | } |
101 | default: | |
102 | { | |
103 | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); | |
# | Line 123 | Line 141 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE( | |
141 | ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
142 | ||
143 | try { // for error handling | |
144 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t; |
144 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t; |
145 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t; | |
146 | match(_t,COMPONENT); | |
147 | _t = _t->getFirstChild(); | |
148 | < | #line 63 "MDTreeParser.g" |
148 | > | #line 72 "MDTreeParser.g" |
149 | Component* currComponet = new Component(); blockStack.push(currComponet); | |
150 | < | #line 133 "MDTreeParser.cpp" |
150 | > | #line 151 "MDTreeParser.cpp" |
151 | { // ( ... )* | |
152 | for (;;) { | |
153 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 139 | Line 157 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE( | |
157 | _t = _retTree; | |
158 | } | |
159 | else { | |
160 | < | goto _loop11; |
160 | > | goto _loop12; |
161 | } | |
162 | ||
163 | } | |
164 | < | _loop11:; |
164 | > | _loop12:; |
165 | } // ( ... )* | |
166 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t; | |
167 | match(_t,ENDBLOCK); | |
168 | _t = _t->getNextSibling(); | |
169 | < | _t = __t9; |
169 | > | _t = __t10; |
170 | _t = _t->getNextSibling(); | |
171 | < | #line 65 "MDTreeParser.g" |
171 | > | #line 74 "MDTreeParser.g" |
172 | blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet); | |
173 | < | #line 156 "MDTreeParser.cpp" |
173 | > | #line 174 "MDTreeParser.cpp" |
174 | } | |
175 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
176 | reportError(ex); | |
# | Line 166 | Line 184 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a | |
184 | ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
185 | ||
186 | try { // for error handling | |
187 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t; |
187 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t; |
188 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t; | |
189 | match(_t,MOLECULE); | |
190 | _t = _t->getFirstChild(); | |
191 | < | #line 78 "MDTreeParser.g" |
191 | > | #line 103 "MDTreeParser.g" |
192 | MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp); | |
193 | < | #line 176 "MDTreeParser.cpp" |
193 | > | #line 194 "MDTreeParser.cpp" |
194 | { // ( ... )* | |
195 | for (;;) { | |
196 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 182 | Line 200 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a | |
200 | _t = _retTree; | |
201 | } | |
202 | else { | |
203 | < | goto _loop23; |
203 | > | goto _loop36; |
204 | } | |
205 | ||
206 | } | |
207 | < | _loop23:; |
207 | > | _loop36:; |
208 | } // ( ... )* | |
209 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t; | |
210 | match(_t,ENDBLOCK); | |
211 | _t = _t->getNextSibling(); | |
212 | < | _t = __t21; |
212 | > | _t = __t34; |
213 | _t = _t->getNextSibling(); | |
214 | < | #line 80 "MDTreeParser.g" |
214 | > | #line 105 "MDTreeParser.g" |
215 | blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp); | |
216 | < | #line 199 "MDTreeParser.cpp" |
216 | > | #line 217 "MDTreeParser.cpp" |
217 | } | |
218 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
219 | reportError(ex); | |
# | Line 209 | Line 227 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC | |
227 | ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
228 | ||
229 | try { // for error handling | |
230 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t; |
230 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t; |
231 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t; | |
232 | match(_t,ZCONSTRAINT); | |
233 | _t = _t->getFirstChild(); | |
234 | < | #line 68 "MDTreeParser.g" |
234 | > | #line 77 "MDTreeParser.g" |
235 | ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp); | |
236 | < | #line 219 "MDTreeParser.cpp" |
236 | > | #line 237 "MDTreeParser.cpp" |
237 | { // ( ... )* | |
238 | for (;;) { | |
239 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 225 | Line 243 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC | |
243 | _t = _retTree; | |
244 | } | |
245 | else { | |
246 | < | goto _loop15; |
246 | > | goto _loop16; |
247 | } | |
248 | ||
249 | } | |
250 | < | _loop15:; |
250 | > | _loop16:; |
251 | } // ( ... )* | |
252 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t; | |
253 | match(_t,ENDBLOCK); | |
254 | _t = _t->getNextSibling(); | |
255 | < | _t = __t13; |
255 | > | _t = __t14; |
256 | _t = _t->getNextSibling(); | |
257 | < | #line 70 "MDTreeParser.g" |
257 | > | #line 79 "MDTreeParser.g" |
258 | blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp); | |
259 | < | #line 242 "MDTreeParser.cpp" |
259 | > | #line 260 "MDTreeParser.cpp" |
260 | } | |
261 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
262 | reportError(ex); | |
# | Line 252 | Line 270 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE( | |
270 | ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
271 | ||
272 | try { // for error handling | |
273 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t; |
273 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t18 = _t; |
274 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t; | |
275 | match(_t,RESTRAINT); | |
276 | _t = _t->getFirstChild(); | |
277 | < | #line 73 "MDTreeParser.g" |
277 | > | #line 82 "MDTreeParser.g" |
278 | RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp); | |
279 | < | #line 262 "MDTreeParser.cpp" |
279 | > | #line 280 "MDTreeParser.cpp" |
280 | { // ( ... )* | |
281 | for (;;) { | |
282 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 268 | Line 286 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE( | |
286 | _t = _retTree; | |
287 | } | |
288 | else { | |
289 | < | goto _loop19; |
289 | > | goto _loop20; |
290 | } | |
291 | ||
292 | } | |
293 | < | _loop19:; |
293 | > | _loop20:; |
294 | } // ( ... )* | |
295 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t; | |
296 | match(_t,ENDBLOCK); | |
297 | _t = _t->getNextSibling(); | |
298 | < | _t = __t17; |
298 | > | _t = __t18; |
299 | _t = _t->getNextSibling(); | |
300 | < | #line 75 "MDTreeParser.g" |
300 | > | #line 84 "MDTreeParser.g" |
301 | blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp); | |
302 | < | #line 285 "MDTreeParser.cpp" |
302 | > | #line 303 "MDTreeParser.cpp" |
303 | } | |
304 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
305 | reportError(ex); | |
# | Line 291 | Line 309 | void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE( | |
309 | _retTree = _t; | |
310 | } | |
311 | ||
312 | + | void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
313 | + | ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
314 | + | |
315 | + | try { // for error handling |
316 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t; |
317 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t; |
318 | + | match(_t,FLUCQ); |
319 | + | _t = _t->getFirstChild(); |
320 | + | #line 87 "MDTreeParser.g" |
321 | + | FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars); |
322 | + | #line 323 "MDTreeParser.cpp" |
323 | + | { // ( ... )* |
324 | + | for (;;) { |
325 | + | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
326 | + | _t = ASTNULL; |
327 | + | if ((_t->getType() == ASSIGNEQUAL)) { |
328 | + | assignment(_t); |
329 | + | _t = _retTree; |
330 | + | } |
331 | + | else { |
332 | + | goto _loop24; |
333 | + | } |
334 | + | |
335 | + | } |
336 | + | _loop24:; |
337 | + | } // ( ... )* |
338 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t; |
339 | + | match(_t,ENDBLOCK); |
340 | + | _t = _t->getNextSibling(); |
341 | + | _t = __t22; |
342 | + | _t = _t->getNextSibling(); |
343 | + | #line 89 "MDTreeParser.g" |
344 | + | blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars); |
345 | + | #line 346 "MDTreeParser.cpp" |
346 | + | } |
347 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
348 | + | reportError(ex); |
349 | + | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
350 | + | _t = _t->getNextSibling(); |
351 | + | } |
352 | + | _retTree = _t; |
353 | + | } |
354 | + | |
355 | + | void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
356 | + | ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
357 | + | |
358 | + | try { // for error handling |
359 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t; |
360 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t; |
361 | + | match(_t,RNEMD); |
362 | + | _t = _t->getFirstChild(); |
363 | + | #line 92 "MDTreeParser.g" |
364 | + | RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars); |
365 | + | #line 366 "MDTreeParser.cpp" |
366 | + | { // ( ... )* |
367 | + | for (;;) { |
368 | + | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
369 | + | _t = ASTNULL; |
370 | + | if ((_t->getType() == ASSIGNEQUAL)) { |
371 | + | assignment(_t); |
372 | + | _t = _retTree; |
373 | + | } |
374 | + | else { |
375 | + | goto _loop28; |
376 | + | } |
377 | + | |
378 | + | } |
379 | + | _loop28:; |
380 | + | } // ( ... )* |
381 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t; |
382 | + | match(_t,ENDBLOCK); |
383 | + | _t = _t->getNextSibling(); |
384 | + | _t = __t26; |
385 | + | _t = _t->getNextSibling(); |
386 | + | #line 94 "MDTreeParser.g" |
387 | + | blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars); |
388 | + | #line 389 "MDTreeParser.cpp" |
389 | + | } |
390 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
391 | + | reportError(ex); |
392 | + | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
393 | + | _t = _t->getNextSibling(); |
394 | + | } |
395 | + | _retTree = _t; |
396 | + | } |
397 | + | |
398 | + | void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
399 | + | ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
400 | + | |
401 | + | try { // for error handling |
402 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t; |
403 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t; |
404 | + | match(_t,MINIMIZER); |
405 | + | _t = _t->getFirstChild(); |
406 | + | #line 97 "MDTreeParser.g" |
407 | + | MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars); |
408 | + | #line 409 "MDTreeParser.cpp" |
409 | + | { // ( ... )* |
410 | + | for (;;) { |
411 | + | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
412 | + | _t = ASTNULL; |
413 | + | if ((_t->getType() == ASSIGNEQUAL)) { |
414 | + | assignment(_t); |
415 | + | _t = _retTree; |
416 | + | } |
417 | + | else { |
418 | + | goto _loop32; |
419 | + | } |
420 | + | |
421 | + | } |
422 | + | _loop32:; |
423 | + | } // ( ... )* |
424 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t; |
425 | + | match(_t,ENDBLOCK); |
426 | + | _t = _t->getNextSibling(); |
427 | + | _t = __t30; |
428 | + | _t = _t->getNextSibling(); |
429 | + | #line 99 "MDTreeParser.g" |
430 | + | blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars); |
431 | + | #line 432 "MDTreeParser.cpp" |
432 | + | } |
433 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
434 | + | reportError(ex); |
435 | + | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
436 | + | _t = _t->getNextSibling(); |
437 | + | } |
438 | + | _retTree = _t; |
439 | + | } |
440 | + | |
441 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t, | |
442 | ANTLR_USE_NAMESPACE(antlr)RefAST id | |
443 | ) { | |
444 | ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
445 | ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
446 | ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
447 | < | #line 48 "MDTreeParser.g" |
447 | > | #line 50 "MDTreeParser.g" |
448 | ||
449 | int ival; | |
450 | < | RealType dval; |
450 | > | RealType dval, x, y, z; |
451 | > | Vector3d dvec; |
452 | ||
453 | < | #line 306 "MDTreeParser.cpp" |
453 | > | #line 454 "MDTreeParser.cpp" |
454 | ||
455 | try { // for error handling | |
456 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 313 | Line 461 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
461 | { | |
462 | ival=intConst(_t); | |
463 | _t = _retTree; | |
464 | < | #line 53 "MDTreeParser.g" |
464 | > | #line 56 "MDTreeParser.g" |
465 | blockStack.top()->assign(id->getText(), ival); | |
466 | < | #line 319 "MDTreeParser.cpp" |
466 | > | #line 467 "MDTreeParser.cpp" |
467 | break; | |
468 | } | |
469 | case NUM_FLOAT: | |
# | Line 323 | Line 471 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
471 | { | |
472 | dval=floatConst(_t); | |
473 | _t = _retTree; | |
474 | < | #line 54 "MDTreeParser.g" |
474 | > | #line 57 "MDTreeParser.g" |
475 | blockStack.top()->assign(id->getText(), dval); | |
476 | < | #line 329 "MDTreeParser.cpp" |
476 | > | #line 477 "MDTreeParser.cpp" |
477 | > | break; |
478 | > | } |
479 | > | case LPAREN: |
480 | > | { |
481 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t; |
482 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t; |
483 | > | match(_t,LPAREN); |
484 | > | _t = _t->getFirstChild(); |
485 | > | x=doubleNumber(_t); |
486 | > | _t = _retTree; |
487 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t; |
488 | > | match(_t,COMMA); |
489 | > | _t = _t->getNextSibling(); |
490 | > | y=doubleNumber(_t); |
491 | > | _t = _retTree; |
492 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t; |
493 | > | match(_t,COMMA); |
494 | > | _t = _t->getNextSibling(); |
495 | > | z=doubleNumber(_t); |
496 | > | _t = _retTree; |
497 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t; |
498 | > | match(_t,RPAREN); |
499 | > | _t = _t->getNextSibling(); |
500 | > | _t = __t8; |
501 | > | _t = _t->getNextSibling(); |
502 | > | #line 59 "MDTreeParser.g" |
503 | > | dvec.x() = x; |
504 | > | dvec.y() = y; |
505 | > | dvec.z() = z; |
506 | > | blockStack.top()->assign(id->getText(), dvec); |
507 | > | |
508 | > | #line 509 "MDTreeParser.cpp" |
509 | break; | |
510 | } | |
511 | case ID: | |
# | Line 333 | Line 513 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
513 | str1 = _t; | |
514 | match(_t,ID); | |
515 | _t = _t->getNextSibling(); | |
516 | < | #line 55 "MDTreeParser.g" |
516 | > | #line 64 "MDTreeParser.g" |
517 | blockStack.top()->assign(id->getText(), str1->getText()); | |
518 | < | #line 339 "MDTreeParser.cpp" |
518 | > | #line 519 "MDTreeParser.cpp" |
519 | break; | |
520 | } | |
521 | case StringLiteral: | |
# | Line 343 | Line 523 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
523 | str2 = _t; | |
524 | match(_t,StringLiteral); | |
525 | _t = _t->getNextSibling(); | |
526 | < | #line 56 "MDTreeParser.g" |
526 | > | #line 65 "MDTreeParser.g" |
527 | std::string s = str2->getText(); | |
528 | s = s.substr(1, s.length()-2); | |
529 | blockStack.top()->assign(id->getText(),s); | |
530 | ||
531 | < | #line 352 "MDTreeParser.cpp" |
531 | > | #line 532 "MDTreeParser.cpp" |
532 | break; | |
533 | } | |
534 | default: | |
# | Line 366 | Line 546 | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr) | |
546 | } | |
547 | ||
548 | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
549 | < | #line 268 "MDTreeParser.g" |
549 | > | #line 314 "MDTreeParser.g" |
550 | int ival; | |
551 | < | #line 372 "MDTreeParser.cpp" |
551 | > | #line 552 "MDTreeParser.cpp" |
552 | ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
553 | ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
554 | ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
# | Line 382 | Line 562 | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr) | |
562 | i1 = _t; | |
563 | match(_t,NUM_INT); | |
564 | _t = _t->getNextSibling(); | |
565 | < | #line 269 "MDTreeParser.g" |
565 | > | #line 315 "MDTreeParser.g" |
566 | ival = lexi_cast<int>(i1->getText()); | |
567 | < | #line 388 "MDTreeParser.cpp" |
567 | > | #line 568 "MDTreeParser.cpp" |
568 | break; | |
569 | } | |
570 | case NUM_LONG: | |
# | Line 392 | Line 572 | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr) | |
572 | i2 = _t; | |
573 | match(_t,NUM_LONG); | |
574 | _t = _t->getNextSibling(); | |
575 | < | #line 270 "MDTreeParser.g" |
575 | > | #line 316 "MDTreeParser.g" |
576 | ival = lexi_cast<int>(i2->getText()); | |
577 | < | #line 398 "MDTreeParser.cpp" |
577 | > | #line 578 "MDTreeParser.cpp" |
578 | break; | |
579 | } | |
580 | default: | |
# | Line 413 | Line 593 | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE | |
593 | } | |
594 | ||
595 | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
596 | < | #line 282 "MDTreeParser.g" |
596 | > | #line 326 "MDTreeParser.g" |
597 | RealType dval; | |
598 | < | #line 419 "MDTreeParser.cpp" |
598 | > | #line 599 "MDTreeParser.cpp" |
599 | ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
600 | ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
601 | ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
# | Line 429 | Line 609 | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE | |
609 | d1 = _t; | |
610 | match(_t,NUM_FLOAT); | |
611 | _t = _t->getNextSibling(); | |
612 | < | #line 283 "MDTreeParser.g" |
612 | > | #line 327 "MDTreeParser.g" |
613 | dval = lexi_cast<RealType>(d1->getText()); | |
614 | < | #line 435 "MDTreeParser.cpp" |
614 | > | #line 615 "MDTreeParser.cpp" |
615 | break; | |
616 | } | |
617 | case NUM_DOUBLE: | |
# | Line 439 | Line 619 | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE | |
619 | d2 = _t; | |
620 | match(_t,NUM_DOUBLE); | |
621 | _t = _t->getNextSibling(); | |
622 | < | #line 284 "MDTreeParser.g" |
622 | > | #line 328 "MDTreeParser.g" |
623 | dval = lexi_cast<RealType>(d2->getText()); | |
624 | < | #line 445 "MDTreeParser.cpp" |
624 | > | #line 625 "MDTreeParser.cpp" |
625 | break; | |
626 | } | |
627 | default: | |
# | Line 459 | Line 639 | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE | |
639 | return dval; | |
640 | } | |
641 | ||
642 | + | RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
643 | + | #line 320 "MDTreeParser.g" |
644 | + | RealType dval; |
645 | + | #line 646 "MDTreeParser.cpp" |
646 | + | ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
647 | + | ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST; |
648 | + | ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST; |
649 | + | |
650 | + | try { // for error handling |
651 | + | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
652 | + | _t = ASTNULL; |
653 | + | switch ( _t->getType()) { |
654 | + | case NUM_INT: |
655 | + | case NUM_LONG: |
656 | + | { |
657 | + | ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
658 | + | intConst(_t); |
659 | + | _t = _retTree; |
660 | + | #line 321 "MDTreeParser.g" |
661 | + | dval = lexi_cast<RealType>(ic->getText()); |
662 | + | #line 663 "MDTreeParser.cpp" |
663 | + | break; |
664 | + | } |
665 | + | case NUM_FLOAT: |
666 | + | case NUM_DOUBLE: |
667 | + | { |
668 | + | fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
669 | + | floatConst(_t); |
670 | + | _t = _retTree; |
671 | + | #line 322 "MDTreeParser.g" |
672 | + | dval = lexi_cast<RealType>(fc->getText()); |
673 | + | #line 674 "MDTreeParser.cpp" |
674 | + | break; |
675 | + | } |
676 | + | default: |
677 | + | { |
678 | + | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); |
679 | + | } |
680 | + | } |
681 | + | } |
682 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
683 | + | reportError(ex); |
684 | + | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
685 | + | _t = _t->getNextSibling(); |
686 | + | } |
687 | + | _retTree = _t; |
688 | + | return dval; |
689 | + | } |
690 | + | |
691 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
692 | ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
693 | ||
# | Line 520 | Line 749 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA | |
749 | _t = _retTree; | |
750 | break; | |
751 | } | |
752 | + | case CONSTRAINT: |
753 | + | { |
754 | + | constraintblock(_t); |
755 | + | _t = _retTree; |
756 | + | break; |
757 | + | } |
758 | default: | |
759 | { | |
760 | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); | |
# | Line 536 | Line 771 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr | |
771 | ||
772 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
773 | ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
774 | < | #line 94 "MDTreeParser.g" |
774 | > | #line 120 "MDTreeParser.g" |
775 | ||
776 | int index; | |
777 | ||
778 | < | #line 544 "MDTreeParser.cpp" |
778 | > | #line 779 "MDTreeParser.cpp" |
779 | ||
780 | try { // for error handling | |
781 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t; |
782 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t; |
781 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t; |
782 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t; |
783 | match(_t,ATOM); | |
784 | _t = _t->getFirstChild(); | |
785 | index=intConst(_t); | |
786 | _t = _retTree; | |
787 | < | #line 98 "MDTreeParser.g" |
787 | > | #line 124 "MDTreeParser.g" |
788 | AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp); | |
789 | < | #line 555 "MDTreeParser.cpp" |
789 | > | #line 790 "MDTreeParser.cpp" |
790 | { // ( ... )* | |
791 | for (;;) { | |
792 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 561 | Line 796 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr | |
796 | _t = _retTree; | |
797 | } | |
798 | else { | |
799 | < | goto _loop28; |
799 | > | goto _loop41; |
800 | } | |
801 | ||
802 | } | |
803 | < | _loop28:; |
803 | > | _loop41:; |
804 | } // ( ... )* | |
805 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t; |
805 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t; |
806 | match(_t,ENDBLOCK); | |
807 | _t = _t->getNextSibling(); | |
808 | < | _t = __t26; |
808 | > | _t = __t39; |
809 | _t = _t->getNextSibling(); | |
810 | < | #line 100 "MDTreeParser.g" |
810 | > | #line 126 "MDTreeParser.g" |
811 | ||
812 | blockStack.top()->validate(); | |
813 | blockStack.pop(); | |
814 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
815 | currMoleculeStamp->addAtomStamp(currAtomStamp); | |
816 | ||
817 | < | #line 583 "MDTreeParser.cpp" |
817 | > | #line 818 "MDTreeParser.cpp" |
818 | } | |
819 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
820 | reportError(ex); | |
# | Line 593 | Line 828 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr | |
828 | ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
829 | ||
830 | try { // for error handling | |
831 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t; |
832 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t; |
831 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t; |
832 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t; |
833 | match(_t,BOND); | |
834 | _t = _t->getFirstChild(); | |
835 | < | #line 120 "MDTreeParser.g" |
835 | > | #line 146 "MDTreeParser.g" |
836 | BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp); | |
837 | < | #line 603 "MDTreeParser.cpp" |
837 | > | #line 838 "MDTreeParser.cpp" |
838 | { // ( ... )* | |
839 | for (;;) { | |
840 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 609 | Line 844 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr | |
844 | _t = _retTree; | |
845 | } | |
846 | else { | |
847 | < | goto _loop35; |
847 | > | goto _loop48; |
848 | } | |
849 | ||
850 | } | |
851 | < | _loop35:; |
851 | > | _loop48:; |
852 | } // ( ... )* | |
853 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t; |
853 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t; |
854 | match(_t,ENDBLOCK); | |
855 | _t = _t->getNextSibling(); | |
856 | < | _t = __t33; |
856 | > | _t = __t46; |
857 | _t = _t->getNextSibling(); | |
858 | < | #line 122 "MDTreeParser.g" |
858 | > | #line 148 "MDTreeParser.g" |
859 | ||
860 | blockStack.pop(); | |
861 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
862 | currMoleculeStamp->addBondStamp(currBondStamp); | |
863 | ||
864 | < | #line 630 "MDTreeParser.cpp" |
864 | > | #line 865 "MDTreeParser.cpp" |
865 | } | |
866 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
867 | reportError(ex); | |
# | Line 640 | Line 875 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr | |
875 | ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
876 | ||
877 | try { // for error handling | |
878 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t; |
879 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t; |
878 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t; |
879 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t; |
880 | match(_t,BEND); | |
881 | _t = _t->getFirstChild(); | |
882 | < | #line 138 "MDTreeParser.g" |
882 | > | #line 164 "MDTreeParser.g" |
883 | BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp); | |
884 | < | #line 650 "MDTreeParser.cpp" |
884 | > | #line 885 "MDTreeParser.cpp" |
885 | { // ( ... )* | |
886 | for (;;) { | |
887 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 656 | Line 891 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr | |
891 | _t = _retTree; | |
892 | } | |
893 | else { | |
894 | < | goto _loop41; |
894 | > | goto _loop54; |
895 | } | |
896 | ||
897 | } | |
898 | < | _loop41:; |
898 | > | _loop54:; |
899 | } // ( ... )* | |
900 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t; |
900 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t; |
901 | match(_t,ENDBLOCK); | |
902 | _t = _t->getNextSibling(); | |
903 | < | _t = __t39; |
903 | > | _t = __t52; |
904 | _t = _t->getNextSibling(); | |
905 | < | #line 140 "MDTreeParser.g" |
905 | > | #line 166 "MDTreeParser.g" |
906 | ||
907 | blockStack.top()->validate(); | |
908 | blockStack.pop(); | |
909 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
910 | currMoleculeStamp->addBendStamp(currBendStamp); | |
911 | ||
912 | < | #line 678 "MDTreeParser.cpp" |
912 | > | #line 913 "MDTreeParser.cpp" |
913 | } | |
914 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
915 | reportError(ex); | |
# | Line 688 | Line 923 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
923 | ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
924 | ||
925 | try { // for error handling | |
926 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t; |
927 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t; |
926 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t; |
927 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t; |
928 | match(_t,TORSION); | |
929 | _t = _t->getFirstChild(); | |
930 | < | #line 157 "MDTreeParser.g" |
930 | > | #line 183 "MDTreeParser.g" |
931 | TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp); | |
932 | < | #line 698 "MDTreeParser.cpp" |
932 | > | #line 933 "MDTreeParser.cpp" |
933 | { // ( ... )* | |
934 | for (;;) { | |
935 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 704 | Line 939 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
939 | _t = _retTree; | |
940 | } | |
941 | else { | |
942 | < | goto _loop47; |
942 | > | goto _loop60; |
943 | } | |
944 | ||
945 | } | |
946 | < | _loop47:; |
946 | > | _loop60:; |
947 | } // ( ... )* | |
948 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t; |
948 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t; |
949 | match(_t,ENDBLOCK); | |
950 | _t = _t->getNextSibling(); | |
951 | < | _t = __t45; |
951 | > | _t = __t58; |
952 | _t = _t->getNextSibling(); | |
953 | < | #line 159 "MDTreeParser.g" |
953 | > | #line 185 "MDTreeParser.g" |
954 | ||
955 | blockStack.top()->validate(); | |
956 | blockStack.pop(); | |
957 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
958 | currMoleculeStamp->addTorsionStamp(currTorsionStamp); | |
959 | ||
960 | < | #line 726 "MDTreeParser.cpp" |
960 | > | #line 961 "MDTreeParser.cpp" |
961 | } | |
962 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
963 | reportError(ex); | |
# | Line 736 | Line 971 | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE( | |
971 | ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
972 | ||
973 | try { // for error handling | |
974 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t; |
975 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t; |
974 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t; |
975 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t; |
976 | match(_t,INVERSION); | |
977 | _t = _t->getFirstChild(); | |
978 | < | #line 176 "MDTreeParser.g" |
978 | > | #line 202 "MDTreeParser.g" |
979 | InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp); | |
980 | < | #line 746 "MDTreeParser.cpp" |
980 | > | #line 981 "MDTreeParser.cpp" |
981 | { // ( ... )* | |
982 | for (;;) { | |
983 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
984 | _t = ASTNULL; | |
985 | < | if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) { |
985 | > | if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) { |
986 | inversionstatement(_t); | |
987 | _t = _retTree; | |
988 | } | |
989 | else { | |
990 | < | goto _loop53; |
990 | > | goto _loop66; |
991 | } | |
992 | ||
993 | } | |
994 | < | _loop53:; |
994 | > | _loop66:; |
995 | } // ( ... )* | |
996 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t; |
996 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t; |
997 | match(_t,ENDBLOCK); | |
998 | _t = _t->getNextSibling(); | |
999 | < | _t = __t51; |
999 | > | _t = __t64; |
1000 | _t = _t->getNextSibling(); | |
1001 | < | #line 178 "MDTreeParser.g" |
1001 | > | #line 204 "MDTreeParser.g" |
1002 | ||
1003 | blockStack.top()->validate(); | |
1004 | blockStack.pop(); | |
1005 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
1006 | currMoleculeStamp->addInversionStamp(currInversionStamp); | |
1007 | ||
1008 | < | #line 774 "MDTreeParser.cpp" |
1008 | > | #line 1009 "MDTreeParser.cpp" |
1009 | } | |
1010 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1011 | reportError(ex); | |
# | Line 782 | Line 1017 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE( | |
1017 | ||
1018 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1019 | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1020 | < | #line 195 "MDTreeParser.g" |
1020 | > | #line 223 "MDTreeParser.g" |
1021 | ||
1022 | int index; | |
1023 | ||
1024 | < | #line 790 "MDTreeParser.cpp" |
1024 | > | #line 1025 "MDTreeParser.cpp" |
1025 | ||
1026 | try { // for error handling | |
1027 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t; |
1028 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t; |
1027 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t; |
1028 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t; |
1029 | match(_t,RIGIDBODY); | |
1030 | _t = _t->getFirstChild(); | |
1031 | index=intConst(_t); | |
1032 | _t = _retTree; | |
1033 | < | #line 199 "MDTreeParser.g" |
1033 | > | #line 227 "MDTreeParser.g" |
1034 | RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp); | |
1035 | < | #line 801 "MDTreeParser.cpp" |
1035 | > | #line 1036 "MDTreeParser.cpp" |
1036 | { // ( ... )* | |
1037 | for (;;) { | |
1038 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 807 | Line 1042 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE( | |
1042 | _t = _retTree; | |
1043 | } | |
1044 | else { | |
1045 | < | goto _loop59; |
1045 | > | goto _loop73; |
1046 | } | |
1047 | ||
1048 | } | |
1049 | < | _loop59:; |
1049 | > | _loop73:; |
1050 | } // ( ... )* | |
1051 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t; |
1051 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t; |
1052 | match(_t,ENDBLOCK); | |
1053 | _t = _t->getNextSibling(); | |
1054 | < | _t = __t57; |
1054 | > | _t = __t71; |
1055 | _t = _t->getNextSibling(); | |
1056 | < | #line 201 "MDTreeParser.g" |
1056 | > | #line 229 "MDTreeParser.g" |
1057 | ||
1058 | blockStack.top()->validate(); | |
1059 | blockStack.pop(); | |
1060 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
1061 | currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); | |
1062 | ||
1063 | < | #line 829 "MDTreeParser.cpp" |
1063 | > | #line 1064 "MDTreeParser.cpp" |
1064 | } | |
1065 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1066 | reportError(ex); | |
# | Line 839 | Line 1074 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC | |
1074 | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1075 | ||
1076 | try { // for error handling | |
1077 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t; |
1078 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t; |
1077 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t; |
1078 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t; |
1079 | match(_t,CUTOFFGROUP); | |
1080 | _t = _t->getFirstChild(); | |
1081 | < | #line 218 "MDTreeParser.g" |
1081 | > | #line 246 "MDTreeParser.g" |
1082 | CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp); | |
1083 | < | #line 849 "MDTreeParser.cpp" |
1083 | > | #line 1084 "MDTreeParser.cpp" |
1084 | { // ( ... )* | |
1085 | for (;;) { | |
1086 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 855 | Line 1090 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC | |
1090 | _t = _retTree; | |
1091 | } | |
1092 | else { | |
1093 | < | goto _loop65; |
1093 | > | goto _loop79; |
1094 | } | |
1095 | ||
1096 | } | |
1097 | < | _loop65:; |
1097 | > | _loop79:; |
1098 | } // ( ... )* | |
1099 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t; |
1099 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t; |
1100 | match(_t,ENDBLOCK); | |
1101 | _t = _t->getNextSibling(); | |
1102 | < | _t = __t63; |
1102 | > | _t = __t77; |
1103 | _t = _t->getNextSibling(); | |
1104 | < | #line 220 "MDTreeParser.g" |
1104 | > | #line 248 "MDTreeParser.g" |
1105 | ||
1106 | blockStack.top()->validate(); | |
1107 | blockStack.pop(); | |
1108 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
1109 | currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); | |
1110 | ||
1111 | < | #line 877 "MDTreeParser.cpp" |
1111 | > | #line 1112 "MDTreeParser.cpp" |
1112 | } | |
1113 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1114 | reportError(ex); | |
# | Line 885 | Line 1120 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a | |
1120 | ||
1121 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1122 | ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1123 | < | #line 237 "MDTreeParser.g" |
1123 | > | #line 265 "MDTreeParser.g" |
1124 | int ival; | |
1125 | < | #line 891 "MDTreeParser.cpp" |
1125 | > | #line 1126 "MDTreeParser.cpp" |
1126 | ||
1127 | try { // for error handling | |
1128 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t; |
1129 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t; |
1128 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t; |
1129 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t; |
1130 | match(_t,FRAGMENT); | |
1131 | _t = _t->getFirstChild(); | |
1132 | ival=intConst(_t); | |
1133 | _t = _retTree; | |
1134 | < | #line 238 "MDTreeParser.g" |
1134 | > | #line 266 "MDTreeParser.g" |
1135 | FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp); | |
1136 | < | #line 902 "MDTreeParser.cpp" |
1136 | > | #line 1137 "MDTreeParser.cpp" |
1137 | { // ( ... )* | |
1138 | for (;;) { | |
1139 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 908 | Line 1143 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a | |
1143 | _t = _retTree; | |
1144 | } | |
1145 | else { | |
1146 | < | goto _loop71; |
1146 | > | goto _loop85; |
1147 | } | |
1148 | ||
1149 | } | |
1150 | < | _loop71:; |
1150 | > | _loop85:; |
1151 | } // ( ... )* | |
1152 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t; |
1152 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t; |
1153 | match(_t,ENDBLOCK); | |
1154 | _t = _t->getNextSibling(); | |
1155 | < | _t = __t69; |
1155 | > | _t = __t83; |
1156 | _t = _t->getNextSibling(); | |
1157 | < | #line 240 "MDTreeParser.g" |
1157 | > | #line 268 "MDTreeParser.g" |
1158 | ||
1159 | blockStack.top()->validate(); | |
1160 | blockStack.pop(); | |
1161 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
1162 | currMoleculeStamp->addFragmentStamp(currFragmentStamp); | |
1163 | ||
1164 | < | #line 930 "MDTreeParser.cpp" |
1164 | > | #line 1165 "MDTreeParser.cpp" |
1165 | } | |
1166 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
1167 | reportError(ex); | |
# | Line 936 | Line 1171 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a | |
1171 | _retTree = _t; | |
1172 | } | |
1173 | ||
1174 | + | void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1175 | + | ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1176 | + | |
1177 | + | try { // for error handling |
1178 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t; |
1179 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t; |
1180 | + | match(_t,CONSTRAINT); |
1181 | + | _t = _t->getFirstChild(); |
1182 | + | #line 279 "MDTreeParser.g" |
1183 | + | ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp); |
1184 | + | #line 1185 "MDTreeParser.cpp" |
1185 | + | { // ( ... )* |
1186 | + | for (;;) { |
1187 | + | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
1188 | + | _t = ASTNULL; |
1189 | + | if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) { |
1190 | + | constraintstatement(_t); |
1191 | + | _t = _retTree; |
1192 | + | } |
1193 | + | else { |
1194 | + | goto _loop90; |
1195 | + | } |
1196 | + | |
1197 | + | } |
1198 | + | _loop90:; |
1199 | + | } // ( ... )* |
1200 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t; |
1201 | + | match(_t,ENDBLOCK); |
1202 | + | _t = _t->getNextSibling(); |
1203 | + | _t = __t88; |
1204 | + | _t = _t->getNextSibling(); |
1205 | + | #line 281 "MDTreeParser.g" |
1206 | + | |
1207 | + | blockStack.pop(); |
1208 | + | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); |
1209 | + | currMoleculeStamp->addConstraintStamp(currConstraintStamp); |
1210 | + | |
1211 | + | #line 1212 "MDTreeParser.cpp" |
1212 | + | } |
1213 | + | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1214 | + | reportError(ex); |
1215 | + | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
1216 | + | _t = _t->getNextSibling(); |
1217 | + | } |
1218 | + | _retTree = _t; |
1219 | + | } |
1220 | + | |
1221 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1222 | ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1223 | < | #line 108 "MDTreeParser.g" |
1223 | > | #line 134 "MDTreeParser.g" |
1224 | ||
1225 | vector<RealType> dvec; | |
1226 | AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top()); | |
1227 | ||
1228 | ||
1229 | < | #line 948 "MDTreeParser.cpp" |
1229 | > | #line 1230 "MDTreeParser.cpp" |
1230 | ||
1231 | try { // for error handling | |
1232 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 958 | Line 1240 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a | |
1240 | } | |
1241 | case POSITION: | |
1242 | { | |
1243 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t; |
1244 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t; |
1243 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t; |
1244 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t; |
1245 | match(_t,POSITION); | |
1246 | _t = _t->getFirstChild(); | |
1247 | dvec=doubleNumberTuple(_t); | |
1248 | _t = _retTree; | |
1249 | < | _t = __t30; |
1249 | > | _t = __t43; |
1250 | _t = _t->getNextSibling(); | |
1251 | < | #line 115 "MDTreeParser.g" |
1251 | > | #line 141 "MDTreeParser.g" |
1252 | currAtomStamp->setPosition(dvec); | |
1253 | < | #line 972 "MDTreeParser.cpp" |
1253 | > | #line 1254 "MDTreeParser.cpp" |
1254 | break; | |
1255 | } | |
1256 | case ORIENTATION: | |
1257 | { | |
1258 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t; |
1259 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t; |
1258 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t; |
1259 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t; |
1260 | match(_t,ORIENTATION); | |
1261 | _t = _t->getFirstChild(); | |
1262 | dvec=doubleNumberTuple(_t); | |
1263 | _t = _retTree; | |
1264 | < | _t = __t31; |
1264 | > | _t = __t44; |
1265 | _t = _t->getNextSibling(); | |
1266 | < | #line 116 "MDTreeParser.g" |
1266 | > | #line 142 "MDTreeParser.g" |
1267 | currAtomStamp->setOrientation(dvec); | |
1268 | < | #line 987 "MDTreeParser.cpp" |
1268 | > | #line 1269 "MDTreeParser.cpp" |
1269 | break; | |
1270 | } | |
1271 | default: | |
# | Line 1001 | Line 1283 | vector<RealType> MDTreeParser::doubleNumberTuple(ANTL | |
1283 | } | |
1284 | ||
1285 | vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1286 | < | #line 253 "MDTreeParser.g" |
1286 | > | #line 298 "MDTreeParser.g" |
1287 | vector<RealType> dvec; | |
1288 | < | #line 1007 "MDTreeParser.cpp" |
1288 | > | #line 1289 "MDTreeParser.cpp" |
1289 | ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1290 | < | #line 253 "MDTreeParser.g" |
1290 | > | #line 298 "MDTreeParser.g" |
1291 | ||
1292 | RealType dval; | |
1293 | ||
1294 | < | #line 1013 "MDTreeParser.cpp" |
1294 | > | #line 1295 "MDTreeParser.cpp" |
1295 | ||
1296 | try { // for error handling | |
1297 | { // ( ... )+ | |
1298 | < | int _cnt75=0; |
1298 | > | int _cnt95=0; |
1299 | for (;;) { | |
1300 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1301 | _t = ASTNULL; | |
1302 | if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) { | |
1303 | dval=doubleNumber(_t); | |
1304 | _t = _retTree; | |
1305 | < | #line 257 "MDTreeParser.g" |
1305 | > | #line 302 "MDTreeParser.g" |
1306 | dvec.push_back(dval); | |
1307 | < | #line 1026 "MDTreeParser.cpp" |
1307 | > | #line 1308 "MDTreeParser.cpp" |
1308 | } | |
1309 | else { | |
1310 | < | if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1310 | > | if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1311 | } | |
1312 | ||
1313 | < | _cnt75++; |
1313 | > | _cnt95++; |
1314 | } | |
1315 | < | _loop75:; |
1315 | > | _loop95:; |
1316 | } // ( ... )+ | |
1317 | } | |
1318 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
# | Line 1044 | Line 1326 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a | |
1326 | ||
1327 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1328 | ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1329 | < | #line 129 "MDTreeParser.g" |
1329 | > | #line 155 "MDTreeParser.g" |
1330 | ||
1331 | vector<int> ivec; | |
1332 | BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top()); | |
1333 | ||
1334 | < | #line 1053 "MDTreeParser.cpp" |
1334 | > | #line 1335 "MDTreeParser.cpp" |
1335 | ||
1336 | try { // for error handling | |
1337 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1063 | Line 1345 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a | |
1345 | } | |
1346 | case MEMBERS: | |
1347 | { | |
1348 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t; |
1349 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t; |
1348 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t; |
1349 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t; |
1350 | match(_t,MEMBERS); | |
1351 | _t = _t->getFirstChild(); | |
1352 | ivec=inttuple(_t); | |
1353 | _t = _retTree; | |
1354 | < | _t = __t37; |
1354 | > | _t = __t50; |
1355 | _t = _t->getNextSibling(); | |
1356 | < | #line 135 "MDTreeParser.g" |
1356 | > | #line 161 "MDTreeParser.g" |
1357 | currBondStamp->setMembers(ivec); | |
1358 | < | #line 1077 "MDTreeParser.cpp" |
1358 | > | #line 1359 "MDTreeParser.cpp" |
1359 | break; | |
1360 | } | |
1361 | default: | |
# | Line 1091 | Line 1373 | vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPAC | |
1373 | } | |
1374 | ||
1375 | vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1376 | < | #line 260 "MDTreeParser.g" |
1376 | > | #line 306 "MDTreeParser.g" |
1377 | vector<int> ivec; | |
1378 | < | #line 1097 "MDTreeParser.cpp" |
1378 | > | #line 1379 "MDTreeParser.cpp" |
1379 | ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1380 | < | #line 260 "MDTreeParser.g" |
1380 | > | #line 306 "MDTreeParser.g" |
1381 | ||
1382 | int ival; | |
1383 | ||
1384 | < | #line 1103 "MDTreeParser.cpp" |
1384 | > | #line 1385 "MDTreeParser.cpp" |
1385 | ||
1386 | try { // for error handling | |
1387 | { // ( ... )+ | |
1388 | < | int _cnt78=0; |
1388 | > | int _cnt98=0; |
1389 | for (;;) { | |
1390 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1391 | _t = ASTNULL; | |
1392 | if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) { | |
1393 | ival=intConst(_t); | |
1394 | _t = _retTree; | |
1395 | < | #line 264 "MDTreeParser.g" |
1395 | > | #line 310 "MDTreeParser.g" |
1396 | ivec.push_back(ival); | |
1397 | < | #line 1116 "MDTreeParser.cpp" |
1397 | > | #line 1398 "MDTreeParser.cpp" |
1398 | } | |
1399 | else { | |
1400 | < | if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1400 | > | if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1401 | } | |
1402 | ||
1403 | < | _cnt78++; |
1403 | > | _cnt98++; |
1404 | } | |
1405 | < | _loop78:; |
1405 | > | _loop98:; |
1406 | } // ( ... )+ | |
1407 | } | |
1408 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
# | Line 1134 | Line 1416 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a | |
1416 | ||
1417 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1418 | ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1419 | < | #line 148 "MDTreeParser.g" |
1419 | > | #line 174 "MDTreeParser.g" |
1420 | ||
1421 | vector<int> ivec; | |
1422 | BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top()); | |
1423 | ||
1424 | < | #line 1143 "MDTreeParser.cpp" |
1424 | > | #line 1425 "MDTreeParser.cpp" |
1425 | ||
1426 | try { // for error handling | |
1427 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1153 | Line 1435 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a | |
1435 | } | |
1436 | case MEMBERS: | |
1437 | { | |
1438 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t; |
1439 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t; |
1438 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t; |
1439 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t; |
1440 | match(_t,MEMBERS); | |
1441 | _t = _t->getFirstChild(); | |
1442 | ivec=inttuple(_t); | |
1443 | _t = _retTree; | |
1444 | < | _t = __t43; |
1444 | > | _t = __t56; |
1445 | _t = _t->getNextSibling(); | |
1446 | < | #line 154 "MDTreeParser.g" |
1446 | > | #line 180 "MDTreeParser.g" |
1447 | currBendStamp->setMembers(ivec); | |
1448 | < | #line 1167 "MDTreeParser.cpp" |
1448 | > | #line 1449 "MDTreeParser.cpp" |
1449 | break; | |
1450 | } | |
1451 | default: | |
# | Line 1182 | Line 1464 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1464 | ||
1465 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1466 | ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1467 | < | #line 167 "MDTreeParser.g" |
1467 | > | #line 193 "MDTreeParser.g" |
1468 | ||
1469 | vector<int> ivec; | |
1470 | TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top()); | |
1471 | ||
1472 | < | #line 1191 "MDTreeParser.cpp" |
1472 | > | #line 1473 "MDTreeParser.cpp" |
1473 | ||
1474 | try { // for error handling | |
1475 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1201 | Line 1483 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1483 | } | |
1484 | case MEMBERS: | |
1485 | { | |
1486 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t; |
1487 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t; |
1486 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t; |
1487 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t; |
1488 | match(_t,MEMBERS); | |
1489 | _t = _t->getFirstChild(); | |
1490 | ivec=inttuple(_t); | |
1491 | _t = _retTree; | |
1492 | < | _t = __t49; |
1492 | > | _t = __t62; |
1493 | _t = _t->getNextSibling(); | |
1494 | < | #line 173 "MDTreeParser.g" |
1494 | > | #line 199 "MDTreeParser.g" |
1495 | currTorsionStamp->setMembers(ivec); | |
1496 | < | #line 1215 "MDTreeParser.cpp" |
1496 | > | #line 1497 "MDTreeParser.cpp" |
1497 | break; | |
1498 | } | |
1499 | default: | |
# | Line 1230 | Line 1512 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP | |
1512 | ||
1513 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1514 | ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1515 | < | #line 186 "MDTreeParser.g" |
1515 | > | #line 212 "MDTreeParser.g" |
1516 | ||
1517 | int icent; | |
1518 | + | vector<int> ivec; |
1519 | InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top()); | |
1520 | ||
1521 | < | #line 1239 "MDTreeParser.cpp" |
1521 | > | #line 1522 "MDTreeParser.cpp" |
1522 | ||
1523 | try { // for error handling | |
1524 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1249 | Line 1532 | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESP | |
1532 | } | |
1533 | case CENTER: | |
1534 | { | |
1535 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t; |
1536 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t; |
1535 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t; |
1536 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t; |
1537 | match(_t,CENTER); | |
1538 | _t = _t->getFirstChild(); | |
1539 | icent=intConst(_t); | |
1540 | _t = _retTree; | |
1541 | < | _t = __t55; |
1541 | > | _t = __t68; |
1542 | _t = _t->getNextSibling(); | |
1543 | < | #line 192 "MDTreeParser.g" |
1543 | > | #line 219 "MDTreeParser.g" |
1544 | currInversionStamp->setCenter(icent); | |
1545 | < | #line 1263 "MDTreeParser.cpp" |
1545 | > | #line 1546 "MDTreeParser.cpp" |
1546 | break; | |
1547 | } | |
1548 | + | case SATELLITES: |
1549 | + | { |
1550 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t; |
1551 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t; |
1552 | + | match(_t,SATELLITES); |
1553 | + | _t = _t->getFirstChild(); |
1554 | + | ivec=inttuple(_t); |
1555 | + | _t = _retTree; |
1556 | + | _t = __t69; |
1557 | + | _t = _t->getNextSibling(); |
1558 | + | #line 220 "MDTreeParser.g" |
1559 | + | currInversionStamp->setSatellites(ivec); |
1560 | + | #line 1561 "MDTreeParser.cpp" |
1561 | + | break; |
1562 | + | } |
1563 | default: | |
1564 | { | |
1565 | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); | |
# | Line 1278 | Line 1576 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP | |
1576 | ||
1577 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1578 | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1579 | < | #line 209 "MDTreeParser.g" |
1579 | > | #line 237 "MDTreeParser.g" |
1580 | ||
1581 | vector<int> ivec; | |
1582 | RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top()); | |
1583 | ||
1584 | < | #line 1287 "MDTreeParser.cpp" |
1584 | > | #line 1585 "MDTreeParser.cpp" |
1585 | ||
1586 | try { // for error handling | |
1587 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1297 | Line 1595 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP | |
1595 | } | |
1596 | case MEMBERS: | |
1597 | { | |
1598 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t; |
1599 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t; |
1598 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t; |
1599 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t; |
1600 | match(_t,MEMBERS); | |
1601 | _t = _t->getFirstChild(); | |
1602 | ivec=inttuple(_t); | |
1603 | _t = _retTree; | |
1604 | < | _t = __t61; |
1604 | > | _t = __t75; |
1605 | _t = _t->getNextSibling(); | |
1606 | < | #line 215 "MDTreeParser.g" |
1606 | > | #line 243 "MDTreeParser.g" |
1607 | currRigidBodyStamp->setMembers(ivec); | |
1608 | < | #line 1311 "MDTreeParser.cpp" |
1608 | > | #line 1609 "MDTreeParser.cpp" |
1609 | break; | |
1610 | } | |
1611 | default: | |
# | Line 1326 | Line 1624 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME | |
1624 | ||
1625 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1626 | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1627 | < | #line 228 "MDTreeParser.g" |
1627 | > | #line 256 "MDTreeParser.g" |
1628 | ||
1629 | vector<int> ivec; | |
1630 | CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top()); | |
1631 | ||
1632 | < | #line 1335 "MDTreeParser.cpp" |
1632 | > | #line 1633 "MDTreeParser.cpp" |
1633 | ||
1634 | try { // for error handling | |
1635 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1345 | Line 1643 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME | |
1643 | } | |
1644 | case MEMBERS: | |
1645 | { | |
1646 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t; |
1647 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t; |
1646 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t; |
1647 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t; |
1648 | match(_t,MEMBERS); | |
1649 | _t = _t->getFirstChild(); | |
1650 | ivec=inttuple(_t); | |
1651 | _t = _retTree; | |
1652 | < | _t = __t67; |
1652 | > | _t = __t81; |
1653 | _t = _t->getNextSibling(); | |
1654 | < | #line 234 "MDTreeParser.g" |
1654 | > | #line 262 "MDTreeParser.g" |
1655 | currCutoffGroupStamp->setMembers(ivec); | |
1656 | < | #line 1359 "MDTreeParser.cpp" |
1656 | > | #line 1657 "MDTreeParser.cpp" |
1657 | break; | |
1658 | } | |
1659 | default: | |
# | Line 1387 | Line 1685 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA | |
1685 | _retTree = _t; | |
1686 | } | |
1687 | ||
1688 | < | RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1689 | < | #line 274 "MDTreeParser.g" |
1690 | < | 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; |
1688 | > | void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1689 | > | ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1690 | > | #line 288 "MDTreeParser.g" |
1691 | ||
1692 | + | vector<int> ivec; |
1693 | + | ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top()); |
1694 | + | |
1695 | + | #line 1696 "MDTreeParser.cpp" |
1696 | + | |
1697 | try { // for error handling | |
1698 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1699 | _t = ASTNULL; | |
1700 | switch ( _t->getType()) { | |
1701 | < | case NUM_INT: |
1403 | < | case NUM_LONG: |
1701 | > | case ASSIGNEQUAL: |
1702 | { | |
1703 | < | ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1406 | < | intConst(_t); |
1703 | > | assignment(_t); |
1704 | _t = _retTree; | |
1408 | – | #line 276 "MDTreeParser.g" |
1409 | – | dval = lexi_cast<RealType>(ic->getText()); |
1410 | – | #line 1411 "MDTreeParser.cpp" |
1705 | break; | |
1706 | } | |
1707 | < | case NUM_FLOAT: |
1414 | < | case NUM_DOUBLE: |
1707 | > | case MEMBERS: |
1708 | { | |
1709 | < | fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1710 | < | floatConst(_t); |
1709 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t; |
1710 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t; |
1711 | > | match(_t,MEMBERS); |
1712 | > | _t = _t->getFirstChild(); |
1713 | > | ivec=inttuple(_t); |
1714 | _t = _retTree; | |
1715 | < | #line 277 "MDTreeParser.g" |
1716 | < | dval = lexi_cast<RealType>(fc->getText()); |
1717 | < | #line 1422 "MDTreeParser.cpp" |
1715 | > | _t = __t92; |
1716 | > | _t = _t->getNextSibling(); |
1717 | > | #line 294 "MDTreeParser.g" |
1718 | > | currConstraintStamp->setMembers(ivec); |
1719 | > | #line 1720 "MDTreeParser.cpp" |
1720 | break; | |
1721 | } | |
1722 | default: | |
# | Line 1433 | Line 1731 | RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPA | |
1731 | _t = _t->getNextSibling(); | |
1732 | } | |
1733 | _retTree = _t; | |
1436 | – | return dval; |
1734 | } | |
1735 | ||
1736 | void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& ) | |
# | Line 1455 | Line 1752 | const char* MDTreeParser::tokenNames[] = { | |
1752 | "\"inversion\"", | |
1753 | "\"rigidBody\"", | |
1754 | "\"cutoffGroup\"", | |
1755 | + | "\"constraint\"", |
1756 | + | "\"distance\"", |
1757 | "\"fragment\"", | |
1758 | "\"members\"", | |
1759 | "\"center\"", | |
1760 | + | "\"satellites\"", |
1761 | "\"position\"", | |
1762 | "\"orientation\"", | |
1763 | + | "\"flucQ\"", |
1764 | + | "\"RNEMD\"", |
1765 | + | "\"minimizer\"", |
1766 | "ENDBLOCK", | |
1767 | "ID", | |
1768 | "ASSIGNEQUAL", | |
# | Line 1497 | Line 1800 | const char* MDTreeParser::tokenNames[] = { | |
1800 | 0 | |
1801 | }; | |
1802 | ||
1803 | < | const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL }; |
1804 | < | // "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL |
1803 | > | const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL }; |
1804 | > | // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer" |
1805 | > | // ASSIGNEQUAL |
1806 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4); | |
1807 | < | const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL }; |
1807 | > | const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL }; |
1808 | // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup" | |
1809 | < | // "fragment" ASSIGNEQUAL |
1809 | > | // "constraint" "fragment" ASSIGNEQUAL |
1810 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4); | |
1811 | ||
1812 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |