ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 2040
Committed: Thu Nov 13 17:49:44 2014 UTC (10 years, 5 months ago) by gezelter
File size: 47836 byte(s)
Log Message: 
Added a vcorr2spectrum script to simplify the task of computing spectra

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date