ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 1979
Committed: Sat Apr 5 20:56:01 2014 UTC (11 years, 6 months ago) by gezelter
File size: 48158 byte(s)
Log Message: 
* Changed the stdDev printouts in RNEMD stats to the 95% confidence intervals
* Added the ability to specify non-bonded constraints in a molecule
* Added the ability to do selection offsets in the pAngle staticProps module

File Contents

# Content
1 /* $ANTLR 2.7.7 (20140107): "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 314 "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 315 "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 316 "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 326 "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 327 "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 328 "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 320 "MDTreeParser.g"
644 RealType dval;
645 #line 646 "MDTreeParser.cpp"
646 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
647 ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
648 ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
649
650 try { // for error handling
651 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
652 _t = ASTNULL;
653 switch ( _t->getType()) {
654 case NUM_INT:
655 case NUM_LONG:
656 {
657 ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
658 intConst(_t);
659 _t = _retTree;
660 #line 321 "MDTreeParser.g"
661 dval = lexi_cast<RealType>(ic->getText());
662 #line 663 "MDTreeParser.cpp"
663 break;
664 }
665 case NUM_FLOAT:
666 case NUM_DOUBLE:
667 {
668 fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
669 floatConst(_t);
670 _t = _retTree;
671 #line 322 "MDTreeParser.g"
672 dval = lexi_cast<RealType>(fc->getText());
673 #line 674 "MDTreeParser.cpp"
674 break;
675 }
676 default:
677 {
678 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
679 }
680 }
681 }
682 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683 reportError(ex);
684 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
685 _t = _t->getNextSibling();
686 }
687 _retTree = _t;
688 return dval;
689 }
690
691 void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
692 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
693
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 case CONSTRAINT:
753 {
754 constraintblock(_t);
755 _t = _retTree;
756 break;
757 }
758 default:
759 {
760 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
761 }
762 }
763 }
764 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
765 reportError(ex);
766 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
767 _t = _t->getNextSibling();
768 }
769 _retTree = _t;
770 }
771
772 void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
773 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
774 #line 120 "MDTreeParser.g"
775
776 int index;
777
778 #line 779 "MDTreeParser.cpp"
779
780 try { // for error handling
781 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
783 match(_t,ATOM);
784 _t = _t->getFirstChild();
785 index=intConst(_t);
786 _t = _retTree;
787 #line 124 "MDTreeParser.g"
788 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
789 #line 790 "MDTreeParser.cpp"
790 { // ( ... )*
791 for (;;) {
792 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
793 _t = ASTNULL;
794 if ((_t->getType() == POSITION || _t->getType() == ORIENTATION || _t->getType() == ASSIGNEQUAL)) {
795 atomstatement(_t);
796 _t = _retTree;
797 }
798 else {
799 goto _loop41;
800 }
801
802 }
803 _loop41:;
804 } // ( ... )*
805 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
806 match(_t,ENDBLOCK);
807 _t = _t->getNextSibling();
808 _t = __t39;
809 _t = _t->getNextSibling();
810 #line 126 "MDTreeParser.g"
811
812 blockStack.top()->validate();
813 blockStack.pop();
814 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
815 currMoleculeStamp->addAtomStamp(currAtomStamp);
816
817 #line 818 "MDTreeParser.cpp"
818 }
819 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
820 reportError(ex);
821 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
822 _t = _t->getNextSibling();
823 }
824 _retTree = _t;
825 }
826
827 void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
828 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
829
830 try { // for error handling
831 ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
832 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
833 match(_t,BOND);
834 _t = _t->getFirstChild();
835 #line 146 "MDTreeParser.g"
836 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
837 #line 838 "MDTreeParser.cpp"
838 { // ( ... )*
839 for (;;) {
840 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
841 _t = ASTNULL;
842 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
843 bondstatement(_t);
844 _t = _retTree;
845 }
846 else {
847 goto _loop48;
848 }
849
850 }
851 _loop48:;
852 } // ( ... )*
853 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
854 match(_t,ENDBLOCK);
855 _t = _t->getNextSibling();
856 _t = __t46;
857 _t = _t->getNextSibling();
858 #line 148 "MDTreeParser.g"
859
860 blockStack.pop();
861 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
862 currMoleculeStamp->addBondStamp(currBondStamp);
863
864 #line 865 "MDTreeParser.cpp"
865 }
866 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
867 reportError(ex);
868 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
869 _t = _t->getNextSibling();
870 }
871 _retTree = _t;
872 }
873
874 void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
875 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
876
877 try { // for error handling
878 ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
879 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
880 match(_t,BEND);
881 _t = _t->getFirstChild();
882 #line 164 "MDTreeParser.g"
883 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
884 #line 885 "MDTreeParser.cpp"
885 { // ( ... )*
886 for (;;) {
887 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
888 _t = ASTNULL;
889 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
890 bendstatement(_t);
891 _t = _retTree;
892 }
893 else {
894 goto _loop54;
895 }
896
897 }
898 _loop54:;
899 } // ( ... )*
900 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
901 match(_t,ENDBLOCK);
902 _t = _t->getNextSibling();
903 _t = __t52;
904 _t = _t->getNextSibling();
905 #line 166 "MDTreeParser.g"
906
907 blockStack.top()->validate();
908 blockStack.pop();
909 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
910 currMoleculeStamp->addBendStamp(currBendStamp);
911
912 #line 913 "MDTreeParser.cpp"
913 }
914 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
915 reportError(ex);
916 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
917 _t = _t->getNextSibling();
918 }
919 _retTree = _t;
920 }
921
922 void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
923 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
924
925 try { // for error handling
926 ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
927 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
928 match(_t,TORSION);
929 _t = _t->getFirstChild();
930 #line 183 "MDTreeParser.g"
931 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
932 #line 933 "MDTreeParser.cpp"
933 { // ( ... )*
934 for (;;) {
935 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
936 _t = ASTNULL;
937 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
938 torsionstatement(_t);
939 _t = _retTree;
940 }
941 else {
942 goto _loop60;
943 }
944
945 }
946 _loop60:;
947 } // ( ... )*
948 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
949 match(_t,ENDBLOCK);
950 _t = _t->getNextSibling();
951 _t = __t58;
952 _t = _t->getNextSibling();
953 #line 185 "MDTreeParser.g"
954
955 blockStack.top()->validate();
956 blockStack.pop();
957 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
958 currMoleculeStamp->addTorsionStamp(currTorsionStamp);
959
960 #line 961 "MDTreeParser.cpp"
961 }
962 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
963 reportError(ex);
964 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
965 _t = _t->getNextSibling();
966 }
967 _retTree = _t;
968 }
969
970 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
971 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
972
973 try { // for error handling
974 ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
975 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
976 match(_t,INVERSION);
977 _t = _t->getFirstChild();
978 #line 202 "MDTreeParser.g"
979 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
980 #line 981 "MDTreeParser.cpp"
981 { // ( ... )*
982 for (;;) {
983 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
984 _t = ASTNULL;
985 if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
986 inversionstatement(_t);
987 _t = _retTree;
988 }
989 else {
990 goto _loop66;
991 }
992
993 }
994 _loop66:;
995 } // ( ... )*
996 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
997 match(_t,ENDBLOCK);
998 _t = _t->getNextSibling();
999 _t = __t64;
1000 _t = _t->getNextSibling();
1001 #line 204 "MDTreeParser.g"
1002
1003 blockStack.top()->validate();
1004 blockStack.pop();
1005 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1006 currMoleculeStamp->addInversionStamp(currInversionStamp);
1007
1008 #line 1009 "MDTreeParser.cpp"
1009 }
1010 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1011 reportError(ex);
1012 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1013 _t = _t->getNextSibling();
1014 }
1015 _retTree = _t;
1016 }
1017
1018 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1019 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1020 #line 223 "MDTreeParser.g"
1021
1022 int index;
1023
1024 #line 1025 "MDTreeParser.cpp"
1025
1026 try { // for error handling
1027 ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1028 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1029 match(_t,RIGIDBODY);
1030 _t = _t->getFirstChild();
1031 index=intConst(_t);
1032 _t = _retTree;
1033 #line 227 "MDTreeParser.g"
1034 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1035 #line 1036 "MDTreeParser.cpp"
1036 { // ( ... )*
1037 for (;;) {
1038 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1039 _t = ASTNULL;
1040 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1041 rigidbodystatement(_t);
1042 _t = _retTree;
1043 }
1044 else {
1045 goto _loop73;
1046 }
1047
1048 }
1049 _loop73:;
1050 } // ( ... )*
1051 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1052 match(_t,ENDBLOCK);
1053 _t = _t->getNextSibling();
1054 _t = __t71;
1055 _t = _t->getNextSibling();
1056 #line 229 "MDTreeParser.g"
1057
1058 blockStack.top()->validate();
1059 blockStack.pop();
1060 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1061 currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1062
1063 #line 1064 "MDTreeParser.cpp"
1064 }
1065 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1066 reportError(ex);
1067 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1068 _t = _t->getNextSibling();
1069 }
1070 _retTree = _t;
1071 }
1072
1073 void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1074 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1075
1076 try { // for error handling
1077 ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1078 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1079 match(_t,CUTOFFGROUP);
1080 _t = _t->getFirstChild();
1081 #line 246 "MDTreeParser.g"
1082 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1083 #line 1084 "MDTreeParser.cpp"
1084 { // ( ... )*
1085 for (;;) {
1086 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1087 _t = ASTNULL;
1088 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1089 cutoffgroupstatement(_t);
1090 _t = _retTree;
1091 }
1092 else {
1093 goto _loop79;
1094 }
1095
1096 }
1097 _loop79:;
1098 } // ( ... )*
1099 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1100 match(_t,ENDBLOCK);
1101 _t = _t->getNextSibling();
1102 _t = __t77;
1103 _t = _t->getNextSibling();
1104 #line 248 "MDTreeParser.g"
1105
1106 blockStack.top()->validate();
1107 blockStack.pop();
1108 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1109 currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1110
1111 #line 1112 "MDTreeParser.cpp"
1112 }
1113 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1114 reportError(ex);
1115 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1116 _t = _t->getNextSibling();
1117 }
1118 _retTree = _t;
1119 }
1120
1121 void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1122 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1123 #line 265 "MDTreeParser.g"
1124 int ival;
1125 #line 1126 "MDTreeParser.cpp"
1126
1127 try { // for error handling
1128 ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1129 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1130 match(_t,FRAGMENT);
1131 _t = _t->getFirstChild();
1132 ival=intConst(_t);
1133 _t = _retTree;
1134 #line 266 "MDTreeParser.g"
1135 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1136 #line 1137 "MDTreeParser.cpp"
1137 { // ( ... )*
1138 for (;;) {
1139 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1140 _t = ASTNULL;
1141 if ((_t->getType() == ASSIGNEQUAL)) {
1142 fragmentstatement(_t);
1143 _t = _retTree;
1144 }
1145 else {
1146 goto _loop85;
1147 }
1148
1149 }
1150 _loop85:;
1151 } // ( ... )*
1152 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1153 match(_t,ENDBLOCK);
1154 _t = _t->getNextSibling();
1155 _t = __t83;
1156 _t = _t->getNextSibling();
1157 #line 268 "MDTreeParser.g"
1158
1159 blockStack.top()->validate();
1160 blockStack.pop();
1161 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1162 currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1163
1164 #line 1165 "MDTreeParser.cpp"
1165 }
1166 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1167 reportError(ex);
1168 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1169 _t = _t->getNextSibling();
1170 }
1171 _retTree = _t;
1172 }
1173
1174 void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1175 ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1176
1177 try { // for error handling
1178 ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1179 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1180 match(_t,CONSTRAINT);
1181 _t = _t->getFirstChild();
1182 #line 279 "MDTreeParser.g"
1183 ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1184 #line 1185 "MDTreeParser.cpp"
1185 { // ( ... )*
1186 for (;;) {
1187 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1188 _t = ASTNULL;
1189 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1190 constraintstatement(_t);
1191 _t = _retTree;
1192 }
1193 else {
1194 goto _loop90;
1195 }
1196
1197 }
1198 _loop90:;
1199 } // ( ... )*
1200 ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1201 match(_t,ENDBLOCK);
1202 _t = _t->getNextSibling();
1203 _t = __t88;
1204 _t = _t->getNextSibling();
1205 #line 281 "MDTreeParser.g"
1206
1207 blockStack.pop();
1208 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1209 currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1210
1211 #line 1212 "MDTreeParser.cpp"
1212 }
1213 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1214 reportError(ex);
1215 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1216 _t = _t->getNextSibling();
1217 }
1218 _retTree = _t;
1219 }
1220
1221 void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1222 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1223 #line 134 "MDTreeParser.g"
1224
1225 vector<RealType> dvec;
1226 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1227
1228
1229 #line 1230 "MDTreeParser.cpp"
1230
1231 try { // for error handling
1232 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1233 _t = ASTNULL;
1234 switch ( _t->getType()) {
1235 case ASSIGNEQUAL:
1236 {
1237 assignment(_t);
1238 _t = _retTree;
1239 break;
1240 }
1241 case POSITION:
1242 {
1243 ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1244 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1245 match(_t,POSITION);
1246 _t = _t->getFirstChild();
1247 dvec=doubleNumberTuple(_t);
1248 _t = _retTree;
1249 _t = __t43;
1250 _t = _t->getNextSibling();
1251 #line 141 "MDTreeParser.g"
1252 currAtomStamp->setPosition(dvec);
1253 #line 1254 "MDTreeParser.cpp"
1254 break;
1255 }
1256 case ORIENTATION:
1257 {
1258 ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1259 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1260 match(_t,ORIENTATION);
1261 _t = _t->getFirstChild();
1262 dvec=doubleNumberTuple(_t);
1263 _t = _retTree;
1264 _t = __t44;
1265 _t = _t->getNextSibling();
1266 #line 142 "MDTreeParser.g"
1267 currAtomStamp->setOrientation(dvec);
1268 #line 1269 "MDTreeParser.cpp"
1269 break;
1270 }
1271 default:
1272 {
1273 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1274 }
1275 }
1276 }
1277 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1278 reportError(ex);
1279 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1280 _t = _t->getNextSibling();
1281 }
1282 _retTree = _t;
1283 }
1284
1285 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286 #line 298 "MDTreeParser.g"
1287 vector<RealType> dvec;
1288 #line 1289 "MDTreeParser.cpp"
1289 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290 #line 298 "MDTreeParser.g"
1291
1292 RealType dval;
1293
1294 #line 1295 "MDTreeParser.cpp"
1295
1296 try { // for error handling
1297 { // ( ... )+
1298 int _cnt95=0;
1299 for (;;) {
1300 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1301 _t = ASTNULL;
1302 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1303 dval=doubleNumber(_t);
1304 _t = _retTree;
1305 #line 302 "MDTreeParser.g"
1306 dvec.push_back(dval);
1307 #line 1308 "MDTreeParser.cpp"
1308 }
1309 else {
1310 if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1311 }
1312
1313 _cnt95++;
1314 }
1315 _loop95:;
1316 } // ( ... )+
1317 }
1318 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1319 reportError(ex);
1320 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1321 _t = _t->getNextSibling();
1322 }
1323 _retTree = _t;
1324 return dvec;
1325 }
1326
1327 void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 #line 155 "MDTreeParser.g"
1330
1331 vector<int> ivec;
1332 BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1333
1334 #line 1335 "MDTreeParser.cpp"
1335
1336 try { // for error handling
1337 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338 _t = ASTNULL;
1339 switch ( _t->getType()) {
1340 case ASSIGNEQUAL:
1341 {
1342 assignment(_t);
1343 _t = _retTree;
1344 break;
1345 }
1346 case MEMBERS:
1347 {
1348 ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1349 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1350 match(_t,MEMBERS);
1351 _t = _t->getFirstChild();
1352 ivec=inttuple(_t);
1353 _t = _retTree;
1354 _t = __t50;
1355 _t = _t->getNextSibling();
1356 #line 161 "MDTreeParser.g"
1357 currBondStamp->setMembers(ivec);
1358 #line 1359 "MDTreeParser.cpp"
1359 break;
1360 }
1361 default:
1362 {
1363 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1364 }
1365 }
1366 }
1367 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1368 reportError(ex);
1369 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1370 _t = _t->getNextSibling();
1371 }
1372 _retTree = _t;
1373 }
1374
1375 vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376 #line 306 "MDTreeParser.g"
1377 vector<int> ivec;
1378 #line 1379 "MDTreeParser.cpp"
1379 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380 #line 306 "MDTreeParser.g"
1381
1382 int ival;
1383
1384 #line 1385 "MDTreeParser.cpp"
1385
1386 try { // for error handling
1387 { // ( ... )+
1388 int _cnt98=0;
1389 for (;;) {
1390 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1391 _t = ASTNULL;
1392 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1393 ival=intConst(_t);
1394 _t = _retTree;
1395 #line 310 "MDTreeParser.g"
1396 ivec.push_back(ival);
1397 #line 1398 "MDTreeParser.cpp"
1398 }
1399 else {
1400 if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1401 }
1402
1403 _cnt98++;
1404 }
1405 _loop98:;
1406 } // ( ... )+
1407 }
1408 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1409 reportError(ex);
1410 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1411 _t = _t->getNextSibling();
1412 }
1413 _retTree = _t;
1414 return ivec;
1415 }
1416
1417 void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1418 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1419 #line 174 "MDTreeParser.g"
1420
1421 vector<int> ivec;
1422 BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1423
1424 #line 1425 "MDTreeParser.cpp"
1425
1426 try { // for error handling
1427 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1428 _t = ASTNULL;
1429 switch ( _t->getType()) {
1430 case ASSIGNEQUAL:
1431 {
1432 assignment(_t);
1433 _t = _retTree;
1434 break;
1435 }
1436 case MEMBERS:
1437 {
1438 ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1439 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1440 match(_t,MEMBERS);
1441 _t = _t->getFirstChild();
1442 ivec=inttuple(_t);
1443 _t = _retTree;
1444 _t = __t56;
1445 _t = _t->getNextSibling();
1446 #line 180 "MDTreeParser.g"
1447 currBendStamp->setMembers(ivec);
1448 #line 1449 "MDTreeParser.cpp"
1449 break;
1450 }
1451 default:
1452 {
1453 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1454 }
1455 }
1456 }
1457 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1458 reportError(ex);
1459 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1460 _t = _t->getNextSibling();
1461 }
1462 _retTree = _t;
1463 }
1464
1465 void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1466 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1467 #line 193 "MDTreeParser.g"
1468
1469 vector<int> ivec;
1470 TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1471
1472 #line 1473 "MDTreeParser.cpp"
1473
1474 try { // for error handling
1475 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1476 _t = ASTNULL;
1477 switch ( _t->getType()) {
1478 case ASSIGNEQUAL:
1479 {
1480 assignment(_t);
1481 _t = _retTree;
1482 break;
1483 }
1484 case MEMBERS:
1485 {
1486 ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1487 ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1488 match(_t,MEMBERS);
1489 _t = _t->getFirstChild();
1490 ivec=inttuple(_t);
1491 _t = _retTree;
1492 _t = __t62;
1493 _t = _t->getNextSibling();
1494 #line 199 "MDTreeParser.g"
1495 currTorsionStamp->setMembers(ivec);
1496 #line 1497 "MDTreeParser.cpp"
1497 break;
1498 }
1499 default:
1500 {
1501 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1502 }
1503 }
1504 }
1505 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1506 reportError(ex);
1507 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1508 _t = _t->getNextSibling();
1509 }
1510 _retTree = _t;
1511 }
1512
1513 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1514 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515 #line 212 "MDTreeParser.g"
1516
1517 int icent;
1518 vector<int> ivec;
1519 InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1520
1521 #line 1522 "MDTreeParser.cpp"
1522
1523 try { // for error handling
1524 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1525 _t = ASTNULL;
1526 switch ( _t->getType()) {
1527 case ASSIGNEQUAL:
1528 {
1529 assignment(_t);
1530 _t = _retTree;
1531 break;
1532 }
1533 case CENTER:
1534 {
1535 ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1536 ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1537 match(_t,CENTER);
1538 _t = _t->getFirstChild();
1539 icent=intConst(_t);
1540 _t = _retTree;
1541 _t = __t68;
1542 _t = _t->getNextSibling();
1543 #line 219 "MDTreeParser.g"
1544 currInversionStamp->setCenter(icent);
1545 #line 1546 "MDTreeParser.cpp"
1546 break;
1547 }
1548 case SATELLITES:
1549 {
1550 ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1551 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1552 match(_t,SATELLITES);
1553 _t = _t->getFirstChild();
1554 ivec=inttuple(_t);
1555 _t = _retTree;
1556 _t = __t69;
1557 _t = _t->getNextSibling();
1558 #line 220 "MDTreeParser.g"
1559 currInversionStamp->setSatellites(ivec);
1560 #line 1561 "MDTreeParser.cpp"
1561 break;
1562 }
1563 default:
1564 {
1565 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1566 }
1567 }
1568 }
1569 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1570 reportError(ex);
1571 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1572 _t = _t->getNextSibling();
1573 }
1574 _retTree = _t;
1575 }
1576
1577 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1578 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1579 #line 237 "MDTreeParser.g"
1580
1581 vector<int> ivec;
1582 RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1583
1584 #line 1585 "MDTreeParser.cpp"
1585
1586 try { // for error handling
1587 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1588 _t = ASTNULL;
1589 switch ( _t->getType()) {
1590 case ASSIGNEQUAL:
1591 {
1592 assignment(_t);
1593 _t = _retTree;
1594 break;
1595 }
1596 case MEMBERS:
1597 {
1598 ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1599 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1600 match(_t,MEMBERS);
1601 _t = _t->getFirstChild();
1602 ivec=inttuple(_t);
1603 _t = _retTree;
1604 _t = __t75;
1605 _t = _t->getNextSibling();
1606 #line 243 "MDTreeParser.g"
1607 currRigidBodyStamp->setMembers(ivec);
1608 #line 1609 "MDTreeParser.cpp"
1609 break;
1610 }
1611 default:
1612 {
1613 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1614 }
1615 }
1616 }
1617 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1618 reportError(ex);
1619 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1620 _t = _t->getNextSibling();
1621 }
1622 _retTree = _t;
1623 }
1624
1625 void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1626 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1627 #line 256 "MDTreeParser.g"
1628
1629 vector<int> ivec;
1630 CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1631
1632 #line 1633 "MDTreeParser.cpp"
1633
1634 try { // for error handling
1635 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1636 _t = ASTNULL;
1637 switch ( _t->getType()) {
1638 case ASSIGNEQUAL:
1639 {
1640 assignment(_t);
1641 _t = _retTree;
1642 break;
1643 }
1644 case MEMBERS:
1645 {
1646 ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1647 ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1648 match(_t,MEMBERS);
1649 _t = _t->getFirstChild();
1650 ivec=inttuple(_t);
1651 _t = _retTree;
1652 _t = __t81;
1653 _t = _t->getNextSibling();
1654 #line 262 "MDTreeParser.g"
1655 currCutoffGroupStamp->setMembers(ivec);
1656 #line 1657 "MDTreeParser.cpp"
1657 break;
1658 }
1659 default:
1660 {
1661 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1662 }
1663 }
1664 }
1665 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1666 reportError(ex);
1667 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1668 _t = _t->getNextSibling();
1669 }
1670 _retTree = _t;
1671 }
1672
1673 void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1674 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1675
1676 try { // for error handling
1677 assignment(_t);
1678 _t = _retTree;
1679 }
1680 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1681 reportError(ex);
1682 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1683 _t = _t->getNextSibling();
1684 }
1685 _retTree = _t;
1686 }
1687
1688 void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1689 ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1690 #line 288 "MDTreeParser.g"
1691
1692 vector<int> ivec;
1693 ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1694
1695 #line 1696 "MDTreeParser.cpp"
1696
1697 try { // for error handling
1698 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1699 _t = ASTNULL;
1700 switch ( _t->getType()) {
1701 case ASSIGNEQUAL:
1702 {
1703 assignment(_t);
1704 _t = _retTree;
1705 break;
1706 }
1707 case MEMBERS:
1708 {
1709 ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1710 ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1711 match(_t,MEMBERS);
1712 _t = _t->getFirstChild();
1713 ivec=inttuple(_t);
1714 _t = _retTree;
1715 _t = __t92;
1716 _t = _t->getNextSibling();
1717 #line 294 "MDTreeParser.g"
1718 currConstraintStamp->setMembers(ivec);
1719 #line 1720 "MDTreeParser.cpp"
1720 break;
1721 }
1722 default:
1723 {
1724 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1725 }
1726 }
1727 }
1728 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1729 reportError(ex);
1730 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1731 _t = _t->getNextSibling();
1732 }
1733 _retTree = _t;
1734 }
1735
1736 void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1737 {
1738 }
1739 const char* MDTreeParser::tokenNames[] = {
1740 "<0>",
1741 "EOF",
1742 "<2>",
1743 "NULL_TREE_LOOKAHEAD",
1744 "\"component\"",
1745 "\"molecule\"",
1746 "\"zconstraint\"",
1747 "\"restraint\"",
1748 "\"atom\"",
1749 "\"bond\"",
1750 "\"bend\"",
1751 "\"torsion\"",
1752 "\"inversion\"",
1753 "\"rigidBody\"",
1754 "\"cutoffGroup\"",
1755 "\"constraint\"",
1756 "\"distance\"",
1757 "\"fragment\"",
1758 "\"members\"",
1759 "\"center\"",
1760 "\"satellites\"",
1761 "\"position\"",
1762 "\"orientation\"",
1763 "\"flucQ\"",
1764 "\"RNEMD\"",
1765 "\"minimizer\"",
1766 "ENDBLOCK",
1767 "ID",
1768 "ASSIGNEQUAL",
1769 "SEMICOLON",
1770 "StringLiteral",
1771 "LCURLY",
1772 "RCURLY",
1773 "LBRACKET",
1774 "RBRACKET",
1775 "LPAREN",
1776 "RPAREN",
1777 "COMMA",
1778 "NUM_INT",
1779 "NUM_LONG",
1780 "NUM_FLOAT",
1781 "NUM_DOUBLE",
1782 "DOT",
1783 "COLON",
1784 "QUESTIONMARK",
1785 "Whitespace",
1786 "Comment",
1787 "CPPComment",
1788 "a line directive",
1789 "LineDirective",
1790 "Space",
1791 "CharLiteral",
1792 "EndOfLine",
1793 "Escape",
1794 "Vocabulary",
1795 "Digit",
1796 "Decimal",
1797 "HEX_DIGIT",
1798 "EXPONENT",
1799 "FLOAT_SUFFIX",
1800 0
1801 };
1802
1803 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1804 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1805 // ASSIGNEQUAL
1806 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1807 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1808 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1809 // "constraint" "fragment" ASSIGNEQUAL
1810 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1811
1812

Properties

Name Value
svn:keywords Author Id Revision Date