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