ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDTreeParser.cpp
Revision: 1776
Committed: Thu Aug 9 15:52:59 2012 UTC (12 years, 8 months ago) by gezelter
File size: 44908 byte(s)
Log Message: 
Fixes to mdParser to handle vector assignments, fixes for VelocityVerletIntegrator deleting rnemd_ when it doesn't exist yet.

File Contents

# Content
1 /* $ANTLR 2.7.7 (20120725): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2 #include "MDTreeParser.hpp"
3 #include <antlr/Token.hpp>
4 #include <antlr/AST.hpp>
5 #include <antlr/NoViableAltException.hpp>
6 #include <antlr/MismatchedTokenException.hpp>
7 #include <antlr/SemanticException.hpp>
8 #include <antlr/BitSet.hpp>
9 #line 1 "MDTreeParser.g"
10 #line 11 "MDTreeParser.cpp"
11 MDTreeParser::MDTreeParser()
12 : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
13 }
14
15 void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _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 { // ( ... )*
20 for (;;) {
21 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
22 _t = ASTNULL;
23 if ((_tokenSet_0.member(_t->getType()))) {
24 statement(_t);
25 _t = _retTree;
26 }
27 else {
28 goto _loop3;
29 }
30
31 }
32 _loop3:;
33 } // ( ... )*
34 #line 34 "MDTreeParser.g"
35 blockStack.top()->validate(); blockStack.pop();
36 #line 37 "MDTreeParser.cpp"
37 }
38 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
39 reportError(ex);
40 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
41 _t = _t->getNextSibling();
42 }
43 _retTree = _t;
44 }
45
46 void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _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 )
51 _t = ASTNULL;
52 switch ( _t->getType()) {
53 case ASSIGNEQUAL:
54 {
55 assignment(_t);
56 _t = _retTree;
57 break;
58 }
59 case COMPONENT:
60 {
61 componentblock(_t);
62 _t = _retTree;
63 break;
64 }
65 case MOLECULE:
66 {
67 moleculeblock(_t);
68 _t = _retTree;
69 break;
70 }
71 case ZCONSTRAINT:
72 {
73 zconstraintblock(_t);
74 _t = _retTree;
75 break;
76 }
77 case RESTRAINT:
78 {
79 restraintblock(_t);
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);
104 }
105 }
106 }
107 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
108 reportError(ex);
109 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
110 _t = _t->getNextSibling();
111 }
112 _retTree = _t;
113 }
114
115 void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
116 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
117 ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
118
119 try { // for error handling
120 ANTLR_USE_NAMESPACE(antlr)RefAST __t6 = _t;
121 ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = _t;
122 match(_t,ASSIGNEQUAL);
123 _t = _t->getFirstChild();
124 id = _t;
125 match(_t,ID);
126 _t = _t->getNextSibling();
127 constant(_t,id);
128 _t = _retTree;
129 _t = __t6;
130 _t = _t->getNextSibling();
131 }
132 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
133 reportError(ex);
134 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
135 _t = _t->getNextSibling();
136 }
137 _retTree = _t;
138 }
139
140 void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t10 = _t;
145 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
146 match(_t,COMPONENT);
147 _t = _t->getFirstChild();
148 #line 72 "MDTreeParser.g"
149 Component* currComponet = new Component(); blockStack.push(currComponet);
150 #line 151 "MDTreeParser.cpp"
151 { // ( ... )*
152 for (;;) {
153 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
154 _t = ASTNULL;
155 if ((_t->getType() == ASSIGNEQUAL)) {
156 assignment(_t);
157 _t = _retTree;
158 }
159 else {
160 goto _loop12;
161 }
162
163 }
164 _loop12:;
165 } // ( ... )*
166 ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
167 match(_t,ENDBLOCK);
168 _t = _t->getNextSibling();
169 _t = __t10;
170 _t = _t->getNextSibling();
171 #line 74 "MDTreeParser.g"
172 blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
173 #line 174 "MDTreeParser.cpp"
174 }
175 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
176 reportError(ex);
177 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
178 _t = _t->getNextSibling();
179 }
180 _retTree = _t;
181 }
182
183 void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t34 = _t;
188 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
189 match(_t,MOLECULE);
190 _t = _t->getFirstChild();
191 #line 103 "MDTreeParser.g"
192 MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
193 #line 194 "MDTreeParser.cpp"
194 { // ( ... )*
195 for (;;) {
196 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
197 _t = ASTNULL;
198 if ((_tokenSet_1.member(_t->getType()))) {
199 moleculestatement(_t);
200 _t = _retTree;
201 }
202 else {
203 goto _loop36;
204 }
205
206 }
207 _loop36:;
208 } // ( ... )*
209 ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
210 match(_t,ENDBLOCK);
211 _t = _t->getNextSibling();
212 _t = __t34;
213 _t = _t->getNextSibling();
214 #line 105 "MDTreeParser.g"
215 blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
216 #line 217 "MDTreeParser.cpp"
217 }
218 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
219 reportError(ex);
220 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
221 _t = _t->getNextSibling();
222 }
223 _retTree = _t;
224 }
225
226 void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t14 = _t;
231 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
232 match(_t,ZCONSTRAINT);
233 _t = _t->getFirstChild();
234 #line 77 "MDTreeParser.g"
235 ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
236 #line 237 "MDTreeParser.cpp"
237 { // ( ... )*
238 for (;;) {
239 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
240 _t = ASTNULL;
241 if ((_t->getType() == ASSIGNEQUAL)) {
242 assignment(_t);
243 _t = _retTree;
244 }
245 else {
246 goto _loop16;
247 }
248
249 }
250 _loop16:;
251 } // ( ... )*
252 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
253 match(_t,ENDBLOCK);
254 _t = _t->getNextSibling();
255 _t = __t14;
256 _t = _t->getNextSibling();
257 #line 79 "MDTreeParser.g"
258 blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
259 #line 260 "MDTreeParser.cpp"
260 }
261 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
262 reportError(ex);
263 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
264 _t = _t->getNextSibling();
265 }
266 _retTree = _t;
267 }
268
269 void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
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 __t18 = _t;
274 ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
275 match(_t,RESTRAINT);
276 _t = _t->getFirstChild();
277 #line 82 "MDTreeParser.g"
278 RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
279 #line 280 "MDTreeParser.cpp"
280 { // ( ... )*
281 for (;;) {
282 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
283 _t = ASTNULL;
284 if ((_t->getType() == ASSIGNEQUAL)) {
285 assignment(_t);
286 _t = _retTree;
287 }
288 else {
289 goto _loop20;
290 }
291
292 }
293 _loop20:;
294 } // ( ... )*
295 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
296 match(_t,ENDBLOCK);
297 _t = _t->getNextSibling();
298 _t = __t18;
299 _t = _t->getNextSibling();
300 #line 84 "MDTreeParser.g"
301 blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
302 #line 303 "MDTreeParser.cpp"
303 }
304 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
305 reportError(ex);
306 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
307 _t = _t->getNextSibling();
308 }
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 50 "MDTreeParser.g"
448
449 int ival;
450 RealType dval, x, y, z;
451 Vector3d dvec;
452
453 #line 454 "MDTreeParser.cpp"
454
455 try { // for error handling
456 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
457 _t = ASTNULL;
458 switch ( _t->getType()) {
459 case NUM_INT:
460 case NUM_LONG:
461 {
462 ival=intConst(_t);
463 _t = _retTree;
464 #line 56 "MDTreeParser.g"
465 blockStack.top()->assign(id->getText(), ival);
466 #line 467 "MDTreeParser.cpp"
467 break;
468 }
469 case NUM_FLOAT:
470 case NUM_DOUBLE:
471 {
472 dval=floatConst(_t);
473 _t = _retTree;
474 #line 57 "MDTreeParser.g"
475 blockStack.top()->assign(id->getText(), dval);
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:
512 {
513 str1 = _t;
514 match(_t,ID);
515 _t = _t->getNextSibling();
516 #line 64 "MDTreeParser.g"
517 blockStack.top()->assign(id->getText(), str1->getText());
518 #line 519 "MDTreeParser.cpp"
519 break;
520 }
521 case StringLiteral:
522 {
523 str2 = _t;
524 match(_t,StringLiteral);
525 _t = _t->getNextSibling();
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 532 "MDTreeParser.cpp"
532 break;
533 }
534 default:
535 {
536 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
537 }
538 }
539 }
540 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
541 reportError(ex);
542 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
543 _t = _t->getNextSibling();
544 }
545 _retTree = _t;
546 }
547
548 int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
549 #line 294 "MDTreeParser.g"
550 int ival;
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;
555
556 try { // for error handling
557 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
558 _t = ASTNULL;
559 switch ( _t->getType()) {
560 case NUM_INT:
561 {
562 i1 = _t;
563 match(_t,NUM_INT);
564 _t = _t->getNextSibling();
565 #line 295 "MDTreeParser.g"
566 ival = lexi_cast<int>(i1->getText());
567 #line 568 "MDTreeParser.cpp"
568 break;
569 }
570 case NUM_LONG:
571 {
572 i2 = _t;
573 match(_t,NUM_LONG);
574 _t = _t->getNextSibling();
575 #line 296 "MDTreeParser.g"
576 ival = lexi_cast<int>(i2->getText());
577 #line 578 "MDTreeParser.cpp"
578 break;
579 }
580 default:
581 {
582 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
583 }
584 }
585 }
586 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
587 reportError(ex);
588 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
589 _t = _t->getNextSibling();
590 }
591 _retTree = _t;
592 return ival;
593 }
594
595 RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
596 #line 306 "MDTreeParser.g"
597 RealType dval;
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;
602
603 try { // for error handling
604 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
605 _t = ASTNULL;
606 switch ( _t->getType()) {
607 case NUM_FLOAT:
608 {
609 d1 = _t;
610 match(_t,NUM_FLOAT);
611 _t = _t->getNextSibling();
612 #line 307 "MDTreeParser.g"
613 dval = lexi_cast<RealType>(d1->getText());
614 #line 615 "MDTreeParser.cpp"
615 break;
616 }
617 case NUM_DOUBLE:
618 {
619 d2 = _t;
620 match(_t,NUM_DOUBLE);
621 _t = _t->getNextSibling();
622 #line 308 "MDTreeParser.g"
623 dval = lexi_cast<RealType>(d2->getText());
624 #line 625 "MDTreeParser.cpp"
625 break;
626 }
627 default:
628 {
629 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
630 }
631 }
632 }
633 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
634 reportError(ex);
635 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
636 _t = _t->getNextSibling();
637 }
638 _retTree = _t;
639 return dval;
640 }
641
642 RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
643 #line 300 "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 301 "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 302 "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
694 try { // for error handling
695 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
696 _t = ASTNULL;
697 switch ( _t->getType()) {
698 case ASSIGNEQUAL:
699 {
700 assignment(_t);
701 _t = _retTree;
702 break;
703 }
704 case ATOM:
705 {
706 atomblock(_t);
707 _t = _retTree;
708 break;
709 }
710 case BOND:
711 {
712 bondblock(_t);
713 _t = _retTree;
714 break;
715 }
716 case BEND:
717 {
718 bendblock(_t);
719 _t = _retTree;
720 break;
721 }
722 case TORSION:
723 {
724 torsionblock(_t);
725 _t = _retTree;
726 break;
727 }
728 case INVERSION:
729 {
730 inversionblock(_t);
731 _t = _retTree;
732 break;
733 }
734 case RIGIDBODY:
735 {
736 rigidbodyblock(_t);
737 _t = _retTree;
738 break;
739 }
740 case CUTOFFGROUP:
741 {
742 cutoffgroupblock(_t);
743 _t = _retTree;
744 break;
745 }
746 case FRAGMENT:
747 {
748 fragmentblock(_t);
749 _t = _retTree;
750 break;
751 }
752 default:
753 {
754 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
755 }
756 }
757 }
758 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
759 reportError(ex);
760 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
761 _t = _t->getNextSibling();
762 }
763 _retTree = _t;
764 }
765
766 void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
767 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
768 #line 119 "MDTreeParser.g"
769
770 int index;
771
772 #line 773 "MDTreeParser.cpp"
773
774 try { // for error handling
775 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
776 ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
777 match(_t,ATOM);
778 _t = _t->getFirstChild();
779 index=intConst(_t);
780 _t = _retTree;
781 #line 123 "MDTreeParser.g"
782 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
783 #line 784 "MDTreeParser.cpp"
784 { // ( ... )*
785 for (;;) {
786 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
787 _t = ASTNULL;
788 if ((_t->getType() == POSITION || _t->getType() == ORIENTATION || _t->getType() == ASSIGNEQUAL)) {
789 atomstatement(_t);
790 _t = _retTree;
791 }
792 else {
793 goto _loop41;
794 }
795
796 }
797 _loop41:;
798 } // ( ... )*
799 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
800 match(_t,ENDBLOCK);
801 _t = _t->getNextSibling();
802 _t = __t39;
803 _t = _t->getNextSibling();
804 #line 125 "MDTreeParser.g"
805
806 blockStack.top()->validate();
807 blockStack.pop();
808 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
809 currMoleculeStamp->addAtomStamp(currAtomStamp);
810
811 #line 812 "MDTreeParser.cpp"
812 }
813 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
814 reportError(ex);
815 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
816 _t = _t->getNextSibling();
817 }
818 _retTree = _t;
819 }
820
821 void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
822 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
823
824 try { // for error handling
825 ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
826 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
827 match(_t,BOND);
828 _t = _t->getFirstChild();
829 #line 145 "MDTreeParser.g"
830 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
831 #line 832 "MDTreeParser.cpp"
832 { // ( ... )*
833 for (;;) {
834 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
835 _t = ASTNULL;
836 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
837 bondstatement(_t);
838 _t = _retTree;
839 }
840 else {
841 goto _loop48;
842 }
843
844 }
845 _loop48:;
846 } // ( ... )*
847 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
848 match(_t,ENDBLOCK);
849 _t = _t->getNextSibling();
850 _t = __t46;
851 _t = _t->getNextSibling();
852 #line 147 "MDTreeParser.g"
853
854 blockStack.pop();
855 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
856 currMoleculeStamp->addBondStamp(currBondStamp);
857
858 #line 859 "MDTreeParser.cpp"
859 }
860 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
861 reportError(ex);
862 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
863 _t = _t->getNextSibling();
864 }
865 _retTree = _t;
866 }
867
868 void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
869 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
870
871 try { // for error handling
872 ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
873 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
874 match(_t,BEND);
875 _t = _t->getFirstChild();
876 #line 163 "MDTreeParser.g"
877 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
878 #line 879 "MDTreeParser.cpp"
879 { // ( ... )*
880 for (;;) {
881 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
882 _t = ASTNULL;
883 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
884 bendstatement(_t);
885 _t = _retTree;
886 }
887 else {
888 goto _loop54;
889 }
890
891 }
892 _loop54:;
893 } // ( ... )*
894 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
895 match(_t,ENDBLOCK);
896 _t = _t->getNextSibling();
897 _t = __t52;
898 _t = _t->getNextSibling();
899 #line 165 "MDTreeParser.g"
900
901 blockStack.top()->validate();
902 blockStack.pop();
903 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
904 currMoleculeStamp->addBendStamp(currBendStamp);
905
906 #line 907 "MDTreeParser.cpp"
907 }
908 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909 reportError(ex);
910 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
911 _t = _t->getNextSibling();
912 }
913 _retTree = _t;
914 }
915
916 void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
917 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
918
919 try { // for error handling
920 ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
921 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
922 match(_t,TORSION);
923 _t = _t->getFirstChild();
924 #line 182 "MDTreeParser.g"
925 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
926 #line 927 "MDTreeParser.cpp"
927 { // ( ... )*
928 for (;;) {
929 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
930 _t = ASTNULL;
931 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
932 torsionstatement(_t);
933 _t = _retTree;
934 }
935 else {
936 goto _loop60;
937 }
938
939 }
940 _loop60:;
941 } // ( ... )*
942 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
943 match(_t,ENDBLOCK);
944 _t = _t->getNextSibling();
945 _t = __t58;
946 _t = _t->getNextSibling();
947 #line 184 "MDTreeParser.g"
948
949 blockStack.top()->validate();
950 blockStack.pop();
951 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
952 currMoleculeStamp->addTorsionStamp(currTorsionStamp);
953
954 #line 955 "MDTreeParser.cpp"
955 }
956 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957 reportError(ex);
958 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
959 _t = _t->getNextSibling();
960 }
961 _retTree = _t;
962 }
963
964 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
965 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
966
967 try { // for error handling
968 ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
969 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
970 match(_t,INVERSION);
971 _t = _t->getFirstChild();
972 #line 201 "MDTreeParser.g"
973 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
974 #line 975 "MDTreeParser.cpp"
975 { // ( ... )*
976 for (;;) {
977 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
978 _t = ASTNULL;
979 if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) {
980 inversionstatement(_t);
981 _t = _retTree;
982 }
983 else {
984 goto _loop66;
985 }
986
987 }
988 _loop66:;
989 } // ( ... )*
990 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
991 match(_t,ENDBLOCK);
992 _t = _t->getNextSibling();
993 _t = __t64;
994 _t = _t->getNextSibling();
995 #line 203 "MDTreeParser.g"
996
997 blockStack.top()->validate();
998 blockStack.pop();
999 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1000 currMoleculeStamp->addInversionStamp(currInversionStamp);
1001
1002 #line 1003 "MDTreeParser.cpp"
1003 }
1004 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1005 reportError(ex);
1006 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1007 _t = _t->getNextSibling();
1008 }
1009 _retTree = _t;
1010 }
1011
1012 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1013 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1014 #line 220 "MDTreeParser.g"
1015
1016 int index;
1017
1018 #line 1019 "MDTreeParser.cpp"
1019
1020 try { // for error handling
1021 ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1022 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1023 match(_t,RIGIDBODY);
1024 _t = _t->getFirstChild();
1025 index=intConst(_t);
1026 _t = _retTree;
1027 #line 224 "MDTreeParser.g"
1028 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1029 #line 1030 "MDTreeParser.cpp"
1030 { // ( ... )*
1031 for (;;) {
1032 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1033 _t = ASTNULL;
1034 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1035 rigidbodystatement(_t);
1036 _t = _retTree;
1037 }
1038 else {
1039 goto _loop72;
1040 }
1041
1042 }
1043 _loop72:;
1044 } // ( ... )*
1045 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1046 match(_t,ENDBLOCK);
1047 _t = _t->getNextSibling();
1048 _t = __t70;
1049 _t = _t->getNextSibling();
1050 #line 226 "MDTreeParser.g"
1051
1052 blockStack.top()->validate();
1053 blockStack.pop();
1054 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1055 currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1056
1057 #line 1058 "MDTreeParser.cpp"
1058 }
1059 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060 reportError(ex);
1061 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1062 _t = _t->getNextSibling();
1063 }
1064 _retTree = _t;
1065 }
1066
1067 void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1068 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1069
1070 try { // for error handling
1071 ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1072 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1073 match(_t,CUTOFFGROUP);
1074 _t = _t->getFirstChild();
1075 #line 243 "MDTreeParser.g"
1076 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1077 #line 1078 "MDTreeParser.cpp"
1078 { // ( ... )*
1079 for (;;) {
1080 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1081 _t = ASTNULL;
1082 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1083 cutoffgroupstatement(_t);
1084 _t = _retTree;
1085 }
1086 else {
1087 goto _loop78;
1088 }
1089
1090 }
1091 _loop78:;
1092 } // ( ... )*
1093 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1094 match(_t,ENDBLOCK);
1095 _t = _t->getNextSibling();
1096 _t = __t76;
1097 _t = _t->getNextSibling();
1098 #line 245 "MDTreeParser.g"
1099
1100 blockStack.top()->validate();
1101 blockStack.pop();
1102 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1103 currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1104
1105 #line 1106 "MDTreeParser.cpp"
1106 }
1107 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1108 reportError(ex);
1109 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1110 _t = _t->getNextSibling();
1111 }
1112 _retTree = _t;
1113 }
1114
1115 void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1116 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1117 #line 262 "MDTreeParser.g"
1118 int ival;
1119 #line 1120 "MDTreeParser.cpp"
1120
1121 try { // for error handling
1122 ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1123 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1124 match(_t,FRAGMENT);
1125 _t = _t->getFirstChild();
1126 ival=intConst(_t);
1127 _t = _retTree;
1128 #line 263 "MDTreeParser.g"
1129 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1130 #line 1131 "MDTreeParser.cpp"
1131 { // ( ... )*
1132 for (;;) {
1133 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1134 _t = ASTNULL;
1135 if ((_t->getType() == ASSIGNEQUAL)) {
1136 fragmentstatement(_t);
1137 _t = _retTree;
1138 }
1139 else {
1140 goto _loop84;
1141 }
1142
1143 }
1144 _loop84:;
1145 } // ( ... )*
1146 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1147 match(_t,ENDBLOCK);
1148 _t = _t->getNextSibling();
1149 _t = __t82;
1150 _t = _t->getNextSibling();
1151 #line 265 "MDTreeParser.g"
1152
1153 blockStack.top()->validate();
1154 blockStack.pop();
1155 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1156 currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1157
1158 #line 1159 "MDTreeParser.cpp"
1159 }
1160 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1161 reportError(ex);
1162 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1163 _t = _t->getNextSibling();
1164 }
1165 _retTree = _t;
1166 }
1167
1168 void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1169 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1170 #line 133 "MDTreeParser.g"
1171
1172 vector<RealType> dvec;
1173 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1174
1175
1176 #line 1177 "MDTreeParser.cpp"
1177
1178 try { // for error handling
1179 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1180 _t = ASTNULL;
1181 switch ( _t->getType()) {
1182 case ASSIGNEQUAL:
1183 {
1184 assignment(_t);
1185 _t = _retTree;
1186 break;
1187 }
1188 case POSITION:
1189 {
1190 ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1191 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1192 match(_t,POSITION);
1193 _t = _t->getFirstChild();
1194 dvec=doubleNumberTuple(_t);
1195 _t = _retTree;
1196 _t = __t43;
1197 _t = _t->getNextSibling();
1198 #line 140 "MDTreeParser.g"
1199 currAtomStamp->setPosition(dvec);
1200 #line 1201 "MDTreeParser.cpp"
1201 break;
1202 }
1203 case ORIENTATION:
1204 {
1205 ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1206 ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1207 match(_t,ORIENTATION);
1208 _t = _t->getFirstChild();
1209 dvec=doubleNumberTuple(_t);
1210 _t = _retTree;
1211 _t = __t44;
1212 _t = _t->getNextSibling();
1213 #line 141 "MDTreeParser.g"
1214 currAtomStamp->setOrientation(dvec);
1215 #line 1216 "MDTreeParser.cpp"
1216 break;
1217 }
1218 default:
1219 {
1220 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1221 }
1222 }
1223 }
1224 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1225 reportError(ex);
1226 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1227 _t = _t->getNextSibling();
1228 }
1229 _retTree = _t;
1230 }
1231
1232 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1233 #line 278 "MDTreeParser.g"
1234 vector<RealType> dvec;
1235 #line 1236 "MDTreeParser.cpp"
1236 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1237 #line 278 "MDTreeParser.g"
1238
1239 RealType dval;
1240
1241 #line 1242 "MDTreeParser.cpp"
1242
1243 try { // for error handling
1244 { // ( ... )+
1245 int _cnt88=0;
1246 for (;;) {
1247 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1248 _t = ASTNULL;
1249 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1250 dval=doubleNumber(_t);
1251 _t = _retTree;
1252 #line 282 "MDTreeParser.g"
1253 dvec.push_back(dval);
1254 #line 1255 "MDTreeParser.cpp"
1255 }
1256 else {
1257 if ( _cnt88>=1 ) { goto _loop88; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1258 }
1259
1260 _cnt88++;
1261 }
1262 _loop88:;
1263 } // ( ... )+
1264 }
1265 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1266 reportError(ex);
1267 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1268 _t = _t->getNextSibling();
1269 }
1270 _retTree = _t;
1271 return dvec;
1272 }
1273
1274 void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1275 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1276 #line 154 "MDTreeParser.g"
1277
1278 vector<int> ivec;
1279 BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1280
1281 #line 1282 "MDTreeParser.cpp"
1282
1283 try { // for error handling
1284 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1285 _t = ASTNULL;
1286 switch ( _t->getType()) {
1287 case ASSIGNEQUAL:
1288 {
1289 assignment(_t);
1290 _t = _retTree;
1291 break;
1292 }
1293 case MEMBERS:
1294 {
1295 ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1296 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1297 match(_t,MEMBERS);
1298 _t = _t->getFirstChild();
1299 ivec=inttuple(_t);
1300 _t = _retTree;
1301 _t = __t50;
1302 _t = _t->getNextSibling();
1303 #line 160 "MDTreeParser.g"
1304 currBondStamp->setMembers(ivec);
1305 #line 1306 "MDTreeParser.cpp"
1306 break;
1307 }
1308 default:
1309 {
1310 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1311 }
1312 }
1313 }
1314 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1315 reportError(ex);
1316 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1317 _t = _t->getNextSibling();
1318 }
1319 _retTree = _t;
1320 }
1321
1322 vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1323 #line 286 "MDTreeParser.g"
1324 vector<int> ivec;
1325 #line 1326 "MDTreeParser.cpp"
1326 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1327 #line 286 "MDTreeParser.g"
1328
1329 int ival;
1330
1331 #line 1332 "MDTreeParser.cpp"
1332
1333 try { // for error handling
1334 { // ( ... )+
1335 int _cnt91=0;
1336 for (;;) {
1337 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338 _t = ASTNULL;
1339 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1340 ival=intConst(_t);
1341 _t = _retTree;
1342 #line 290 "MDTreeParser.g"
1343 ivec.push_back(ival);
1344 #line 1345 "MDTreeParser.cpp"
1345 }
1346 else {
1347 if ( _cnt91>=1 ) { goto _loop91; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1348 }
1349
1350 _cnt91++;
1351 }
1352 _loop91:;
1353 } // ( ... )+
1354 }
1355 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1356 reportError(ex);
1357 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1358 _t = _t->getNextSibling();
1359 }
1360 _retTree = _t;
1361 return ivec;
1362 }
1363
1364 void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1365 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1366 #line 173 "MDTreeParser.g"
1367
1368 vector<int> ivec;
1369 BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1370
1371 #line 1372 "MDTreeParser.cpp"
1372
1373 try { // for error handling
1374 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1375 _t = ASTNULL;
1376 switch ( _t->getType()) {
1377 case ASSIGNEQUAL:
1378 {
1379 assignment(_t);
1380 _t = _retTree;
1381 break;
1382 }
1383 case MEMBERS:
1384 {
1385 ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1386 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1387 match(_t,MEMBERS);
1388 _t = _t->getFirstChild();
1389 ivec=inttuple(_t);
1390 _t = _retTree;
1391 _t = __t56;
1392 _t = _t->getNextSibling();
1393 #line 179 "MDTreeParser.g"
1394 currBendStamp->setMembers(ivec);
1395 #line 1396 "MDTreeParser.cpp"
1396 break;
1397 }
1398 default:
1399 {
1400 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1401 }
1402 }
1403 }
1404 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1405 reportError(ex);
1406 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1407 _t = _t->getNextSibling();
1408 }
1409 _retTree = _t;
1410 }
1411
1412 void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1413 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1414 #line 192 "MDTreeParser.g"
1415
1416 vector<int> ivec;
1417 TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1418
1419 #line 1420 "MDTreeParser.cpp"
1420
1421 try { // for error handling
1422 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1423 _t = ASTNULL;
1424 switch ( _t->getType()) {
1425 case ASSIGNEQUAL:
1426 {
1427 assignment(_t);
1428 _t = _retTree;
1429 break;
1430 }
1431 case MEMBERS:
1432 {
1433 ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1434 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1435 match(_t,MEMBERS);
1436 _t = _t->getFirstChild();
1437 ivec=inttuple(_t);
1438 _t = _retTree;
1439 _t = __t62;
1440 _t = _t->getNextSibling();
1441 #line 198 "MDTreeParser.g"
1442 currTorsionStamp->setMembers(ivec);
1443 #line 1444 "MDTreeParser.cpp"
1444 break;
1445 }
1446 default:
1447 {
1448 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1449 }
1450 }
1451 }
1452 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1453 reportError(ex);
1454 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1455 _t = _t->getNextSibling();
1456 }
1457 _retTree = _t;
1458 }
1459
1460 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1461 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1462 #line 211 "MDTreeParser.g"
1463
1464 int icent;
1465 InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1466
1467 #line 1468 "MDTreeParser.cpp"
1468
1469 try { // for error handling
1470 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1471 _t = ASTNULL;
1472 switch ( _t->getType()) {
1473 case ASSIGNEQUAL:
1474 {
1475 assignment(_t);
1476 _t = _retTree;
1477 break;
1478 }
1479 case CENTER:
1480 {
1481 ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1482 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1483 match(_t,CENTER);
1484 _t = _t->getFirstChild();
1485 icent=intConst(_t);
1486 _t = _retTree;
1487 _t = __t68;
1488 _t = _t->getNextSibling();
1489 #line 217 "MDTreeParser.g"
1490 currInversionStamp->setCenter(icent);
1491 #line 1492 "MDTreeParser.cpp"
1492 break;
1493 }
1494 default:
1495 {
1496 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1497 }
1498 }
1499 }
1500 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1501 reportError(ex);
1502 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1503 _t = _t->getNextSibling();
1504 }
1505 _retTree = _t;
1506 }
1507
1508 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1509 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1510 #line 234 "MDTreeParser.g"
1511
1512 vector<int> ivec;
1513 RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1514
1515 #line 1516 "MDTreeParser.cpp"
1516
1517 try { // for error handling
1518 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1519 _t = ASTNULL;
1520 switch ( _t->getType()) {
1521 case ASSIGNEQUAL:
1522 {
1523 assignment(_t);
1524 _t = _retTree;
1525 break;
1526 }
1527 case MEMBERS:
1528 {
1529 ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1530 ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1531 match(_t,MEMBERS);
1532 _t = _t->getFirstChild();
1533 ivec=inttuple(_t);
1534 _t = _retTree;
1535 _t = __t74;
1536 _t = _t->getNextSibling();
1537 #line 240 "MDTreeParser.g"
1538 currRigidBodyStamp->setMembers(ivec);
1539 #line 1540 "MDTreeParser.cpp"
1540 break;
1541 }
1542 default:
1543 {
1544 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1545 }
1546 }
1547 }
1548 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1549 reportError(ex);
1550 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1551 _t = _t->getNextSibling();
1552 }
1553 _retTree = _t;
1554 }
1555
1556 void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1557 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1558 #line 253 "MDTreeParser.g"
1559
1560 vector<int> ivec;
1561 CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1562
1563 #line 1564 "MDTreeParser.cpp"
1564
1565 try { // for error handling
1566 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1567 _t = ASTNULL;
1568 switch ( _t->getType()) {
1569 case ASSIGNEQUAL:
1570 {
1571 assignment(_t);
1572 _t = _retTree;
1573 break;
1574 }
1575 case MEMBERS:
1576 {
1577 ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1578 ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1579 match(_t,MEMBERS);
1580 _t = _t->getFirstChild();
1581 ivec=inttuple(_t);
1582 _t = _retTree;
1583 _t = __t80;
1584 _t = _t->getNextSibling();
1585 #line 259 "MDTreeParser.g"
1586 currCutoffGroupStamp->setMembers(ivec);
1587 #line 1588 "MDTreeParser.cpp"
1588 break;
1589 }
1590 default:
1591 {
1592 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1593 }
1594 }
1595 }
1596 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1597 reportError(ex);
1598 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1599 _t = _t->getNextSibling();
1600 }
1601 _retTree = _t;
1602 }
1603
1604 void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1605 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1606
1607 try { // for error handling
1608 assignment(_t);
1609 _t = _retTree;
1610 }
1611 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1612 reportError(ex);
1613 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1614 _t = _t->getNextSibling();
1615 }
1616 _retTree = _t;
1617 }
1618
1619 void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1620 {
1621 }
1622 const char* MDTreeParser::tokenNames[] = {
1623 "<0>",
1624 "EOF",
1625 "<2>",
1626 "NULL_TREE_LOOKAHEAD",
1627 "\"component\"",
1628 "\"molecule\"",
1629 "\"zconstraint\"",
1630 "\"restraint\"",
1631 "\"atom\"",
1632 "\"bond\"",
1633 "\"bend\"",
1634 "\"torsion\"",
1635 "\"inversion\"",
1636 "\"rigidBody\"",
1637 "\"cutoffGroup\"",
1638 "\"fragment\"",
1639 "\"members\"",
1640 "\"center\"",
1641 "\"position\"",
1642 "\"orientation\"",
1643 "\"flucQ\"",
1644 "\"RNEMD\"",
1645 "\"minimizer\"",
1646 "ENDBLOCK",
1647 "ID",
1648 "ASSIGNEQUAL",
1649 "SEMICOLON",
1650 "StringLiteral",
1651 "LCURLY",
1652 "RCURLY",
1653 "LBRACKET",
1654 "RBRACKET",
1655 "LPAREN",
1656 "RPAREN",
1657 "COMMA",
1658 "NUM_INT",
1659 "NUM_LONG",
1660 "NUM_FLOAT",
1661 "NUM_DOUBLE",
1662 "DOT",
1663 "COLON",
1664 "QUESTIONMARK",
1665 "Whitespace",
1666 "Comment",
1667 "CPPComment",
1668 "a line directive",
1669 "LineDirective",
1670 "Space",
1671 "CharLiteral",
1672 "EndOfLine",
1673 "Escape",
1674 "Vocabulary",
1675 "Digit",
1676 "Decimal",
1677 "HEX_DIGIT",
1678 "EXPONENT",
1679 "FLOAT_SUFFIX",
1680 0
1681 };
1682
1683 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 40894704UL, 0UL, 0UL, 0UL };
1684 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1685 // ASSIGNEQUAL
1686 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1687 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 33619712UL, 0UL, 0UL, 0UL };
1688 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1689 // "fragment" ASSIGNEQUAL
1690 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1691
1692

Properties

Name Value
svn:keywords Author Id Revision Date