OpenMD 3.0
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
MDTreeParser.cpp
1/* $ANTLR 2.7.7 (2006-11-01): "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"
11MDTreeParser::MDTreeParser()
12 : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
13}
14
15void 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
46void 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 FRAGMENT:
72 {
73 fragmentblock(_t);
74 _t = _retTree;
75 break;
76 }
77 case ZCONSTRAINT:
78 {
79 zconstraintblock(_t);
80 _t = _retTree;
81 break;
82 }
83 case RESTRAINT:
84 {
85 restraintblock(_t);
86 _t = _retTree;
87 break;
88 }
89 case FLUCQ:
90 {
91 flucqblock(_t);
92 _t = _retTree;
93 break;
94 }
95 case RNEMD:
96 {
97 rnemdblock(_t);
98 _t = _retTree;
99 break;
100 }
101 case MINIMIZER:
102 {
103 minimizerblock(_t);
104 _t = _retTree;
105 break;
106 }
107 default:
108 {
109 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
110 }
111 }
112 }
113 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
114 reportError(ex);
115 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
116 _t = _t->getNextSibling();
117 }
118 _retTree = _t;
119}
120
121void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
122 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
123 ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
124
125 try { // for error handling
126 ANTLR_USE_NAMESPACE(antlr)RefAST __t6 = _t;
127 ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST_in = _t;
128 match(_t,ASSIGNEQUAL);
129 _t = _t->getFirstChild();
130 id = _t;
131 match(_t,ID);
132 _t = _t->getNextSibling();
133 constant(_t,id);
134 _t = _retTree;
135 _t = __t6;
136 _t = _t->getNextSibling();
137 }
138 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
139 reportError(ex);
140 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
141 _t = _t->getNextSibling();
142 }
143 _retTree = _t;
144}
145
146void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
147 ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
148
149 try { // for error handling
150 ANTLR_USE_NAMESPACE(antlr)RefAST __t10 = _t;
151 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
152 match(_t,COMPONENT);
153 _t = _t->getFirstChild();
154#line 71 "MDTreeParser.g"
155 Component* currComponet = new Component(); blockStack.push(currComponet);
156#line 157 "MDTreeParser.cpp"
157 { // ( ... )*
158 for (;;) {
159 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
160 _t = ASTNULL;
161 if ((_t->getType() == ASSIGNEQUAL)) {
162 assignment(_t);
163 _t = _retTree;
164 }
165 else {
166 goto _loop12;
167 }
168
169 }
170 _loop12:;
171 } // ( ... )*
172 ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
173 match(_t,ENDBLOCK);
174 _t = _t->getNextSibling();
175 _t = __t10;
176 _t = _t->getNextSibling();
177#line 73 "MDTreeParser.g"
178 blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
179#line 180 "MDTreeParser.cpp"
180 }
181 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
182 reportError(ex);
183 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
184 _t = _t->getNextSibling();
185 }
186 _retTree = _t;
187}
188
189void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
190 ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
191
192 try { // for error handling
193 ANTLR_USE_NAMESPACE(antlr)RefAST __t34 = _t;
194 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
195 match(_t,MOLECULE);
196 _t = _t->getFirstChild();
197#line 102 "MDTreeParser.g"
198 MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
199#line 200 "MDTreeParser.cpp"
200 { // ( ... )*
201 for (;;) {
202 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
203 _t = ASTNULL;
204 if ((_tokenSet_1.member(_t->getType()))) {
205 moleculestatement(_t);
206 _t = _retTree;
207 }
208 else {
209 goto _loop36;
210 }
211
212 }
213 _loop36:;
214 } // ( ... )*
215 ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
216 match(_t,ENDBLOCK);
217 _t = _t->getNextSibling();
218 _t = __t34;
219 _t = _t->getNextSibling();
220#line 104 "MDTreeParser.g"
221 blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
222#line 223 "MDTreeParser.cpp"
223 }
224 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
225 reportError(ex);
226 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
227 _t = _t->getNextSibling();
228 }
229 _retTree = _t;
230}
231
232void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
233 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
234
235 try { // for error handling
236 ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
237 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
238 match(_t,FRAGMENT);
239 _t = _t->getFirstChild();
240#line 122 "MDTreeParser.g"
241 FragmentStamp* currFragmentStamp = new FragmentStamp(); blockStack.push(currFragmentStamp);
242#line 243 "MDTreeParser.cpp"
243 { // ( ... )*
244 for (;;) {
245 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
246 _t = ASTNULL;
247 if ((_tokenSet_2.member(_t->getType()))) {
248 fragmentstatement(_t);
249 _t = _retTree;
250 }
251 else {
252 goto _loop43;
253 }
254
255 }
256 _loop43:;
257 } // ( ... )*
258 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
259 match(_t,ENDBLOCK);
260 _t = _t->getNextSibling();
261 _t = __t41;
262 _t = _t->getNextSibling();
263#line 124 "MDTreeParser.g"
264 blockStack.top()->validate(); blockStack.pop(); currConf->addFragmentStamp(currFragmentStamp);
265#line 266 "MDTreeParser.cpp"
266 }
267 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
268 reportError(ex);
269 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
270 _t = _t->getNextSibling();
271 }
272 _retTree = _t;
273}
274
275void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
276 ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
277
278 try { // for error handling
279 ANTLR_USE_NAMESPACE(antlr)RefAST __t14 = _t;
280 ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
281 match(_t,ZCONSTRAINT);
282 _t = _t->getFirstChild();
283#line 76 "MDTreeParser.g"
284 ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
285#line 286 "MDTreeParser.cpp"
286 { // ( ... )*
287 for (;;) {
288 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
289 _t = ASTNULL;
290 if ((_t->getType() == ASSIGNEQUAL)) {
291 assignment(_t);
292 _t = _retTree;
293 }
294 else {
295 goto _loop16;
296 }
297
298 }
299 _loop16:;
300 } // ( ... )*
301 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
302 match(_t,ENDBLOCK);
303 _t = _t->getNextSibling();
304 _t = __t14;
305 _t = _t->getNextSibling();
306#line 78 "MDTreeParser.g"
307 blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
308#line 309 "MDTreeParser.cpp"
309 }
310 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
311 reportError(ex);
312 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
313 _t = _t->getNextSibling();
314 }
315 _retTree = _t;
316}
317
318void MDTreeParser::restraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
319 ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
320
321 try { // for error handling
322 ANTLR_USE_NAMESPACE(antlr)RefAST __t18 = _t;
323 ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
324 match(_t,RESTRAINT);
325 _t = _t->getFirstChild();
326#line 81 "MDTreeParser.g"
327 RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);
328#line 329 "MDTreeParser.cpp"
329 { // ( ... )*
330 for (;;) {
331 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
332 _t = ASTNULL;
333 if ((_t->getType() == ASSIGNEQUAL)) {
334 assignment(_t);
335 _t = _retTree;
336 }
337 else {
338 goto _loop20;
339 }
340
341 }
342 _loop20:;
343 } // ( ... )*
344 ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
345 match(_t,ENDBLOCK);
346 _t = _t->getNextSibling();
347 _t = __t18;
348 _t = _t->getNextSibling();
349#line 83 "MDTreeParser.g"
350 blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);
351#line 352 "MDTreeParser.cpp"
352 }
353 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
354 reportError(ex);
355 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
356 _t = _t->getNextSibling();
357 }
358 _retTree = _t;
359}
360
361void MDTreeParser::flucqblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
362 ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
363
364 try { // for error handling
365 ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
366 ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
367 match(_t,FLUCQ);
368 _t = _t->getFirstChild();
369#line 86 "MDTreeParser.g"
370 FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);
371#line 372 "MDTreeParser.cpp"
372 { // ( ... )*
373 for (;;) {
374 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
375 _t = ASTNULL;
376 if ((_t->getType() == ASSIGNEQUAL)) {
377 assignment(_t);
378 _t = _retTree;
379 }
380 else {
381 goto _loop24;
382 }
383
384 }
385 _loop24:;
386 } // ( ... )*
387 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
388 match(_t,ENDBLOCK);
389 _t = _t->getNextSibling();
390 _t = __t22;
391 _t = _t->getNextSibling();
392#line 88 "MDTreeParser.g"
393 blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);
394#line 395 "MDTreeParser.cpp"
395 }
396 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
397 reportError(ex);
398 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
399 _t = _t->getNextSibling();
400 }
401 _retTree = _t;
402}
403
404void MDTreeParser::rnemdblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
405 ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
406
407 try { // for error handling
408 ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
409 ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
410 match(_t,RNEMD);
411 _t = _t->getFirstChild();
412#line 91 "MDTreeParser.g"
413 RNEMD::RNEMDParameters* rnemdPars = new RNEMD::RNEMDParameters(); blockStack.push(rnemdPars);
414#line 415 "MDTreeParser.cpp"
415 { // ( ... )*
416 for (;;) {
417 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
418 _t = ASTNULL;
419 if ((_t->getType() == ASSIGNEQUAL)) {
420 assignment(_t);
421 _t = _retTree;
422 }
423 else {
424 goto _loop28;
425 }
426
427 }
428 _loop28:;
429 } // ( ... )*
430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
431 match(_t,ENDBLOCK);
432 _t = _t->getNextSibling();
433 _t = __t26;
434 _t = _t->getNextSibling();
435#line 93 "MDTreeParser.g"
436 blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);
437#line 438 "MDTreeParser.cpp"
438 }
439 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
440 reportError(ex);
441 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
442 _t = _t->getNextSibling();
443 }
444 _retTree = _t;
445}
446
447void MDTreeParser::minimizerblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
448 ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
449
450 try { // for error handling
451 ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
452 ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
453 match(_t,MINIMIZER);
454 _t = _t->getFirstChild();
455#line 96 "MDTreeParser.g"
456 MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);
457#line 458 "MDTreeParser.cpp"
458 { // ( ... )*
459 for (;;) {
460 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
461 _t = ASTNULL;
462 if ((_t->getType() == ASSIGNEQUAL)) {
463 assignment(_t);
464 _t = _retTree;
465 }
466 else {
467 goto _loop32;
468 }
469
470 }
471 _loop32:;
472 } // ( ... )*
473 ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
474 match(_t,ENDBLOCK);
475 _t = _t->getNextSibling();
476 _t = __t30;
477 _t = _t->getNextSibling();
478#line 98 "MDTreeParser.g"
479 blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);
480#line 481 "MDTreeParser.cpp"
481 }
482 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
483 reportError(ex);
484 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
485 _t = _t->getNextSibling();
486 }
487 _retTree = _t;
488}
489
490void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
491 ANTLR_USE_NAMESPACE(antlr)RefAST id
492) {
493 ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
494 ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
495 ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
496#line 51 "MDTreeParser.g"
497
498 int ival;
499 RealType dval;
500 std::vector<RealType> dvec;
501
502#line 503 "MDTreeParser.cpp"
503
504 try { // for error handling
505 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
506 _t = ASTNULL;
507 switch ( _t->getType()) {
508 case NUM_INT:
509 case NUM_LONG:
510 {
511 ival=intConst(_t);
512 _t = _retTree;
513#line 57 "MDTreeParser.g"
514 blockStack.top()->assign(id->getText(), ival);
515#line 516 "MDTreeParser.cpp"
516 break;
517 }
518 case NUM_FLOAT:
519 case NUM_DOUBLE:
520 {
521 dval=floatConst(_t);
522 _t = _retTree;
523#line 58 "MDTreeParser.g"
524 blockStack.top()->assign(id->getText(), dval);
525#line 526 "MDTreeParser.cpp"
526 break;
527 }
528 case ID:
529 {
530 str1 = _t;
531 match(_t,ID);
532 _t = _t->getNextSibling();
533#line 59 "MDTreeParser.g"
534 blockStack.top()->assign(id->getText(), str1->getText());
535#line 536 "MDTreeParser.cpp"
536 break;
537 }
538 case StringLiteral:
539 {
540 str2 = _t;
541 match(_t,StringLiteral);
542 _t = _t->getNextSibling();
543#line 60 "MDTreeParser.g"
544 std::string s = str2->getText();
545 s = s.substr(1, s.length()-2);
546 blockStack.top()->assign(id->getText(),s);
547
548#line 549 "MDTreeParser.cpp"
549 break;
550 }
551 case LPAREN:
552 {
553 ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
554 ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
555 match(_t,LPAREN);
556 _t = _t->getFirstChild();
557 dvec=doubleNumberTuple(_t);
558 _t = _retTree;
559 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
560 match(_t,RPAREN);
561 _t = _t->getNextSibling();
562 _t = __t8;
563 _t = _t->getNextSibling();
564#line 65 "MDTreeParser.g"
565
566 blockStack.top()->assign(id->getText(), dvec);
567
568#line 569 "MDTreeParser.cpp"
569 break;
570 }
571 default:
572 {
573 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
574 }
575 }
576 }
577 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
578 reportError(ex);
579 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
580 _t = _t->getNextSibling();
581 }
582 _retTree = _t;
583}
584
585int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
586#line 376 "MDTreeParser.g"
587 int ival;
588#line 589 "MDTreeParser.cpp"
589 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
590 ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
591 ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
592
593 try { // for error handling
594 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
595 _t = ASTNULL;
596 switch ( _t->getType()) {
597 case NUM_INT:
598 {
599 i1 = _t;
600 match(_t,NUM_INT);
601 _t = _t->getNextSibling();
602#line 377 "MDTreeParser.g"
603 ival = lexi_cast<int>(i1->getText());
604#line 605 "MDTreeParser.cpp"
605 break;
606 }
607 case NUM_LONG:
608 {
609 i2 = _t;
610 match(_t,NUM_LONG);
611 _t = _t->getNextSibling();
612#line 378 "MDTreeParser.g"
613 ival = lexi_cast<int>(i2->getText());
614#line 615 "MDTreeParser.cpp"
615 break;
616 }
617 default:
618 {
619 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
620 }
621 }
622 }
623 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
624 reportError(ex);
625 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
626 _t = _t->getNextSibling();
627 }
628 _retTree = _t;
629 return ival;
630}
631
632RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
633#line 388 "MDTreeParser.g"
634 RealType dval;
635#line 636 "MDTreeParser.cpp"
636 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
637 ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
638 ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
639
640 try { // for error handling
641 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
642 _t = ASTNULL;
643 switch ( _t->getType()) {
644 case NUM_FLOAT:
645 {
646 d1 = _t;
647 match(_t,NUM_FLOAT);
648 _t = _t->getNextSibling();
649#line 389 "MDTreeParser.g"
650 dval = lexi_cast<RealType>(d1->getText());
651#line 652 "MDTreeParser.cpp"
652 break;
653 }
654 case NUM_DOUBLE:
655 {
656 d2 = _t;
657 match(_t,NUM_DOUBLE);
658 _t = _t->getNextSibling();
659#line 390 "MDTreeParser.g"
660 dval = lexi_cast<RealType>(d2->getText());
661#line 662 "MDTreeParser.cpp"
662 break;
663 }
664 default:
665 {
666 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
667 }
668 }
669 }
670 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
671 reportError(ex);
672 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
673 _t = _t->getNextSibling();
674 }
675 _retTree = _t;
676 return dval;
677}
678
679vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
680#line 360 "MDTreeParser.g"
681 vector<RealType> dvec;
682#line 683 "MDTreeParser.cpp"
683 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
684#line 360 "MDTreeParser.g"
685
686 RealType dval;
687
688#line 689 "MDTreeParser.cpp"
689
690 try { // for error handling
691 { // ( ... )+
692 int _cnt130=0;
693 for (;;) {
694 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
695 _t = ASTNULL;
696 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
697 dval=doubleNumber(_t);
698 _t = _retTree;
699#line 364 "MDTreeParser.g"
700 dvec.push_back(dval);
701#line 702 "MDTreeParser.cpp"
702 }
703 else {
704 if ( _cnt130>=1 ) { goto _loop130; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
705 }
706
707 _cnt130++;
708 }
709 _loop130:;
710 } // ( ... )+
711 }
712 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
713 reportError(ex);
714 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
715 _t = _t->getNextSibling();
716 }
717 _retTree = _t;
718 return dvec;
719}
720
721void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
722 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
723
724 try { // for error handling
725 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
726 _t = ASTNULL;
727 switch ( _t->getType()) {
728 case ATOM:
729 {
730 atomblock(_t);
731 _t = _retTree;
732 break;
733 }
734 case BOND:
735 {
736 bondblock(_t);
737 _t = _retTree;
738 break;
739 }
740 case BEND:
741 {
742 bendblock(_t);
743 _t = _retTree;
744 break;
745 }
746 case TORSION:
747 {
748 torsionblock(_t);
749 _t = _retTree;
750 break;
751 }
752 case INVERSION:
753 {
754 inversionblock(_t);
755 _t = _retTree;
756 break;
757 }
758 case RIGIDBODY:
759 {
760 rigidbodyblock(_t);
761 _t = _retTree;
762 break;
763 }
764 case CUTOFFGROUP:
765 {
766 cutoffgroupblock(_t);
767 _t = _retTree;
768 break;
769 }
770 case CONSTRAINT:
771 {
772 constraintblock(_t);
773 _t = _retTree;
774 break;
775 }
776 default:
777 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
778 _t = ASTNULL;
779 if ((_t->getType() == ASSIGNEQUAL)) {
780 assignment(_t);
781 _t = _retTree;
782 }
783 else if ((_t->getType() == ASSIGNEQUAL)) {
784 sequencestring(_t);
785 _t = _retTree;
786 }
787 else {
788 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
789 }
790 }
791 }
792 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
793 reportError(ex);
794 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
795 _t = _t->getNextSibling();
796 }
797 _retTree = _t;
798}
799
800void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
801 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
802#line 139 "MDTreeParser.g"
803
804 int index;
805
806#line 807 "MDTreeParser.cpp"
807
808 try { // for error handling
809 ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
810 ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
811 match(_t,ATOM);
812 _t = _t->getFirstChild();
813 index=intConst(_t);
814 _t = _retTree;
815#line 143 "MDTreeParser.g"
816 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
817#line 818 "MDTreeParser.cpp"
818 { // ( ... )*
819 for (;;) {
820 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
821 _t = ASTNULL;
822 if ((_tokenSet_3.member(_t->getType()))) {
823 atomstatement(_t);
824 _t = _retTree;
825 }
826 else {
827 goto _loop48;
828 }
829
830 }
831 _loop48:;
832 } // ( ... )*
833 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
834 match(_t,ENDBLOCK);
835 _t = _t->getNextSibling();
836 _t = __t46;
837 _t = _t->getNextSibling();
838#line 145 "MDTreeParser.g"
839
840 blockStack.top()->validate();
841 blockStack.pop();
842 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
843 currMoleculeStamp->addAtomStamp(currAtomStamp);
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
855void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
856 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_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 __t54 = _t;
860 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
861 match(_t,BOND);
862 _t = _t->getFirstChild();
863#line 168 "MDTreeParser.g"
864 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
865#line 866 "MDTreeParser.cpp"
866 { // ( ... )*
867 for (;;) {
868 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
869 _t = ASTNULL;
870 if ((_tokenSet_4.member(_t->getType()))) {
871 bondstatement(_t);
872 _t = _retTree;
873 }
874 else {
875 goto _loop56;
876 }
877
878 }
879 _loop56:;
880 } // ( ... )*
881 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
882 match(_t,ENDBLOCK);
883 _t = _t->getNextSibling();
884 _t = __t54;
885 _t = _t->getNextSibling();
886#line 170 "MDTreeParser.g"
887
888 blockStack.top()->validate();
889 blockStack.pop();
890 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
891 currMoleculeStamp->addBondStamp(currBondStamp);
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
903void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
904 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_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 __t66 = _t;
908 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
909 match(_t,BEND);
910 _t = _t->getFirstChild();
911#line 195 "MDTreeParser.g"
912 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
913#line 914 "MDTreeParser.cpp"
914 { // ( ... )*
915 for (;;) {
916 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
917 _t = ASTNULL;
918 if ((_tokenSet_5.member(_t->getType()))) {
919 bendstatement(_t);
920 _t = _retTree;
921 }
922 else {
923 goto _loop68;
924 }
925
926 }
927 _loop68:;
928 } // ( ... )*
929 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
930 match(_t,ENDBLOCK);
931 _t = _t->getNextSibling();
932 _t = __t66;
933 _t = _t->getNextSibling();
934#line 197 "MDTreeParser.g"
935
936 blockStack.top()->validate();
937 blockStack.pop();
938 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
939 currMoleculeStamp->addBendStamp(currBendStamp);
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
951void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
952 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_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 __t79 = _t;
956 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
957 match(_t,TORSION);
958 _t = _t->getFirstChild();
959#line 222 "MDTreeParser.g"
960 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
961#line 962 "MDTreeParser.cpp"
962 { // ( ... )*
963 for (;;) {
964 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
965 _t = ASTNULL;
966 if ((_tokenSet_6.member(_t->getType()))) {
967 torsionstatement(_t);
968 _t = _retTree;
969 }
970 else {
971 goto _loop81;
972 }
973
974 }
975 _loop81:;
976 } // ( ... )*
977 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978 match(_t,ENDBLOCK);
979 _t = _t->getNextSibling();
980 _t = __t79;
981 _t = _t->getNextSibling();
982#line 224 "MDTreeParser.g"
983
984 blockStack.top()->validate();
985 blockStack.pop();
986 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
987 currMoleculeStamp->addTorsionStamp(currTorsionStamp);
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
999void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1000 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1001
1002 try { // for error handling
1003 ANTLR_USE_NAMESPACE(antlr)RefAST __t93 = _t;
1004 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1005 match(_t,INVERSION);
1006 _t = _t->getFirstChild();
1007#line 251 "MDTreeParser.g"
1008 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
1009#line 1010 "MDTreeParser.cpp"
1010 { // ( ... )*
1011 for (;;) {
1012 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1013 _t = ASTNULL;
1014 if ((_tokenSet_7.member(_t->getType()))) {
1015 inversionstatement(_t);
1016 _t = _retTree;
1017 }
1018 else {
1019 goto _loop95;
1020 }
1021
1022 }
1023 _loop95:;
1024 } // ( ... )*
1025 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1026 match(_t,ENDBLOCK);
1027 _t = _t->getNextSibling();
1028 _t = __t93;
1029 _t = _t->getNextSibling();
1030#line 253 "MDTreeParser.g"
1031
1032 blockStack.top()->validate();
1033 blockStack.pop();
1034 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1035 currMoleculeStamp->addInversionStamp(currInversionStamp);
1036
1037#line 1038 "MDTreeParser.cpp"
1038 }
1039 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1040 reportError(ex);
1041 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1042 _t = _t->getNextSibling();
1043 }
1044 _retTree = _t;
1045}
1046
1047void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1048 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1049#line 279 "MDTreeParser.g"
1050
1051 int index;
1052
1053#line 1054 "MDTreeParser.cpp"
1054
1055 try { // for error handling
1056 ANTLR_USE_NAMESPACE(antlr)RefAST __t105 = _t;
1057 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1058 match(_t,RIGIDBODY);
1059 _t = _t->getFirstChild();
1060 index=intConst(_t);
1061 _t = _retTree;
1062#line 283 "MDTreeParser.g"
1063 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
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 rigidbodystatement(_t);
1071 _t = _retTree;
1072 }
1073 else {
1074 goto _loop107;
1075 }
1076
1077 }
1078 _loop107:;
1079 } // ( ... )*
1080 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1081 match(_t,ENDBLOCK);
1082 _t = _t->getNextSibling();
1083 _t = __t105;
1084 _t = _t->getNextSibling();
1085#line 285 "MDTreeParser.g"
1086
1087 blockStack.top()->validate();
1088 blockStack.pop();
1089 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1090 currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
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
1102void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1103 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1104
1105 try { // for error handling
1106 ANTLR_USE_NAMESPACE(antlr)RefAST __t111 = _t;
1107 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1108 match(_t,CUTOFFGROUP);
1109 _t = _t->getFirstChild();
1110#line 302 "MDTreeParser.g"
1111 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1112#line 1113 "MDTreeParser.cpp"
1113 { // ( ... )*
1114 for (;;) {
1115 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1116 _t = ASTNULL;
1117 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1118 cutoffgroupstatement(_t);
1119 _t = _retTree;
1120 }
1121 else {
1122 goto _loop113;
1123 }
1124
1125 }
1126 _loop113:;
1127 } // ( ... )*
1128 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1129 match(_t,ENDBLOCK);
1130 _t = _t->getNextSibling();
1131 _t = __t111;
1132 _t = _t->getNextSibling();
1133#line 304 "MDTreeParser.g"
1134
1135 blockStack.top()->validate();
1136 blockStack.pop();
1137 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1138 currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1139
1140#line 1141 "MDTreeParser.cpp"
1141 }
1142 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1143 reportError(ex);
1144 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1145 _t = _t->getNextSibling();
1146 }
1147 _retTree = _t;
1148}
1149
1150void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1151 ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1152
1153 try { // for error handling
1154 ANTLR_USE_NAMESPACE(antlr)RefAST __t117 = _t;
1155 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1156 match(_t,CONSTRAINT);
1157 _t = _t->getFirstChild();
1158#line 322 "MDTreeParser.g"
1159 ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1160#line 1161 "MDTreeParser.cpp"
1161 { // ( ... )*
1162 for (;;) {
1163 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1164 _t = ASTNULL;
1165 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1166 constraintstatement(_t);
1167 _t = _retTree;
1168 }
1169 else {
1170 goto _loop119;
1171 }
1172
1173 }
1174 _loop119:;
1175 } // ( ... )*
1176 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1177 match(_t,ENDBLOCK);
1178 _t = _t->getNextSibling();
1179 _t = __t117;
1180 _t = _t->getNextSibling();
1181#line 324 "MDTreeParser.g"
1182
1183 blockStack.pop();
1184 MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1185 currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1186
1187#line 1188 "MDTreeParser.cpp"
1188 }
1189 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1190 reportError(ex);
1191 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1192 _t = _t->getNextSibling();
1193 }
1194 _retTree = _t;
1195}
1196
1197void MDTreeParser::sequencestring(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1198 ANTLR_USE_NAMESPACE(antlr)RefAST sequencestring_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1199 ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST;
1200
1201 try { // for error handling
1202 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1203 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1204 match(_t,ASSIGNEQUAL);
1205 _t = _t->getFirstChild();
1206 id = _t;
1207 match(_t,SEQUENCE);
1208 _t = _t->getNextSibling();
1209 constant(_t,id);
1210 _t = _retTree;
1211 _t = __t39;
1212 _t = _t->getNextSibling();
1213 }
1214 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1215 reportError(ex);
1216 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1217 _t = _t->getNextSibling();
1218 }
1219 _retTree = _t;
1220}
1221
1222void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1223 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1224
1225 try { // for error handling
1226 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1227 _t = ASTNULL;
1228 switch ( _t->getType()) {
1229 case ASSIGNEQUAL:
1230 {
1231 assignment(_t);
1232 _t = _retTree;
1233 break;
1234 }
1235 case ATOM:
1236 {
1237 atomblock(_t);
1238 _t = _retTree;
1239 break;
1240 }
1241 case BOND:
1242 {
1243 bondblock(_t);
1244 _t = _retTree;
1245 break;
1246 }
1247 case BEND:
1248 {
1249 bendblock(_t);
1250 _t = _retTree;
1251 break;
1252 }
1253 case TORSION:
1254 {
1255 torsionblock(_t);
1256 _t = _retTree;
1257 break;
1258 }
1259 case INVERSION:
1260 {
1261 inversionblock(_t);
1262 _t = _retTree;
1263 break;
1264 }
1265 case RIGIDBODY:
1266 {
1267 rigidbodyblock(_t);
1268 _t = _retTree;
1269 break;
1270 }
1271 case CUTOFFGROUP:
1272 {
1273 cutoffgroupblock(_t);
1274 _t = _retTree;
1275 break;
1276 }
1277 case CONSTRAINT:
1278 {
1279 constraintblock(_t);
1280 _t = _retTree;
1281 break;
1282 }
1283 case NODES:
1284 {
1285 nodesblock(_t);
1286 _t = _retTree;
1287 break;
1288 }
1289 default:
1290 {
1291 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1292 }
1293 }
1294 }
1295 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1296 reportError(ex);
1297 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1298 _t = _t->getNextSibling();
1299 }
1300 _retTree = _t;
1301}
1302
1303void MDTreeParser::nodesblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1304 ANTLR_USE_NAMESPACE(antlr)RefAST nodesblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1305
1306 try { // for error handling
1307 ANTLR_USE_NAMESPACE(antlr)RefAST __t123 = _t;
1308 ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1309 match(_t,NODES);
1310 _t = _t->getFirstChild();
1311#line 341 "MDTreeParser.g"
1312 NodesStamp* currNodesStamp = new NodesStamp(); blockStack.push(currNodesStamp);
1313#line 1314 "MDTreeParser.cpp"
1314 { // ( ... )*
1315 for (;;) {
1316 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1317 _t = ASTNULL;
1318 if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1319 nodesstatement(_t);
1320 _t = _retTree;
1321 }
1322 else {
1323 goto _loop125;
1324 }
1325
1326 }
1327 _loop125:;
1328 } // ( ... )*
1329 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1330 match(_t,ENDBLOCK);
1331 _t = _t->getNextSibling();
1332 _t = __t123;
1333 _t = _t->getNextSibling();
1334#line 343 "MDTreeParser.g"
1335
1336 blockStack.top()->validate();
1337 blockStack.pop();
1338 FragmentStamp* currFragmentStamp = static_cast<FragmentStamp*>(blockStack.top());
1339 currFragmentStamp->addNodesStamp(currNodesStamp);
1340
1341#line 1342 "MDTreeParser.cpp"
1342 }
1343 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1344 reportError(ex);
1345 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1346 _t = _t->getNextSibling();
1347 }
1348 _retTree = _t;
1349}
1350
1351void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1352 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1353#line 153 "MDTreeParser.g"
1354
1355 vector<RealType> dvec;
1356 RealType rval;
1357 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1358
1359
1360#line 1361 "MDTreeParser.cpp"
1361
1362 try { // for error handling
1363 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1364 _t = ASTNULL;
1365 switch ( _t->getType()) {
1366 case ASSIGNEQUAL:
1367 {
1368 assignment(_t);
1369 _t = _retTree;
1370 break;
1371 }
1372 case POSITION:
1373 {
1374 ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1375 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1376 match(_t,POSITION);
1377 _t = _t->getFirstChild();
1378 dvec=doubleNumberTuple(_t);
1379 _t = _retTree;
1380 _t = __t50;
1381 _t = _t->getNextSibling();
1382#line 161 "MDTreeParser.g"
1383 currAtomStamp->setPosition(dvec);
1384#line 1385 "MDTreeParser.cpp"
1385 break;
1386 }
1387 case ORIENTATION:
1388 {
1389 ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1390 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1391 match(_t,ORIENTATION);
1392 _t = _t->getFirstChild();
1393 dvec=doubleNumberTuple(_t);
1394 _t = _retTree;
1395 _t = __t51;
1396 _t = _t->getNextSibling();
1397#line 162 "MDTreeParser.g"
1398 currAtomStamp->setOrientation(dvec);
1399#line 1400 "MDTreeParser.cpp"
1400 break;
1401 }
1402 case CHARGE:
1403 {
1404 ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
1405 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1406 match(_t,CHARGE);
1407 _t = _t->getFirstChild();
1408 rval=doubleNumber(_t);
1409 _t = _retTree;
1410 _t = __t52;
1411 _t = _t->getNextSibling();
1412#line 163 "MDTreeParser.g"
1413 currAtomStamp->overrideCharge(rval);
1414#line 1415 "MDTreeParser.cpp"
1415 break;
1416 }
1417 default:
1418 {
1419 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1420 }
1421 }
1422 }
1423 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1424 reportError(ex);
1425 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1426 _t = _t->getNextSibling();
1427 }
1428 _retTree = _t;
1429}
1430
1431RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1432#line 382 "MDTreeParser.g"
1433 RealType dval;
1434#line 1435 "MDTreeParser.cpp"
1435 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1436 ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1437 ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1438
1439 try { // for error handling
1440 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1441 _t = ASTNULL;
1442 switch ( _t->getType()) {
1443 case NUM_INT:
1444 case NUM_LONG:
1445 {
1446 ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1447 intConst(_t);
1448 _t = _retTree;
1449#line 383 "MDTreeParser.g"
1450 dval = lexi_cast<RealType>(ic->getText());
1451#line 1452 "MDTreeParser.cpp"
1452 break;
1453 }
1454 case NUM_FLOAT:
1455 case NUM_DOUBLE:
1456 {
1457 fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1458 floatConst(_t);
1459 _t = _retTree;
1460#line 384 "MDTreeParser.g"
1461 dval = lexi_cast<RealType>(fc->getText());
1462#line 1463 "MDTreeParser.cpp"
1463 break;
1464 }
1465 default:
1466 {
1467 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1468 }
1469 }
1470 }
1471 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1472 reportError(ex);
1473 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1474 _t = _t->getNextSibling();
1475 }
1476 _retTree = _t;
1477 return dval;
1478}
1479
1480void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1481 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1482#line 178 "MDTreeParser.g"
1483
1484 vector<int> ivec;
1485 RealType rval;
1486 vector<RealType> dvec;
1487 BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1488
1489#line 1490 "MDTreeParser.cpp"
1490
1491 try { // for error handling
1492 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1493 _t = ASTNULL;
1494 switch ( _t->getType()) {
1495 case ASSIGNEQUAL:
1496 {
1497 assignment(_t);
1498 _t = _retTree;
1499 break;
1500 }
1501 case MEMBERS:
1502 {
1503 ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
1504 ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1505 match(_t,MEMBERS);
1506 _t = _t->getFirstChild();
1507 ivec=inttuple(_t);
1508 _t = _retTree;
1509 _t = __t58;
1510 _t = _t->getNextSibling();
1511#line 186 "MDTreeParser.g"
1512 currBondStamp->setMembers(ivec);
1513#line 1514 "MDTreeParser.cpp"
1514 break;
1515 }
1516 case FIXED:
1517 {
1518 ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
1519 ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1520 match(_t,FIXED);
1521 _t = _t->getFirstChild();
1522 rval=doubleNumber(_t);
1523 _t = _retTree;
1524 _t = __t59;
1525 _t = _t->getNextSibling();
1526#line 187 "MDTreeParser.g"
1527 currBondStamp->overrideType("Fixed", rval);
1528#line 1529 "MDTreeParser.cpp"
1529 break;
1530 }
1531 case HARMONIC:
1532 {
1533 ANTLR_USE_NAMESPACE(antlr)RefAST __t60 = _t;
1534 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1535 match(_t,HARMONIC);
1536 _t = _t->getFirstChild();
1537 dvec=doubleNumberTuple(_t);
1538 _t = _retTree;
1539 _t = __t60;
1540 _t = _t->getNextSibling();
1541#line 188 "MDTreeParser.g"
1542 currBondStamp->overrideType("Harmonic", dvec);
1543#line 1544 "MDTreeParser.cpp"
1544 break;
1545 }
1546 case CUBIC:
1547 {
1548 ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1549 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1550 match(_t,CUBIC);
1551 _t = _t->getFirstChild();
1552 dvec=doubleNumberTuple(_t);
1553 _t = _retTree;
1554 _t = __t61;
1555 _t = _t->getNextSibling();
1556#line 189 "MDTreeParser.g"
1557 currBondStamp->overrideType("Cubic", dvec);
1558#line 1559 "MDTreeParser.cpp"
1559 break;
1560 }
1561 case QUARTIC:
1562 {
1563 ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1564 ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1565 match(_t,QUARTIC);
1566 _t = _t->getFirstChild();
1567 dvec=doubleNumberTuple(_t);
1568 _t = _retTree;
1569 _t = __t62;
1570 _t = _t->getNextSibling();
1571#line 190 "MDTreeParser.g"
1572 currBondStamp->overrideType("Quartic", dvec);
1573#line 1574 "MDTreeParser.cpp"
1574 break;
1575 }
1576 case POLYNOMIAL:
1577 {
1578 ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1579 ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1580 match(_t,POLYNOMIAL);
1581 _t = _t->getFirstChild();
1582 dvec=doubleNumberTuple(_t);
1583 _t = _retTree;
1584 _t = __t63;
1585 _t = _t->getNextSibling();
1586#line 191 "MDTreeParser.g"
1587 currBondStamp->overrideType("Polynomial", dvec);
1588#line 1589 "MDTreeParser.cpp"
1589 break;
1590 }
1591 case MORSE:
1592 {
1593 ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
1594 ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST_in = _t;
1595 match(_t,MORSE);
1596 _t = _t->getFirstChild();
1597 dvec=doubleNumberTuple(_t);
1598 _t = _retTree;
1599 _t = __t64;
1600 _t = _t->getNextSibling();
1601#line 192 "MDTreeParser.g"
1602 currBondStamp->overrideType("Morse", dvec);
1603#line 1604 "MDTreeParser.cpp"
1604 break;
1605 }
1606 default:
1607 {
1608 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1609 }
1610 }
1611 }
1612 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1613 reportError(ex);
1614 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1615 _t = _t->getNextSibling();
1616 }
1617 _retTree = _t;
1618}
1619
1620vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1621#line 368 "MDTreeParser.g"
1622 vector<int> ivec;
1623#line 1624 "MDTreeParser.cpp"
1624 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1625#line 368 "MDTreeParser.g"
1626
1627 int ival;
1628
1629#line 1630 "MDTreeParser.cpp"
1630
1631 try { // for error handling
1632 { // ( ... )+
1633 int _cnt133=0;
1634 for (;;) {
1635 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1636 _t = ASTNULL;
1637 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1638 ival=intConst(_t);
1639 _t = _retTree;
1640#line 372 "MDTreeParser.g"
1641 ivec.push_back(ival);
1642#line 1643 "MDTreeParser.cpp"
1643 }
1644 else {
1645 if ( _cnt133>=1 ) { goto _loop133; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1646 }
1647
1648 _cnt133++;
1649 }
1650 _loop133:;
1651 } // ( ... )+
1652 }
1653 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1654 reportError(ex);
1655 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1656 _t = _t->getNextSibling();
1657 }
1658 _retTree = _t;
1659 return ivec;
1660}
1661
1662void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1663 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1664#line 205 "MDTreeParser.g"
1665
1666 vector<int> ivec;
1667 vector<RealType> dvec;
1668 BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1669
1670#line 1671 "MDTreeParser.cpp"
1671
1672 try { // for error handling
1673 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1674 _t = ASTNULL;
1675 switch ( _t->getType()) {
1676 case ASSIGNEQUAL:
1677 {
1678 assignment(_t);
1679 _t = _retTree;
1680 break;
1681 }
1682 case MEMBERS:
1683 {
1684 ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1685 ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST_in = _t;
1686 match(_t,MEMBERS);
1687 _t = _t->getFirstChild();
1688 ivec=inttuple(_t);
1689 _t = _retTree;
1690 _t = __t70;
1691 _t = _t->getNextSibling();
1692#line 212 "MDTreeParser.g"
1693 currBendStamp->setMembers(ivec);
1694#line 1695 "MDTreeParser.cpp"
1695 break;
1696 }
1697 case HARMONIC:
1698 {
1699 ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1700 ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST_in = _t;
1701 match(_t,HARMONIC);
1702 _t = _t->getFirstChild();
1703 dvec=doubleNumberTuple(_t);
1704 _t = _retTree;
1705 _t = __t71;
1706 _t = _t->getNextSibling();
1707#line 213 "MDTreeParser.g"
1708 currBendStamp->overrideType("Harmonic", dvec);
1709#line 1710 "MDTreeParser.cpp"
1710 break;
1711 }
1712 case GHOSTBEND:
1713 {
1714 ANTLR_USE_NAMESPACE(antlr)RefAST __t72 = _t;
1715 ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST_in = _t;
1716 match(_t,GHOSTBEND);
1717 _t = _t->getFirstChild();
1718 dvec=doubleNumberTuple(_t);
1719 _t = _retTree;
1720 _t = __t72;
1721 _t = _t->getNextSibling();
1722#line 214 "MDTreeParser.g"
1723 currBendStamp->overrideType("GhostBend", dvec);
1724#line 1725 "MDTreeParser.cpp"
1725 break;
1726 }
1727 case UREYBRADLEY:
1728 {
1729 ANTLR_USE_NAMESPACE(antlr)RefAST __t73 = _t;
1730 ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST_in = _t;
1731 match(_t,UREYBRADLEY);
1732 _t = _t->getFirstChild();
1733 dvec=doubleNumberTuple(_t);
1734 _t = _retTree;
1735 _t = __t73;
1736 _t = _t->getNextSibling();
1737#line 215 "MDTreeParser.g"
1738 currBendStamp->overrideType("UreyBradley", dvec);
1739#line 1740 "MDTreeParser.cpp"
1740 break;
1741 }
1742 case CUBIC:
1743 {
1744 ANTLR_USE_NAMESPACE(antlr)RefAST __t74 = _t;
1745 ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST_in = _t;
1746 match(_t,CUBIC);
1747 _t = _t->getFirstChild();
1748 dvec=doubleNumberTuple(_t);
1749 _t = _retTree;
1750 _t = __t74;
1751 _t = _t->getNextSibling();
1752#line 216 "MDTreeParser.g"
1753 currBendStamp->overrideType("Cubic", dvec);
1754#line 1755 "MDTreeParser.cpp"
1755 break;
1756 }
1757 case QUARTIC:
1758 {
1759 ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1760 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST_in = _t;
1761 match(_t,QUARTIC);
1762 _t = _t->getFirstChild();
1763 dvec=doubleNumberTuple(_t);
1764 _t = _retTree;
1765 _t = __t75;
1766 _t = _t->getNextSibling();
1767#line 217 "MDTreeParser.g"
1768 currBendStamp->overrideType("Quartic", dvec);
1769#line 1770 "MDTreeParser.cpp"
1770 break;
1771 }
1772 case POLYNOMIAL:
1773 {
1774 ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1775 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST_in = _t;
1776 match(_t,POLYNOMIAL);
1777 _t = _t->getFirstChild();
1778 dvec=doubleNumberTuple(_t);
1779 _t = _retTree;
1780 _t = __t76;
1781 _t = _t->getNextSibling();
1782#line 218 "MDTreeParser.g"
1783 currBendStamp->overrideType("Polynomial", dvec);
1784#line 1785 "MDTreeParser.cpp"
1785 break;
1786 }
1787 case COSINE:
1788 {
1789 ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1790 ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST_in = _t;
1791 match(_t,COSINE);
1792 _t = _t->getFirstChild();
1793 dvec=doubleNumberTuple(_t);
1794 _t = _retTree;
1795 _t = __t77;
1796 _t = _t->getNextSibling();
1797#line 219 "MDTreeParser.g"
1798 currBendStamp->overrideType("Cosine", dvec);
1799#line 1800 "MDTreeParser.cpp"
1800 break;
1801 }
1802 default:
1803 {
1804 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1805 }
1806 }
1807 }
1808 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1809 reportError(ex);
1810 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1811 _t = _t->getNextSibling();
1812 }
1813 _retTree = _t;
1814}
1815
1816void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1817 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1818#line 232 "MDTreeParser.g"
1819
1820 vector<int> ivec;
1821 vector<RealType> dvec;
1822 TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1823
1824#line 1825 "MDTreeParser.cpp"
1825
1826 try { // for error handling
1827 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1828 _t = ASTNULL;
1829 switch ( _t->getType()) {
1830 case ASSIGNEQUAL:
1831 {
1832 assignment(_t);
1833 _t = _retTree;
1834 break;
1835 }
1836 case MEMBERS:
1837 {
1838 ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1839 ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST_in = _t;
1840 match(_t,MEMBERS);
1841 _t = _t->getFirstChild();
1842 ivec=inttuple(_t);
1843 _t = _retTree;
1844 _t = __t83;
1845 _t = _t->getNextSibling();
1846#line 239 "MDTreeParser.g"
1847 currTorsionStamp->setMembers(ivec);
1848#line 1849 "MDTreeParser.cpp"
1849 break;
1850 }
1851 case GHOSTTORSION:
1852 {
1853 ANTLR_USE_NAMESPACE(antlr)RefAST __t84 = _t;
1854 ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST_in = _t;
1855 match(_t,GHOSTTORSION);
1856 _t = _t->getFirstChild();
1857 dvec=doubleNumberTuple(_t);
1858 _t = _retTree;
1859 _t = __t84;
1860 _t = _t->getNextSibling();
1861#line 240 "MDTreeParser.g"
1862 currTorsionStamp->overrideType("GhostTorsion", dvec);
1863#line 1864 "MDTreeParser.cpp"
1864 break;
1865 }
1866 case CUBIC:
1867 {
1868 ANTLR_USE_NAMESPACE(antlr)RefAST __t85 = _t;
1869 ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST_in = _t;
1870 match(_t,CUBIC);
1871 _t = _t->getFirstChild();
1872 dvec=doubleNumberTuple(_t);
1873 _t = _retTree;
1874 _t = __t85;
1875 _t = _t->getNextSibling();
1876#line 241 "MDTreeParser.g"
1877 currTorsionStamp->overrideType("Cubic", dvec);
1878#line 1879 "MDTreeParser.cpp"
1879 break;
1880 }
1881 case QUARTIC:
1882 {
1883 ANTLR_USE_NAMESPACE(antlr)RefAST __t86 = _t;
1884 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST_in = _t;
1885 match(_t,QUARTIC);
1886 _t = _t->getFirstChild();
1887 dvec=doubleNumberTuple(_t);
1888 _t = _retTree;
1889 _t = __t86;
1890 _t = _t->getNextSibling();
1891#line 242 "MDTreeParser.g"
1892 currTorsionStamp->overrideType("Quartic", dvec);
1893#line 1894 "MDTreeParser.cpp"
1894 break;
1895 }
1896 case POLYNOMIAL:
1897 {
1898 ANTLR_USE_NAMESPACE(antlr)RefAST __t87 = _t;
1899 ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST_in = _t;
1900 match(_t,POLYNOMIAL);
1901 _t = _t->getFirstChild();
1902 dvec=doubleNumberTuple(_t);
1903 _t = _retTree;
1904 _t = __t87;
1905 _t = _t->getNextSibling();
1906#line 243 "MDTreeParser.g"
1907 currTorsionStamp->overrideType("Polynomial", dvec);
1908#line 1909 "MDTreeParser.cpp"
1909 break;
1910 }
1911 case CHARMM:
1912 {
1913 ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1914 ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST_in = _t;
1915 match(_t,CHARMM);
1916 _t = _t->getFirstChild();
1917 dvec=doubleNumberTuple(_t);
1918 _t = _retTree;
1919 _t = __t88;
1920 _t = _t->getNextSibling();
1921#line 244 "MDTreeParser.g"
1922 currTorsionStamp->overrideType("Charmm", dvec);
1923#line 1924 "MDTreeParser.cpp"
1924 break;
1925 }
1926 case OPLS:
1927 {
1928 ANTLR_USE_NAMESPACE(antlr)RefAST __t89 = _t;
1929 ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST_in = _t;
1930 match(_t,OPLS);
1931 _t = _t->getFirstChild();
1932 dvec=doubleNumberTuple(_t);
1933 _t = _retTree;
1934 _t = __t89;
1935 _t = _t->getNextSibling();
1936#line 245 "MDTreeParser.g"
1937 currTorsionStamp->overrideType("Opls", dvec);
1938#line 1939 "MDTreeParser.cpp"
1939 break;
1940 }
1941 case TRAPPE:
1942 {
1943 ANTLR_USE_NAMESPACE(antlr)RefAST __t90 = _t;
1944 ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST_in = _t;
1945 match(_t,TRAPPE);
1946 _t = _t->getFirstChild();
1947 dvec=doubleNumberTuple(_t);
1948 _t = _retTree;
1949 _t = __t90;
1950 _t = _t->getNextSibling();
1951#line 246 "MDTreeParser.g"
1952 currTorsionStamp->overrideType("Trappe", dvec);
1953#line 1954 "MDTreeParser.cpp"
1954 break;
1955 }
1956 case HARMONIC:
1957 {
1958 ANTLR_USE_NAMESPACE(antlr)RefAST __t91 = _t;
1959 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST_in = _t;
1960 match(_t,HARMONIC);
1961 _t = _t->getFirstChild();
1962 dvec=doubleNumberTuple(_t);
1963 _t = _retTree;
1964 _t = __t91;
1965 _t = _t->getNextSibling();
1966#line 247 "MDTreeParser.g"
1967 currTorsionStamp->overrideType("Harmonic", dvec);
1968#line 1969 "MDTreeParser.cpp"
1969 break;
1970 }
1971 default:
1972 {
1973 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1974 }
1975 }
1976 }
1977 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1978 reportError(ex);
1979 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1980 _t = _t->getNextSibling();
1981 }
1982 _retTree = _t;
1983}
1984
1985void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1986 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1987#line 261 "MDTreeParser.g"
1988
1989 int icent;
1990 vector<int> ivec;
1991 vector<RealType> dvec;
1992 InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1993
1994#line 1995 "MDTreeParser.cpp"
1995
1996 try { // for error handling
1997 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1998 _t = ASTNULL;
1999 switch ( _t->getType()) {
2000 case ASSIGNEQUAL:
2001 {
2002 assignment(_t);
2003 _t = _retTree;
2004 break;
2005 }
2006 case CENTER:
2007 {
2008 ANTLR_USE_NAMESPACE(antlr)RefAST __t97 = _t;
2009 ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST_in = _t;
2010 match(_t,CENTER);
2011 _t = _t->getFirstChild();
2012 icent=intConst(_t);
2013 _t = _retTree;
2014 _t = __t97;
2015 _t = _t->getNextSibling();
2016#line 269 "MDTreeParser.g"
2017 currInversionStamp->setCenter(icent);
2018#line 2019 "MDTreeParser.cpp"
2019 break;
2020 }
2021 case SATELLITES:
2022 {
2023 ANTLR_USE_NAMESPACE(antlr)RefAST __t98 = _t;
2024 ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST_in = _t;
2025 match(_t,SATELLITES);
2026 _t = _t->getFirstChild();
2027 ivec=inttuple(_t);
2028 _t = _retTree;
2029 _t = __t98;
2030 _t = _t->getNextSibling();
2031#line 270 "MDTreeParser.g"
2032 currInversionStamp->setSatellites(ivec);
2033#line 2034 "MDTreeParser.cpp"
2034 break;
2035 }
2036 case AMBERIMPROPER:
2037 {
2038 ANTLR_USE_NAMESPACE(antlr)RefAST __t99 = _t;
2039 ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST_in = _t;
2040 match(_t,AMBERIMPROPER);
2041 _t = _t->getFirstChild();
2042 dvec=doubleNumberTuple(_t);
2043 _t = _retTree;
2044 _t = __t99;
2045 _t = _t->getNextSibling();
2046#line 271 "MDTreeParser.g"
2047 currInversionStamp->overrideType("AmberImproper", dvec);
2048#line 2049 "MDTreeParser.cpp"
2049 break;
2050 }
2051 case IMPROPERCOSINE:
2052 {
2053 ANTLR_USE_NAMESPACE(antlr)RefAST __t100 = _t;
2054 ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST_in = _t;
2055 match(_t,IMPROPERCOSINE);
2056 _t = _t->getFirstChild();
2057 dvec=doubleNumberTuple(_t);
2058 _t = _retTree;
2059 _t = __t100;
2060 _t = _t->getNextSibling();
2061#line 272 "MDTreeParser.g"
2062 currInversionStamp->overrideType("ImproperCosine", dvec);
2063#line 2064 "MDTreeParser.cpp"
2064 break;
2065 }
2066 case HARMONIC:
2067 {
2068 ANTLR_USE_NAMESPACE(antlr)RefAST __t101 = _t;
2069 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST_in = _t;
2070 match(_t,HARMONIC);
2071 _t = _t->getFirstChild();
2072 dvec=doubleNumberTuple(_t);
2073 _t = _retTree;
2074 _t = __t101;
2075 _t = _t->getNextSibling();
2076#line 273 "MDTreeParser.g"
2077 currInversionStamp->overrideType("Harmonic", dvec);
2078#line 2079 "MDTreeParser.cpp"
2079 break;
2080 }
2081 case CENTRALATOMHEIGHT:
2082 {
2083 ANTLR_USE_NAMESPACE(antlr)RefAST __t102 = _t;
2084 ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST_in = _t;
2085 match(_t,CENTRALATOMHEIGHT);
2086 _t = _t->getFirstChild();
2087 dvec=doubleNumberTuple(_t);
2088 _t = _retTree;
2089 _t = __t102;
2090 _t = _t->getNextSibling();
2091#line 274 "MDTreeParser.g"
2092 currInversionStamp->overrideType("CentralAtomHeight", dvec);
2093#line 2094 "MDTreeParser.cpp"
2094 break;
2095 }
2096 case DREIDING:
2097 {
2098 ANTLR_USE_NAMESPACE(antlr)RefAST __t103 = _t;
2099 ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST_in = _t;
2100 match(_t,DREIDING);
2101 _t = _t->getFirstChild();
2102 dvec=doubleNumberTuple(_t);
2103 _t = _retTree;
2104 _t = __t103;
2105 _t = _t->getNextSibling();
2106#line 275 "MDTreeParser.g"
2107 currInversionStamp->overrideType("Dreiding", dvec);
2108#line 2109 "MDTreeParser.cpp"
2109 break;
2110 }
2111 default:
2112 {
2113 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2114 }
2115 }
2116 }
2117 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2118 reportError(ex);
2119 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2120 _t = _t->getNextSibling();
2121 }
2122 _retTree = _t;
2123}
2124
2125void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2126 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2127#line 293 "MDTreeParser.g"
2128
2129 vector<int> ivec;
2130 RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
2131
2132#line 2133 "MDTreeParser.cpp"
2133
2134 try { // for error handling
2135 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2136 _t = ASTNULL;
2137 switch ( _t->getType()) {
2138 case ASSIGNEQUAL:
2139 {
2140 assignment(_t);
2141 _t = _retTree;
2142 break;
2143 }
2144 case MEMBERS:
2145 {
2146 ANTLR_USE_NAMESPACE(antlr)RefAST __t109 = _t;
2147 ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST_in = _t;
2148 match(_t,MEMBERS);
2149 _t = _t->getFirstChild();
2150 ivec=inttuple(_t);
2151 _t = _retTree;
2152 _t = __t109;
2153 _t = _t->getNextSibling();
2154#line 299 "MDTreeParser.g"
2155 currRigidBodyStamp->setMembers(ivec);
2156#line 2157 "MDTreeParser.cpp"
2157 break;
2158 }
2159 default:
2160 {
2161 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2162 }
2163 }
2164 }
2165 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2166 reportError(ex);
2167 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2168 _t = _t->getNextSibling();
2169 }
2170 _retTree = _t;
2171}
2172
2173void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2174 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2175#line 312 "MDTreeParser.g"
2176
2177 vector<int> ivec;
2178 CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
2179
2180#line 2181 "MDTreeParser.cpp"
2181
2182 try { // for error handling
2183 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2184 _t = ASTNULL;
2185 switch ( _t->getType()) {
2186 case ASSIGNEQUAL:
2187 {
2188 assignment(_t);
2189 _t = _retTree;
2190 break;
2191 }
2192 case MEMBERS:
2193 {
2194 ANTLR_USE_NAMESPACE(antlr)RefAST __t115 = _t;
2195 ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST_in = _t;
2196 match(_t,MEMBERS);
2197 _t = _t->getFirstChild();
2198 ivec=inttuple(_t);
2199 _t = _retTree;
2200 _t = __t115;
2201 _t = _t->getNextSibling();
2202#line 318 "MDTreeParser.g"
2203 currCutoffGroupStamp->setMembers(ivec);
2204#line 2205 "MDTreeParser.cpp"
2205 break;
2206 }
2207 default:
2208 {
2209 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2210 }
2211 }
2212 }
2213 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2214 reportError(ex);
2215 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2216 _t = _t->getNextSibling();
2217 }
2218 _retTree = _t;
2219}
2220
2221void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2222 ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2223#line 331 "MDTreeParser.g"
2224
2225 vector<int> ivec;
2226 ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
2227
2228#line 2229 "MDTreeParser.cpp"
2229
2230 try { // for error handling
2231 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2232 _t = ASTNULL;
2233 switch ( _t->getType()) {
2234 case ASSIGNEQUAL:
2235 {
2236 assignment(_t);
2237 _t = _retTree;
2238 break;
2239 }
2240 case MEMBERS:
2241 {
2242 ANTLR_USE_NAMESPACE(antlr)RefAST __t121 = _t;
2243 ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST_in = _t;
2244 match(_t,MEMBERS);
2245 _t = _t->getFirstChild();
2246 ivec=inttuple(_t);
2247 _t = _retTree;
2248 _t = __t121;
2249 _t = _t->getNextSibling();
2250#line 337 "MDTreeParser.g"
2251 currConstraintStamp->setMembers(ivec);
2252#line 2253 "MDTreeParser.cpp"
2253 break;
2254 }
2255 default:
2256 {
2257 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2258 }
2259 }
2260 }
2261 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2262 reportError(ex);
2263 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2264 _t = _t->getNextSibling();
2265 }
2266 _retTree = _t;
2267}
2268
2269void MDTreeParser::nodesstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2270 ANTLR_USE_NAMESPACE(antlr)RefAST nodesstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2271#line 351 "MDTreeParser.g"
2272
2273 vector<int> ivec;
2274 NodesStamp* currNodesStamp = static_cast<NodesStamp*>(blockStack.top());
2275
2276#line 2277 "MDTreeParser.cpp"
2277
2278 try { // for error handling
2279 if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2280 _t = ASTNULL;
2281 switch ( _t->getType()) {
2282 case ASSIGNEQUAL:
2283 {
2284 assignment(_t);
2285 _t = _retTree;
2286 break;
2287 }
2288 case MEMBERS:
2289 {
2290 ANTLR_USE_NAMESPACE(antlr)RefAST __t127 = _t;
2291 ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST_in = _t;
2292 match(_t,MEMBERS);
2293 _t = _t->getFirstChild();
2294 ivec=inttuple(_t);
2295 _t = _retTree;
2296 _t = __t127;
2297 _t = _t->getNextSibling();
2298#line 357 "MDTreeParser.g"
2299 currNodesStamp->setMembers(ivec);
2300#line 2301 "MDTreeParser.cpp"
2301 break;
2302 }
2303 default:
2304 {
2305 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2306 }
2307 }
2308 }
2309 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2310 reportError(ex);
2311 if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2312 _t = _t->getNextSibling();
2313 }
2314 _retTree = _t;
2315}
2316
2317void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
2318{
2319}
2320const char* MDTreeParser::tokenNames[] = {
2321 "<0>",
2322 "EOF",
2323 "<2>",
2324 "NULL_TREE_LOOKAHEAD",
2325 "\"component\"",
2326 "\"molecule\"",
2327 "\"zconstraint\"",
2328 "\"restraint\"",
2329 "\"atom\"",
2330 "\"bond\"",
2331 "\"bend\"",
2332 "\"torsion\"",
2333 "\"inversion\"",
2334 "\"rigidBody\"",
2335 "\"cutoffGroup\"",
2336 "\"constraint\"",
2337 "\"distance\"",
2338 "\"fragment\"",
2339 "\"sequence\"",
2340 "\"members\"",
2341 "\"center\"",
2342 "\"satellites\"",
2343 "\"position\"",
2344 "\"orientation\"",
2345 "\"flucQ\"",
2346 "\"RNEMD\"",
2347 "\"minimizer\"",
2348 "\"Fixed\"",
2349 "\"Harmonic\"",
2350 "\"Cubic\"",
2351 "\"Quartic\"",
2352 "\"Polynomial\"",
2353 "\"Morse\"",
2354 "\"GhostBend\"",
2355 "\"UreyBradley\"",
2356 "\"Cosine\"",
2357 "\"GhostTorsion\"",
2358 "\"Charmm\"",
2359 "\"Opls\"",
2360 "\"Trappe\"",
2361 "\"AmberImproper\"",
2362 "\"ImproperCosine\"",
2363 "\"CentralAtomHeight\"",
2364 "\"Dreiding\"",
2365 "\"charge\"",
2366 "\"nodes\"",
2367 "ENDBLOCK",
2368 "ID",
2369 "ASSIGNEQUAL",
2370 "SEMICOLON",
2371 "StringLiteral",
2372 "LCURLY",
2373 "RCURLY",
2374 "LBRACKET",
2375 "RBRACKET",
2376 "LPAREN",
2377 "RPAREN",
2378 "COMMA",
2379 "NUM_INT",
2380 "NUM_LONG",
2381 "NUM_FLOAT",
2382 "NUM_DOUBLE",
2383 "DOT",
2384 "COLON",
2385 "QUESTIONMARK",
2386 "Whitespace",
2387 "Comment",
2388 "CPPComment",
2389 "a line directive",
2390 "LineDirective",
2391 "Space",
2392 "CharLiteral",
2393 "EndOfLine",
2394 "Escape",
2395 "Vocabulary",
2396 "Digit",
2397 "Decimal",
2398 "HEX_DIGIT",
2399 "EXPONENT",
2400 "FLOAT_SUFFIX",
2401 0
2402};
2403
2404const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 117571824UL, 65536UL, 0UL, 0UL };
2405// "component" "molecule" "zconstraint" "restraint" "fragment" "flucQ"
2406// "RNEMD" "minimizer" ASSIGNEQUAL
2407const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
2408const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 65280UL, 65536UL, 0UL, 0UL };
2409// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2410// "constraint" ASSIGNEQUAL
2411const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
2412const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 65280UL, 73728UL, 0UL, 0UL };
2413// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2414// "constraint" "nodes" ASSIGNEQUAL
2415const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);
2416const unsigned long MDTreeParser::_tokenSet_3_data_[] = { 12582912UL, 69632UL, 0UL, 0UL };
2417// "position" "orientation" "charge" ASSIGNEQUAL
2418const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_3(_tokenSet_3_data_,4);
2419const unsigned long MDTreeParser::_tokenSet_4_data_[] = { 4161273856UL, 65537UL, 0UL, 0UL };
2420// "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse"
2421// ASSIGNEQUAL
2422const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_4(_tokenSet_4_data_,4);
2423const unsigned long MDTreeParser::_tokenSet_5_data_[] = { 4027056128UL, 65550UL, 0UL, 0UL };
2424// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley"
2425// "Cosine" ASSIGNEQUAL
2426const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_5(_tokenSet_5_data_,4);
2427const unsigned long MDTreeParser::_tokenSet_6_data_[] = { 4027056128UL, 65776UL, 0UL, 0UL };
2428// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm"
2429// "Opls" "Trappe" ASSIGNEQUAL
2430const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_6(_tokenSet_6_data_,4);
2431const unsigned long MDTreeParser::_tokenSet_7_data_[] = { 271581184UL, 69376UL, 0UL, 0UL };
2432// "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight"
2433// "Dreiding" ASSIGNEQUAL
2434const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_7(_tokenSet_7_data_,4);
2435
2436
OpenMD::RigidBodyStamp
Definition RigidBodyStamp.hpp:52
antlr::AST::getNextSibling
virtual RefAST getNextSibling() const =0
Get the next sibling in line after this one.
OpenMD::INVERSION
@ INVERSION
Inversions.
Definition SelectionSet.hpp:65
OpenMD::TORSION
@ TORSION
Torsions.
Definition SelectionSet.hpp:64
OpenMD::BEND
@ BEND
Bends.
Definition SelectionSet.hpp:63
OpenMD::BOND
@ BOND
Bonds.
Definition SelectionSet.hpp:62
OpenMD::MOLECULE
@ MOLECULE
Molecules.
Definition SelectionSet.hpp:66