OpenMD 3.0
Molecular Dynamics in the Open
Loading...
Searching...
No Matches
MDParser.cpp
1/* $ANTLR 2.7.7 (2006-11-01): "MDParser.g" -> "MDParser.cpp"$ */
2#include "MDParser.hpp"
3#include <antlr/NoViableAltException.hpp>
4#include <antlr/SemanticException.hpp>
5#include <antlr/ASTFactory.hpp>
6#line 1 "MDParser.g"
7#line 8 "MDParser.cpp"
8MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
9: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
10{
11}
12
13MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
14: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
15{
16}
17
18MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
19: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
20{
21}
22
23MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
24: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
25{
26}
27
28MDParser::MDParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
29: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
30{
31}
32
33void MDParser::mdfile() {
34 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
35 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
36 ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
37
38 try { // for error handling
39 { // ( ... )*
40 for (;;) {
41 if ((_tokenSet_0.member(LA(1)))) {
42 statement();
43 astFactory->addASTChild( currentAST, returnAST );
44 }
45 else {
46 goto _loop3;
47 }
48
49 }
50 _loop3:;
51 } // ( ... )*
52 mdfile_AST = currentAST.root;
53 }
54 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
55 reportError(ex);
56 recover(ex,_tokenSet_1);
57 }
58 returnAST = mdfile_AST;
59}
60
61void MDParser::statement() {
62 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
63 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
64 ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
65
66 try { // for error handling
67 switch ( LA(1)) {
68 case ID:
69 {
70 assignment();
71 astFactory->addASTChild( currentAST, returnAST );
72 statement_AST = currentAST.root;
73 break;
74 }
75 case COMPONENT:
76 {
77 componentblock();
78 astFactory->addASTChild( currentAST, returnAST );
79 statement_AST = currentAST.root;
80 break;
81 }
82 case MOLECULE:
83 {
84 moleculeblock();
85 astFactory->addASTChild( currentAST, returnAST );
86 statement_AST = currentAST.root;
87 break;
88 }
89 case FRAGMENT:
90 {
91 fragmentblock();
92 astFactory->addASTChild( currentAST, returnAST );
93 statement_AST = currentAST.root;
94 break;
95 }
96 case ZCONSTRAINT:
97 {
98 zconstraintblock();
99 astFactory->addASTChild( currentAST, returnAST );
100 statement_AST = currentAST.root;
101 break;
102 }
103 case RESTRAINT:
104 {
105 restraintblock();
106 astFactory->addASTChild( currentAST, returnAST );
107 statement_AST = currentAST.root;
108 break;
109 }
110 case FLUCQ:
111 {
112 flucqblock();
113 astFactory->addASTChild( currentAST, returnAST );
114 statement_AST = currentAST.root;
115 break;
116 }
117 case RNEMD:
118 {
119 rnemdblock();
120 astFactory->addASTChild( currentAST, returnAST );
121 statement_AST = currentAST.root;
122 break;
123 }
124 case MINIMIZER:
125 {
126 minimizerblock();
127 astFactory->addASTChild( currentAST, returnAST );
128 statement_AST = currentAST.root;
129 break;
130 }
131 default:
132 {
133 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
134 }
135 }
136 }
137 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
138 reportError(ex);
139 recover(ex,_tokenSet_2);
140 }
141 returnAST = statement_AST;
142}
143
144void MDParser::assignment() {
145 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
146 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
147 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
148
149 try { // for error handling
150 ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
151 tmp1_AST = astFactory->create(LT(1));
152 astFactory->addASTChild(currentAST, tmp1_AST);
153 match(ID);
154 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
155 tmp2_AST = astFactory->create(LT(1));
156 astFactory->makeASTRoot(currentAST, tmp2_AST);
157 match(ASSIGNEQUAL);
158 constant();
159 astFactory->addASTChild( currentAST, returnAST );
160 match(SEMICOLON);
161 assignment_AST = currentAST.root;
162 }
163 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
164 reportError(ex);
165 recover(ex,_tokenSet_3);
166 }
167 returnAST = assignment_AST;
168}
169
170void MDParser::componentblock() {
171 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
172 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
173 ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
174
175 try { // for error handling
176 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
177 tmp4_AST = astFactory->create(LT(1));
178 astFactory->makeASTRoot(currentAST, tmp4_AST);
179 match(COMPONENT);
180 match(LCURLY);
181 { // ( ... )*
182 for (;;) {
183 if ((LA(1) == ID)) {
184 assignment();
185 astFactory->addASTChild( currentAST, returnAST );
186 }
187 else {
188 goto _loop9;
189 }
190
191 }
192 _loop9:;
193 } // ( ... )*
194 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
195 tmp6_AST = astFactory->create(LT(1));
196 astFactory->addASTChild(currentAST, tmp6_AST);
197 match(RCURLY);
198#line 98 "MDParser.g"
199 tmp6_AST->setType(ENDBLOCK);
200#line 201 "MDParser.cpp"
201 componentblock_AST = currentAST.root;
202 }
203 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
204 reportError(ex);
205 recover(ex,_tokenSet_2);
206 }
207 returnAST = componentblock_AST;
208}
209
210void MDParser::moleculeblock() {
211 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
212 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
213 ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
214
215 try { // for error handling
216 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
217 tmp7_AST = astFactory->create(LT(1));
218 astFactory->makeASTRoot(currentAST, tmp7_AST);
219 match(MOLECULE);
220 match(LCURLY);
221 { // ( ... )*
222 for (;;) {
223 if ((_tokenSet_4.member(LA(1)))) {
224 moleculestatement();
225 astFactory->addASTChild( currentAST, returnAST );
226 }
227 else {
228 goto _loop27;
229 }
230
231 }
232 _loop27:;
233 } // ( ... )*
234 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
235 tmp9_AST = astFactory->create(LT(1));
236 astFactory->addASTChild(currentAST, tmp9_AST);
237 match(RCURLY);
238#line 116 "MDParser.g"
239 tmp9_AST->setType(ENDBLOCK);
240#line 241 "MDParser.cpp"
241 moleculeblock_AST = currentAST.root;
242 }
243 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
244 reportError(ex);
245 recover(ex,_tokenSet_2);
246 }
247 returnAST = moleculeblock_AST;
248}
249
250void MDParser::fragmentblock() {
251 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
252 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
253 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
254
255 try { // for error handling
256 ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
257 tmp10_AST = astFactory->create(LT(1));
258 astFactory->makeASTRoot(currentAST, tmp10_AST);
259 match(FRAGMENT);
260 match(LCURLY);
261 { // ( ... )*
262 for (;;) {
263 if ((_tokenSet_5.member(LA(1)))) {
264 fragmentstatement();
265 astFactory->addASTChild( currentAST, returnAST );
266 }
267 else {
268 goto _loop69;
269 }
270
271 }
272 _loop69:;
273 } // ( ... )*
274 ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
275 tmp12_AST = astFactory->create(LT(1));
276 astFactory->addASTChild(currentAST, tmp12_AST);
277 match(RCURLY);
278#line 217 "MDParser.g"
279 tmp12_AST->setType(ENDBLOCK);
280#line 281 "MDParser.cpp"
281 fragmentblock_AST = currentAST.root;
282 }
283 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
284 reportError(ex);
285 recover(ex,_tokenSet_2);
286 }
287 returnAST = fragmentblock_AST;
288}
289
290void MDParser::zconstraintblock() {
291 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
292 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
293 ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
294
295 try { // for error handling
296 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
297 tmp13_AST = astFactory->create(LT(1));
298 astFactory->makeASTRoot(currentAST, tmp13_AST);
299 match(ZCONSTRAINT);
300 match(LCURLY);
301 { // ( ... )*
302 for (;;) {
303 if ((LA(1) == ID)) {
304 assignment();
305 astFactory->addASTChild( currentAST, returnAST );
306 }
307 else {
308 goto _loop12;
309 }
310
311 }
312 _loop12:;
313 } // ( ... )*
314 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
315 tmp15_AST = astFactory->create(LT(1));
316 astFactory->addASTChild(currentAST, tmp15_AST);
317 match(RCURLY);
318#line 101 "MDParser.g"
319 tmp15_AST->setType(ENDBLOCK);
320#line 321 "MDParser.cpp"
321 zconstraintblock_AST = currentAST.root;
322 }
323 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
324 reportError(ex);
325 recover(ex,_tokenSet_2);
326 }
327 returnAST = zconstraintblock_AST;
328}
329
330void MDParser::restraintblock() {
331 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
332 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
333 ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
334
335 try { // for error handling
336 ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
337 tmp16_AST = astFactory->create(LT(1));
338 astFactory->makeASTRoot(currentAST, tmp16_AST);
339 match(RESTRAINT);
340 match(LCURLY);
341 { // ( ... )*
342 for (;;) {
343 if ((LA(1) == ID)) {
344 assignment();
345 astFactory->addASTChild( currentAST, returnAST );
346 }
347 else {
348 goto _loop15;
349 }
350
351 }
352 _loop15:;
353 } // ( ... )*
354 ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
355 tmp18_AST = astFactory->create(LT(1));
356 astFactory->addASTChild(currentAST, tmp18_AST);
357 match(RCURLY);
358#line 104 "MDParser.g"
359 tmp18_AST->setType(ENDBLOCK);
360#line 361 "MDParser.cpp"
361 restraintblock_AST = currentAST.root;
362 }
363 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
364 reportError(ex);
365 recover(ex,_tokenSet_2);
366 }
367 returnAST = restraintblock_AST;
368}
369
370void MDParser::flucqblock() {
371 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
372 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
373 ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
374
375 try { // for error handling
376 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
377 tmp19_AST = astFactory->create(LT(1));
378 astFactory->makeASTRoot(currentAST, tmp19_AST);
379 match(FLUCQ);
380 match(LCURLY);
381 { // ( ... )*
382 for (;;) {
383 if ((LA(1) == ID)) {
384 assignment();
385 astFactory->addASTChild( currentAST, returnAST );
386 }
387 else {
388 goto _loop18;
389 }
390
391 }
392 _loop18:;
393 } // ( ... )*
394 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
395 tmp21_AST = astFactory->create(LT(1));
396 astFactory->addASTChild(currentAST, tmp21_AST);
397 match(RCURLY);
398#line 107 "MDParser.g"
399 tmp21_AST->setType(ENDBLOCK);
400#line 401 "MDParser.cpp"
401 flucqblock_AST = currentAST.root;
402 }
403 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
404 reportError(ex);
405 recover(ex,_tokenSet_2);
406 }
407 returnAST = flucqblock_AST;
408}
409
410void MDParser::rnemdblock() {
411 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
412 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
413 ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
414
415 try { // for error handling
416 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
417 tmp22_AST = astFactory->create(LT(1));
418 astFactory->makeASTRoot(currentAST, tmp22_AST);
419 match(RNEMD);
420 match(LCURLY);
421 { // ( ... )*
422 for (;;) {
423 if ((LA(1) == ID)) {
424 assignment();
425 astFactory->addASTChild( currentAST, returnAST );
426 }
427 else {
428 goto _loop21;
429 }
430
431 }
432 _loop21:;
433 } // ( ... )*
434 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
435 tmp24_AST = astFactory->create(LT(1));
436 astFactory->addASTChild(currentAST, tmp24_AST);
437 match(RCURLY);
438#line 110 "MDParser.g"
439 tmp24_AST->setType(ENDBLOCK);
440#line 441 "MDParser.cpp"
441 rnemdblock_AST = currentAST.root;
442 }
443 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
444 reportError(ex);
445 recover(ex,_tokenSet_2);
446 }
447 returnAST = rnemdblock_AST;
448}
449
450void MDParser::minimizerblock() {
451 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
452 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
453 ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
454
455 try { // for error handling
456 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
457 tmp25_AST = astFactory->create(LT(1));
458 astFactory->makeASTRoot(currentAST, tmp25_AST);
459 match(MINIMIZER);
460 match(LCURLY);
461 { // ( ... )*
462 for (;;) {
463 if ((LA(1) == ID)) {
464 assignment();
465 astFactory->addASTChild( currentAST, returnAST );
466 }
467 else {
468 goto _loop24;
469 }
470
471 }
472 _loop24:;
473 } // ( ... )*
474 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
475 tmp27_AST = astFactory->create(LT(1));
476 astFactory->addASTChild(currentAST, tmp27_AST);
477 match(RCURLY);
478#line 113 "MDParser.g"
479 tmp27_AST->setType(ENDBLOCK);
480#line 481 "MDParser.cpp"
481 minimizerblock_AST = currentAST.root;
482 }
483 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
484 reportError(ex);
485 recover(ex,_tokenSet_2);
486 }
487 returnAST = minimizerblock_AST;
488}
489
490void MDParser::constant() {
491 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
492 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
493 ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
494
495 try { // for error handling
496 switch ( LA(1)) {
497 case NUM_INT:
498 case NUM_LONG:
499 {
500 intConst();
501 astFactory->addASTChild( currentAST, returnAST );
502 constant_AST = currentAST.root;
503 break;
504 }
505 case NUM_FLOAT:
506 case NUM_DOUBLE:
507 {
508 floatConst();
509 astFactory->addASTChild( currentAST, returnAST );
510 constant_AST = currentAST.root;
511 break;
512 }
513 case LPAREN:
514 {
515 vectorConst();
516 astFactory->addASTChild( currentAST, returnAST );
517 constant_AST = currentAST.root;
518 break;
519 }
520 case ID:
521 {
522 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
523 tmp28_AST = astFactory->create(LT(1));
524 astFactory->addASTChild(currentAST, tmp28_AST);
525 match(ID);
526 constant_AST = currentAST.root;
527 break;
528 }
529 case StringLiteral:
530 {
531 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
532 tmp29_AST = astFactory->create(LT(1));
533 astFactory->addASTChild(currentAST, tmp29_AST);
534 match(StringLiteral);
535 constant_AST = currentAST.root;
536 break;
537 }
538 default:
539 {
540 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
541 }
542 }
543 }
544 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
545 reportError(ex);
546 recover(ex,_tokenSet_6);
547 }
548 returnAST = constant_AST;
549}
550
551void MDParser::intConst() {
552 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
553 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
554 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
555
556 try { // for error handling
557 switch ( LA(1)) {
558 case NUM_INT:
559 {
560 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
561 tmp30_AST = astFactory->create(LT(1));
562 astFactory->addASTChild(currentAST, tmp30_AST);
563 match(NUM_INT);
564 intConst_AST = currentAST.root;
565 break;
566 }
567 case NUM_LONG:
568 {
569 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
570 tmp31_AST = astFactory->create(LT(1));
571 astFactory->addASTChild(currentAST, tmp31_AST);
572 match(NUM_LONG);
573 intConst_AST = currentAST.root;
574 break;
575 }
576 default:
577 {
578 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
579 }
580 }
581 }
582 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
583 reportError(ex);
584 recover(ex,_tokenSet_7);
585 }
586 returnAST = intConst_AST;
587}
588
589void MDParser::floatConst() {
590 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
591 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
592 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
593
594 try { // for error handling
595 switch ( LA(1)) {
596 case NUM_FLOAT:
597 {
598 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 tmp32_AST = astFactory->create(LT(1));
600 astFactory->addASTChild(currentAST, tmp32_AST);
601 match(NUM_FLOAT);
602 floatConst_AST = currentAST.root;
603 break;
604 }
605 case NUM_DOUBLE:
606 {
607 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
608 tmp33_AST = astFactory->create(LT(1));
609 astFactory->addASTChild(currentAST, tmp33_AST);
610 match(NUM_DOUBLE);
611 floatConst_AST = currentAST.root;
612 break;
613 }
614 default:
615 {
616 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
617 }
618 }
619 }
620 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
621 reportError(ex);
622 recover(ex,_tokenSet_8);
623 }
624 returnAST = floatConst_AST;
625}
626
627void MDParser::vectorConst() {
628 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
629 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
630 ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
631
632 try { // for error handling
633 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
634 tmp34_AST = astFactory->create(LT(1));
635 astFactory->makeASTRoot(currentAST, tmp34_AST);
636 match(LPAREN);
637 doubleNumberTuple();
638 astFactory->addASTChild( currentAST, returnAST );
639 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
640 tmp35_AST = astFactory->create(LT(1));
641 astFactory->addASTChild(currentAST, tmp35_AST);
642 match(RPAREN);
643 vectorConst_AST = currentAST.root;
644 }
645 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
646 reportError(ex);
647 recover(ex,_tokenSet_6);
648 }
649 returnAST = vectorConst_AST;
650}
651
652void MDParser::moleculestatement() {
653 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
654 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
655 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
656
657 try { // for error handling
658 switch ( LA(1)) {
659 case ID:
660 {
661 assignment();
662 astFactory->addASTChild( currentAST, returnAST );
663 moleculestatement_AST = currentAST.root;
664 break;
665 }
666 case ATOM:
667 {
668 atomblock();
669 astFactory->addASTChild( currentAST, returnAST );
670 moleculestatement_AST = currentAST.root;
671 break;
672 }
673 case BOND:
674 {
675 bondblock();
676 astFactory->addASTChild( currentAST, returnAST );
677 moleculestatement_AST = currentAST.root;
678 break;
679 }
680 case BEND:
681 {
682 bendblock();
683 astFactory->addASTChild( currentAST, returnAST );
684 moleculestatement_AST = currentAST.root;
685 break;
686 }
687 case TORSION:
688 {
689 torsionblock();
690 astFactory->addASTChild( currentAST, returnAST );
691 moleculestatement_AST = currentAST.root;
692 break;
693 }
694 case INVERSION:
695 {
696 inversionblock();
697 astFactory->addASTChild( currentAST, returnAST );
698 moleculestatement_AST = currentAST.root;
699 break;
700 }
701 case RIGIDBODY:
702 {
703 rigidbodyblock();
704 astFactory->addASTChild( currentAST, returnAST );
705 moleculestatement_AST = currentAST.root;
706 break;
707 }
708 case CUTOFFGROUP:
709 {
710 cutoffgroupblock();
711 astFactory->addASTChild( currentAST, returnAST );
712 moleculestatement_AST = currentAST.root;
713 break;
714 }
715 case CONSTRAINT:
716 {
717 constraintblock();
718 astFactory->addASTChild( currentAST, returnAST );
719 moleculestatement_AST = currentAST.root;
720 break;
721 }
722 case SEQUENCE:
723 {
724 sequencestring();
725 astFactory->addASTChild( currentAST, returnAST );
726 moleculestatement_AST = currentAST.root;
727 break;
728 }
729 default:
730 {
731 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
732 }
733 }
734 }
735 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
736 reportError(ex);
737 recover(ex,_tokenSet_9);
738 }
739 returnAST = moleculestatement_AST;
740}
741
742void MDParser::atomblock() {
743 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
744 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
745 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
746
747 try { // for error handling
748 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
749 tmp36_AST = astFactory->create(LT(1));
750 astFactory->makeASTRoot(currentAST, tmp36_AST);
751 match(ATOM);
752 match(LBRACKET);
753 intConst();
754 astFactory->addASTChild( currentAST, returnAST );
755 match(RBRACKET);
756 match(LCURLY);
757 { // ( ... )*
758 for (;;) {
759 if ((_tokenSet_10.member(LA(1)))) {
760 atomstatement();
761 astFactory->addASTChild( currentAST, returnAST );
762 }
763 else {
764 goto _loop31;
765 }
766
767 }
768 _loop31:;
769 } // ( ... )*
770 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
771 tmp40_AST = astFactory->create(LT(1));
772 astFactory->addASTChild(currentAST, tmp40_AST);
773 match(RCURLY);
774#line 131 "MDParser.g"
775 tmp40_AST->setType(ENDBLOCK);
776#line 777 "MDParser.cpp"
777 atomblock_AST = currentAST.root;
778 }
779 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
780 reportError(ex);
781 recover(ex,_tokenSet_11);
782 }
783 returnAST = atomblock_AST;
784}
785
786void MDParser::bondblock() {
787 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
788 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
789 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
790
791 try { // for error handling
792 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
793 tmp41_AST = astFactory->create(LT(1));
794 astFactory->makeASTRoot(currentAST, tmp41_AST);
795 match(BOND);
796 {
797 switch ( LA(1)) {
798 case LBRACKET:
799 {
800 match(LBRACKET);
801 intConst();
802 match(RBRACKET);
803 break;
804 }
805 case LCURLY:
806 {
807 break;
808 }
809 default:
810 {
811 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
812 }
813 }
814 }
815 match(LCURLY);
816 { // ( ... )*
817 for (;;) {
818 if ((_tokenSet_12.member(LA(1)))) {
819 bondstatement();
820 astFactory->addASTChild( currentAST, returnAST );
821 }
822 else {
823 goto _loop36;
824 }
825
826 }
827 _loop36:;
828 } // ( ... )*
829 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
830 tmp45_AST = astFactory->create(LT(1));
831 astFactory->addASTChild(currentAST, tmp45_AST);
832 match(RCURLY);
833#line 141 "MDParser.g"
834 tmp45_AST->setType(ENDBLOCK);
835#line 836 "MDParser.cpp"
836 bondblock_AST = currentAST.root;
837 }
838 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
839 reportError(ex);
840 recover(ex,_tokenSet_11);
841 }
842 returnAST = bondblock_AST;
843}
844
845void MDParser::bendblock() {
846 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
847 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
848 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
849
850 try { // for error handling
851 ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
852 tmp46_AST = astFactory->create(LT(1));
853 astFactory->makeASTRoot(currentAST, tmp46_AST);
854 match(BEND);
855 {
856 switch ( LA(1)) {
857 case LBRACKET:
858 {
859 match(LBRACKET);
860 intConst();
861 match(RBRACKET);
862 break;
863 }
864 case LCURLY:
865 {
866 break;
867 }
868 default:
869 {
870 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
871 }
872 }
873 }
874 match(LCURLY);
875 { // ( ... )*
876 for (;;) {
877 if ((_tokenSet_13.member(LA(1)))) {
878 bendstatement();
879 astFactory->addASTChild( currentAST, returnAST );
880 }
881 else {
882 goto _loop41;
883 }
884
885 }
886 _loop41:;
887 } // ( ... )*
888 ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
889 tmp50_AST = astFactory->create(LT(1));
890 astFactory->addASTChild(currentAST, tmp50_AST);
891 match(RCURLY);
892#line 154 "MDParser.g"
893 tmp50_AST->setType(ENDBLOCK);
894#line 895 "MDParser.cpp"
895 bendblock_AST = currentAST.root;
896 }
897 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
898 reportError(ex);
899 recover(ex,_tokenSet_11);
900 }
901 returnAST = bendblock_AST;
902}
903
904void MDParser::torsionblock() {
905 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
906 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
907 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
908
909 try { // for error handling
910 ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
911 tmp51_AST = astFactory->create(LT(1));
912 astFactory->makeASTRoot(currentAST, tmp51_AST);
913 match(TORSION);
914 {
915 switch ( LA(1)) {
916 case LBRACKET:
917 {
918 match(LBRACKET);
919 intConst();
920 match(RBRACKET);
921 break;
922 }
923 case LCURLY:
924 {
925 break;
926 }
927 default:
928 {
929 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
930 }
931 }
932 }
933 match(LCURLY);
934 { // ( ... )*
935 for (;;) {
936 if ((_tokenSet_14.member(LA(1)))) {
937 torsionstatement();
938 astFactory->addASTChild( currentAST, returnAST );
939 }
940 else {
941 goto _loop46;
942 }
943
944 }
945 _loop46:;
946 } // ( ... )*
947 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
948 tmp55_AST = astFactory->create(LT(1));
949 astFactory->addASTChild(currentAST, tmp55_AST);
950 match(RCURLY);
951#line 168 "MDParser.g"
952 tmp55_AST->setType(ENDBLOCK);
953#line 954 "MDParser.cpp"
954 torsionblock_AST = currentAST.root;
955 }
956 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
957 reportError(ex);
958 recover(ex,_tokenSet_11);
959 }
960 returnAST = torsionblock_AST;
961}
962
963void MDParser::inversionblock() {
964 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
965 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
966 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
967
968 try { // for error handling
969 ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
970 tmp56_AST = astFactory->create(LT(1));
971 astFactory->makeASTRoot(currentAST, tmp56_AST);
972 match(INVERSION);
973 {
974 switch ( LA(1)) {
975 case LBRACKET:
976 {
977 match(LBRACKET);
978 intConst();
979 match(RBRACKET);
980 break;
981 }
982 case LCURLY:
983 {
984 break;
985 }
986 default:
987 {
988 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
989 }
990 }
991 }
992 match(LCURLY);
993 { // ( ... )*
994 for (;;) {
995 if ((_tokenSet_15.member(LA(1)))) {
996 inversionstatement();
997 astFactory->addASTChild( currentAST, returnAST );
998 }
999 else {
1000 goto _loop51;
1001 }
1002
1003 }
1004 _loop51:;
1005 } // ( ... )*
1006 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1007 tmp60_AST = astFactory->create(LT(1));
1008 astFactory->addASTChild(currentAST, tmp60_AST);
1009 match(RCURLY);
1010#line 183 "MDParser.g"
1011 tmp60_AST->setType(ENDBLOCK);
1012#line 1013 "MDParser.cpp"
1013 inversionblock_AST = currentAST.root;
1014 }
1015 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1016 reportError(ex);
1017 recover(ex,_tokenSet_11);
1018 }
1019 returnAST = inversionblock_AST;
1020}
1021
1022void MDParser::rigidbodyblock() {
1023 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1025 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026
1027 try { // for error handling
1028 ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1029 tmp61_AST = astFactory->create(LT(1));
1030 astFactory->makeASTRoot(currentAST, tmp61_AST);
1031 match(RIGIDBODY);
1032 match(LBRACKET);
1033 intConst();
1034 astFactory->addASTChild( currentAST, returnAST );
1035 match(RBRACKET);
1036 match(LCURLY);
1037 { // ( ... )*
1038 for (;;) {
1039 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1040 rigidbodystatement();
1041 astFactory->addASTChild( currentAST, returnAST );
1042 }
1043 else {
1044 goto _loop55;
1045 }
1046
1047 }
1048 _loop55:;
1049 } // ( ... )*
1050 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1051 tmp65_AST = astFactory->create(LT(1));
1052 astFactory->addASTChild(currentAST, tmp65_AST);
1053 match(RCURLY);
1054#line 196 "MDParser.g"
1055 tmp65_AST->setType(ENDBLOCK);
1056#line 1057 "MDParser.cpp"
1057 rigidbodyblock_AST = currentAST.root;
1058 }
1059 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1060 reportError(ex);
1061 recover(ex,_tokenSet_11);
1062 }
1063 returnAST = rigidbodyblock_AST;
1064}
1065
1066void MDParser::cutoffgroupblock() {
1067 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1068 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1069 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070
1071 try { // for error handling
1072 ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1073 tmp66_AST = astFactory->create(LT(1));
1074 astFactory->makeASTRoot(currentAST, tmp66_AST);
1075 match(CUTOFFGROUP);
1076 {
1077 switch ( LA(1)) {
1078 case LBRACKET:
1079 {
1080 match(LBRACKET);
1081 intConst();
1082 match(RBRACKET);
1083 break;
1084 }
1085 case LCURLY:
1086 {
1087 break;
1088 }
1089 default:
1090 {
1091 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1092 }
1093 }
1094 }
1095 match(LCURLY);
1096 { // ( ... )*
1097 for (;;) {
1098 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1099 cutoffgroupstatement();
1100 astFactory->addASTChild( currentAST, returnAST );
1101 }
1102 else {
1103 goto _loop60;
1104 }
1105
1106 }
1107 _loop60:;
1108 } // ( ... )*
1109 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1110 tmp70_AST = astFactory->create(LT(1));
1111 astFactory->addASTChild(currentAST, tmp70_AST);
1112 match(RCURLY);
1113#line 203 "MDParser.g"
1114 tmp70_AST->setType(ENDBLOCK);
1115#line 1116 "MDParser.cpp"
1116 cutoffgroupblock_AST = currentAST.root;
1117 }
1118 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1119 reportError(ex);
1120 recover(ex,_tokenSet_11);
1121 }
1122 returnAST = cutoffgroupblock_AST;
1123}
1124
1125void MDParser::constraintblock() {
1126 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1127 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1128 ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1129
1130 try { // for error handling
1131 ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1132 tmp71_AST = astFactory->create(LT(1));
1133 astFactory->makeASTRoot(currentAST, tmp71_AST);
1134 match(CONSTRAINT);
1135 {
1136 switch ( LA(1)) {
1137 case LBRACKET:
1138 {
1139 match(LBRACKET);
1140 intConst();
1141 match(RBRACKET);
1142 break;
1143 }
1144 case LCURLY:
1145 {
1146 break;
1147 }
1148 default:
1149 {
1150 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1151 }
1152 }
1153 }
1154 match(LCURLY);
1155 { // ( ... )*
1156 for (;;) {
1157 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1158 constraintstatement();
1159 astFactory->addASTChild( currentAST, returnAST );
1160 }
1161 else {
1162 goto _loop74;
1163 }
1164
1165 }
1166 _loop74:;
1167 } // ( ... )*
1168 ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1169 tmp75_AST = astFactory->create(LT(1));
1170 astFactory->addASTChild(currentAST, tmp75_AST);
1171 match(RCURLY);
1172#line 232 "MDParser.g"
1173 tmp75_AST->setType(ENDBLOCK);
1174#line 1175 "MDParser.cpp"
1175 constraintblock_AST = currentAST.root;
1176 }
1177 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1178 reportError(ex);
1179 recover(ex,_tokenSet_11);
1180 }
1181 returnAST = constraintblock_AST;
1182}
1183
1184void MDParser::sequencestring() {
1185 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1186 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1187 ANTLR_USE_NAMESPACE(antlr)RefAST sequencestring_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1188
1189 try { // for error handling
1190 ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1191 tmp76_AST = astFactory->create(LT(1));
1192 astFactory->addASTChild(currentAST, tmp76_AST);
1193 match(SEQUENCE);
1194 ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1195 tmp77_AST = astFactory->create(LT(1));
1196 astFactory->makeASTRoot(currentAST, tmp77_AST);
1197 match(ASSIGNEQUAL);
1198 constant();
1199 astFactory->addASTChild( currentAST, returnAST );
1200 match(SEMICOLON);
1201 sequencestring_AST = currentAST.root;
1202 }
1203 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1204 reportError(ex);
1205 recover(ex,_tokenSet_9);
1206 }
1207 returnAST = sequencestring_AST;
1208}
1209
1210void MDParser::atomstatement() {
1211 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1212 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1213 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1214
1215 try { // for error handling
1216 switch ( LA(1)) {
1217 case ID:
1218 {
1219 assignment();
1220 astFactory->addASTChild( currentAST, returnAST );
1221 atomstatement_AST = currentAST.root;
1222 break;
1223 }
1224 case POSITION:
1225 {
1226 ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1227 tmp79_AST = astFactory->create(LT(1));
1228 astFactory->makeASTRoot(currentAST, tmp79_AST);
1229 match(POSITION);
1230 match(LPAREN);
1231 doubleNumberTuple();
1232 astFactory->addASTChild( currentAST, returnAST );
1233 match(RPAREN);
1234 match(SEMICOLON);
1235 atomstatement_AST = currentAST.root;
1236 break;
1237 }
1238 case ORIENTATION:
1239 {
1240 ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1241 tmp83_AST = astFactory->create(LT(1));
1242 astFactory->makeASTRoot(currentAST, tmp83_AST);
1243 match(ORIENTATION);
1244 match(LPAREN);
1245 doubleNumberTuple();
1246 astFactory->addASTChild( currentAST, returnAST );
1247 match(RPAREN);
1248 match(SEMICOLON);
1249 atomstatement_AST = currentAST.root;
1250 break;
1251 }
1252 case CHARGE:
1253 {
1254 ANTLR_USE_NAMESPACE(antlr)RefAST tmp87_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1255 tmp87_AST = astFactory->create(LT(1));
1256 astFactory->makeASTRoot(currentAST, tmp87_AST);
1257 match(CHARGE);
1258 match(LPAREN);
1259 floatConst();
1260 astFactory->addASTChild( currentAST, returnAST );
1261 match(RPAREN);
1262 match(SEMICOLON);
1263 atomstatement_AST = currentAST.root;
1264 break;
1265 }
1266 default:
1267 {
1268 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1269 }
1270 }
1271 }
1272 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1273 reportError(ex);
1274 recover(ex,_tokenSet_16);
1275 }
1276 returnAST = atomstatement_AST;
1277}
1278
1279void MDParser::doubleNumberTuple() {
1280 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1281 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1282 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1283
1284 try { // for error handling
1285 doubleNumber();
1286 astFactory->addASTChild( currentAST, returnAST );
1287 { // ( ... )*
1288 for (;;) {
1289 if ((LA(1) == COMMA)) {
1290 match(COMMA);
1291 doubleNumber();
1292 astFactory->addASTChild( currentAST, returnAST );
1293 }
1294 else {
1295 goto _loop79;
1296 }
1297
1298 }
1299 _loop79:;
1300 } // ( ... )*
1301 doubleNumberTuple_AST = currentAST.root;
1302 }
1303 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1304 reportError(ex);
1305 recover(ex,_tokenSet_17);
1306 }
1307 returnAST = doubleNumberTuple_AST;
1308}
1309
1310void MDParser::bondstatement() {
1311 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1312 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1313 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1314
1315 try { // for error handling
1316 switch ( LA(1)) {
1317 case ID:
1318 {
1319 assignment();
1320 astFactory->addASTChild( currentAST, returnAST );
1321 bondstatement_AST = currentAST.root;
1322 break;
1323 }
1324 case MEMBERS:
1325 {
1326 ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1327 tmp92_AST = astFactory->create(LT(1));
1328 astFactory->makeASTRoot(currentAST, tmp92_AST);
1329 match(MEMBERS);
1330 match(LPAREN);
1331 inttuple();
1332 astFactory->addASTChild( currentAST, returnAST );
1333 match(RPAREN);
1334 match(SEMICOLON);
1335 bondstatement_AST = currentAST.root;
1336 break;
1337 }
1338 case FIXED:
1339 {
1340 ANTLR_USE_NAMESPACE(antlr)RefAST tmp96_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1341 tmp96_AST = astFactory->create(LT(1));
1342 astFactory->makeASTRoot(currentAST, tmp96_AST);
1343 match(FIXED);
1344 match(LPAREN);
1345 floatConst();
1346 astFactory->addASTChild( currentAST, returnAST );
1347 match(RPAREN);
1348 match(SEMICOLON);
1349 bondstatement_AST = currentAST.root;
1350 break;
1351 }
1352 case HARMONIC:
1353 {
1354 ANTLR_USE_NAMESPACE(antlr)RefAST tmp100_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1355 tmp100_AST = astFactory->create(LT(1));
1356 astFactory->makeASTRoot(currentAST, tmp100_AST);
1357 match(HARMONIC);
1358 match(LPAREN);
1359 doubleNumberTuple();
1360 astFactory->addASTChild( currentAST, returnAST );
1361 match(RPAREN);
1362 match(SEMICOLON);
1363 bondstatement_AST = currentAST.root;
1364 break;
1365 }
1366 case CUBIC:
1367 {
1368 ANTLR_USE_NAMESPACE(antlr)RefAST tmp104_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1369 tmp104_AST = astFactory->create(LT(1));
1370 astFactory->makeASTRoot(currentAST, tmp104_AST);
1371 match(CUBIC);
1372 match(LPAREN);
1373 doubleNumberTuple();
1374 astFactory->addASTChild( currentAST, returnAST );
1375 match(RPAREN);
1376 match(SEMICOLON);
1377 bondstatement_AST = currentAST.root;
1378 break;
1379 }
1380 case QUARTIC:
1381 {
1382 ANTLR_USE_NAMESPACE(antlr)RefAST tmp108_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1383 tmp108_AST = astFactory->create(LT(1));
1384 astFactory->makeASTRoot(currentAST, tmp108_AST);
1385 match(QUARTIC);
1386 match(LPAREN);
1387 doubleNumberTuple();
1388 astFactory->addASTChild( currentAST, returnAST );
1389 match(RPAREN);
1390 match(SEMICOLON);
1391 bondstatement_AST = currentAST.root;
1392 break;
1393 }
1394 case POLYNOMIAL:
1395 {
1396 ANTLR_USE_NAMESPACE(antlr)RefAST tmp112_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1397 tmp112_AST = astFactory->create(LT(1));
1398 astFactory->makeASTRoot(currentAST, tmp112_AST);
1399 match(POLYNOMIAL);
1400 match(LPAREN);
1401 doubleNumberTuple();
1402 astFactory->addASTChild( currentAST, returnAST );
1403 match(RPAREN);
1404 match(SEMICOLON);
1405 bondstatement_AST = currentAST.root;
1406 break;
1407 }
1408 case MORSE:
1409 {
1410 ANTLR_USE_NAMESPACE(antlr)RefAST tmp116_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1411 tmp116_AST = astFactory->create(LT(1));
1412 astFactory->makeASTRoot(currentAST, tmp116_AST);
1413 match(MORSE);
1414 match(LPAREN);
1415 doubleNumberTuple();
1416 astFactory->addASTChild( currentAST, returnAST );
1417 match(RPAREN);
1418 match(SEMICOLON);
1419 bondstatement_AST = currentAST.root;
1420 break;
1421 }
1422 default:
1423 {
1424 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1425 }
1426 }
1427 }
1428 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1429 reportError(ex);
1430 recover(ex,_tokenSet_18);
1431 }
1432 returnAST = bondstatement_AST;
1433}
1434
1435void MDParser::inttuple() {
1436 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1437 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1438 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1439
1440 try { // for error handling
1441 intConst();
1442 astFactory->addASTChild( currentAST, returnAST );
1443 { // ( ... )*
1444 for (;;) {
1445 if ((LA(1) == COMMA)) {
1446 match(COMMA);
1447 intConst();
1448 astFactory->addASTChild( currentAST, returnAST );
1449 }
1450 else {
1451 goto _loop82;
1452 }
1453
1454 }
1455 _loop82:;
1456 } // ( ... )*
1457 inttuple_AST = currentAST.root;
1458 }
1459 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1460 reportError(ex);
1461 recover(ex,_tokenSet_17);
1462 }
1463 returnAST = inttuple_AST;
1464}
1465
1466void MDParser::bendstatement() {
1467 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1468 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1469 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1470
1471 try { // for error handling
1472 switch ( LA(1)) {
1473 case ID:
1474 {
1475 assignment();
1476 astFactory->addASTChild( currentAST, returnAST );
1477 bendstatement_AST = currentAST.root;
1478 break;
1479 }
1480 case MEMBERS:
1481 {
1482 ANTLR_USE_NAMESPACE(antlr)RefAST tmp121_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1483 tmp121_AST = astFactory->create(LT(1));
1484 astFactory->makeASTRoot(currentAST, tmp121_AST);
1485 match(MEMBERS);
1486 match(LPAREN);
1487 inttuple();
1488 astFactory->addASTChild( currentAST, returnAST );
1489 match(RPAREN);
1490 match(SEMICOLON);
1491 bendstatement_AST = currentAST.root;
1492 break;
1493 }
1494 case HARMONIC:
1495 {
1496 ANTLR_USE_NAMESPACE(antlr)RefAST tmp125_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1497 tmp125_AST = astFactory->create(LT(1));
1498 astFactory->makeASTRoot(currentAST, tmp125_AST);
1499 match(HARMONIC);
1500 match(LPAREN);
1501 doubleNumberTuple();
1502 astFactory->addASTChild( currentAST, returnAST );
1503 match(RPAREN);
1504 match(SEMICOLON);
1505 bendstatement_AST = currentAST.root;
1506 break;
1507 }
1508 case GHOSTBEND:
1509 {
1510 ANTLR_USE_NAMESPACE(antlr)RefAST tmp129_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1511 tmp129_AST = astFactory->create(LT(1));
1512 astFactory->makeASTRoot(currentAST, tmp129_AST);
1513 match(GHOSTBEND);
1514 match(LPAREN);
1515 doubleNumberTuple();
1516 astFactory->addASTChild( currentAST, returnAST );
1517 match(RPAREN);
1518 match(SEMICOLON);
1519 bendstatement_AST = currentAST.root;
1520 break;
1521 }
1522 case UREYBRADLEY:
1523 {
1524 ANTLR_USE_NAMESPACE(antlr)RefAST tmp133_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1525 tmp133_AST = astFactory->create(LT(1));
1526 astFactory->makeASTRoot(currentAST, tmp133_AST);
1527 match(UREYBRADLEY);
1528 match(LPAREN);
1529 doubleNumberTuple();
1530 astFactory->addASTChild( currentAST, returnAST );
1531 match(RPAREN);
1532 match(SEMICOLON);
1533 bendstatement_AST = currentAST.root;
1534 break;
1535 }
1536 case CUBIC:
1537 {
1538 ANTLR_USE_NAMESPACE(antlr)RefAST tmp137_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1539 tmp137_AST = astFactory->create(LT(1));
1540 astFactory->makeASTRoot(currentAST, tmp137_AST);
1541 match(CUBIC);
1542 match(LPAREN);
1543 doubleNumberTuple();
1544 astFactory->addASTChild( currentAST, returnAST );
1545 match(RPAREN);
1546 match(SEMICOLON);
1547 bendstatement_AST = currentAST.root;
1548 break;
1549 }
1550 case QUARTIC:
1551 {
1552 ANTLR_USE_NAMESPACE(antlr)RefAST tmp141_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1553 tmp141_AST = astFactory->create(LT(1));
1554 astFactory->makeASTRoot(currentAST, tmp141_AST);
1555 match(QUARTIC);
1556 match(LPAREN);
1557 doubleNumberTuple();
1558 astFactory->addASTChild( currentAST, returnAST );
1559 match(RPAREN);
1560 match(SEMICOLON);
1561 bendstatement_AST = currentAST.root;
1562 break;
1563 }
1564 case POLYNOMIAL:
1565 {
1566 ANTLR_USE_NAMESPACE(antlr)RefAST tmp145_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1567 tmp145_AST = astFactory->create(LT(1));
1568 astFactory->makeASTRoot(currentAST, tmp145_AST);
1569 match(POLYNOMIAL);
1570 match(LPAREN);
1571 doubleNumberTuple();
1572 astFactory->addASTChild( currentAST, returnAST );
1573 match(RPAREN);
1574 match(SEMICOLON);
1575 bendstatement_AST = currentAST.root;
1576 break;
1577 }
1578 case COSINE:
1579 {
1580 ANTLR_USE_NAMESPACE(antlr)RefAST tmp149_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1581 tmp149_AST = astFactory->create(LT(1));
1582 astFactory->makeASTRoot(currentAST, tmp149_AST);
1583 match(COSINE);
1584 match(LPAREN);
1585 doubleNumberTuple();
1586 astFactory->addASTChild( currentAST, returnAST );
1587 match(RPAREN);
1588 match(SEMICOLON);
1589 bendstatement_AST = currentAST.root;
1590 break;
1591 }
1592 default:
1593 {
1594 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1595 }
1596 }
1597 }
1598 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1599 reportError(ex);
1600 recover(ex,_tokenSet_19);
1601 }
1602 returnAST = bendstatement_AST;
1603}
1604
1605void MDParser::torsionstatement() {
1606 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1607 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1608 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1609
1610 try { // for error handling
1611 switch ( LA(1)) {
1612 case ID:
1613 {
1614 assignment();
1615 astFactory->addASTChild( currentAST, returnAST );
1616 torsionstatement_AST = currentAST.root;
1617 break;
1618 }
1619 case MEMBERS:
1620 {
1621 ANTLR_USE_NAMESPACE(antlr)RefAST tmp153_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1622 tmp153_AST = astFactory->create(LT(1));
1623 astFactory->makeASTRoot(currentAST, tmp153_AST);
1624 match(MEMBERS);
1625 match(LPAREN);
1626 inttuple();
1627 astFactory->addASTChild( currentAST, returnAST );
1628 match(RPAREN);
1629 match(SEMICOLON);
1630 torsionstatement_AST = currentAST.root;
1631 break;
1632 }
1633 case GHOSTTORSION:
1634 {
1635 ANTLR_USE_NAMESPACE(antlr)RefAST tmp157_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1636 tmp157_AST = astFactory->create(LT(1));
1637 astFactory->makeASTRoot(currentAST, tmp157_AST);
1638 match(GHOSTTORSION);
1639 match(LPAREN);
1640 doubleNumberTuple();
1641 astFactory->addASTChild( currentAST, returnAST );
1642 match(RPAREN);
1643 match(SEMICOLON);
1644 torsionstatement_AST = currentAST.root;
1645 break;
1646 }
1647 case CUBIC:
1648 {
1649 ANTLR_USE_NAMESPACE(antlr)RefAST tmp161_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1650 tmp161_AST = astFactory->create(LT(1));
1651 astFactory->makeASTRoot(currentAST, tmp161_AST);
1652 match(CUBIC);
1653 match(LPAREN);
1654 doubleNumberTuple();
1655 astFactory->addASTChild( currentAST, returnAST );
1656 match(RPAREN);
1657 match(SEMICOLON);
1658 torsionstatement_AST = currentAST.root;
1659 break;
1660 }
1661 case QUARTIC:
1662 {
1663 ANTLR_USE_NAMESPACE(antlr)RefAST tmp165_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1664 tmp165_AST = astFactory->create(LT(1));
1665 astFactory->makeASTRoot(currentAST, tmp165_AST);
1666 match(QUARTIC);
1667 match(LPAREN);
1668 doubleNumberTuple();
1669 astFactory->addASTChild( currentAST, returnAST );
1670 match(RPAREN);
1671 match(SEMICOLON);
1672 torsionstatement_AST = currentAST.root;
1673 break;
1674 }
1675 case POLYNOMIAL:
1676 {
1677 ANTLR_USE_NAMESPACE(antlr)RefAST tmp169_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1678 tmp169_AST = astFactory->create(LT(1));
1679 astFactory->makeASTRoot(currentAST, tmp169_AST);
1680 match(POLYNOMIAL);
1681 match(LPAREN);
1682 doubleNumberTuple();
1683 astFactory->addASTChild( currentAST, returnAST );
1684 match(RPAREN);
1685 match(SEMICOLON);
1686 torsionstatement_AST = currentAST.root;
1687 break;
1688 }
1689 case CHARMM:
1690 {
1691 ANTLR_USE_NAMESPACE(antlr)RefAST tmp173_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1692 tmp173_AST = astFactory->create(LT(1));
1693 astFactory->makeASTRoot(currentAST, tmp173_AST);
1694 match(CHARMM);
1695 match(LPAREN);
1696 doubleNumberTuple();
1697 astFactory->addASTChild( currentAST, returnAST );
1698 match(RPAREN);
1699 match(SEMICOLON);
1700 torsionstatement_AST = currentAST.root;
1701 break;
1702 }
1703 case OPLS:
1704 {
1705 ANTLR_USE_NAMESPACE(antlr)RefAST tmp177_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1706 tmp177_AST = astFactory->create(LT(1));
1707 astFactory->makeASTRoot(currentAST, tmp177_AST);
1708 match(OPLS);
1709 match(LPAREN);
1710 doubleNumberTuple();
1711 astFactory->addASTChild( currentAST, returnAST );
1712 match(RPAREN);
1713 match(SEMICOLON);
1714 torsionstatement_AST = currentAST.root;
1715 break;
1716 }
1717 case TRAPPE:
1718 {
1719 ANTLR_USE_NAMESPACE(antlr)RefAST tmp181_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1720 tmp181_AST = astFactory->create(LT(1));
1721 astFactory->makeASTRoot(currentAST, tmp181_AST);
1722 match(TRAPPE);
1723 match(LPAREN);
1724 doubleNumberTuple();
1725 astFactory->addASTChild( currentAST, returnAST );
1726 match(RPAREN);
1727 match(SEMICOLON);
1728 torsionstatement_AST = currentAST.root;
1729 break;
1730 }
1731 case HARMONIC:
1732 {
1733 ANTLR_USE_NAMESPACE(antlr)RefAST tmp185_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1734 tmp185_AST = astFactory->create(LT(1));
1735 astFactory->makeASTRoot(currentAST, tmp185_AST);
1736 match(HARMONIC);
1737 match(LPAREN);
1738 doubleNumberTuple();
1739 astFactory->addASTChild( currentAST, returnAST );
1740 match(RPAREN);
1741 match(SEMICOLON);
1742 torsionstatement_AST = currentAST.root;
1743 break;
1744 }
1745 default:
1746 {
1747 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1748 }
1749 }
1750 }
1751 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1752 reportError(ex);
1753 recover(ex,_tokenSet_20);
1754 }
1755 returnAST = torsionstatement_AST;
1756}
1757
1758void MDParser::inversionstatement() {
1759 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1760 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1761 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1762
1763 try { // for error handling
1764 switch ( LA(1)) {
1765 case ID:
1766 {
1767 assignment();
1768 astFactory->addASTChild( currentAST, returnAST );
1769 inversionstatement_AST = currentAST.root;
1770 break;
1771 }
1772 case CENTER:
1773 {
1774 ANTLR_USE_NAMESPACE(antlr)RefAST tmp189_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1775 tmp189_AST = astFactory->create(LT(1));
1776 astFactory->makeASTRoot(currentAST, tmp189_AST);
1777 match(CENTER);
1778 match(LPAREN);
1779 intConst();
1780 astFactory->addASTChild( currentAST, returnAST );
1781 match(RPAREN);
1782 match(SEMICOLON);
1783 inversionstatement_AST = currentAST.root;
1784 break;
1785 }
1786 case SATELLITES:
1787 {
1788 ANTLR_USE_NAMESPACE(antlr)RefAST tmp193_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1789 tmp193_AST = astFactory->create(LT(1));
1790 astFactory->makeASTRoot(currentAST, tmp193_AST);
1791 match(SATELLITES);
1792 match(LPAREN);
1793 inttuple();
1794 astFactory->addASTChild( currentAST, returnAST );
1795 match(RPAREN);
1796 match(SEMICOLON);
1797 inversionstatement_AST = currentAST.root;
1798 break;
1799 }
1800 case AMBERIMPROPER:
1801 {
1802 ANTLR_USE_NAMESPACE(antlr)RefAST tmp197_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1803 tmp197_AST = astFactory->create(LT(1));
1804 astFactory->makeASTRoot(currentAST, tmp197_AST);
1805 match(AMBERIMPROPER);
1806 match(LPAREN);
1807 doubleNumberTuple();
1808 astFactory->addASTChild( currentAST, returnAST );
1809 match(RPAREN);
1810 match(SEMICOLON);
1811 inversionstatement_AST = currentAST.root;
1812 break;
1813 }
1814 case IMPROPERCOSINE:
1815 {
1816 ANTLR_USE_NAMESPACE(antlr)RefAST tmp201_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1817 tmp201_AST = astFactory->create(LT(1));
1818 astFactory->makeASTRoot(currentAST, tmp201_AST);
1819 match(IMPROPERCOSINE);
1820 match(LPAREN);
1821 doubleNumberTuple();
1822 astFactory->addASTChild( currentAST, returnAST );
1823 match(RPAREN);
1824 match(SEMICOLON);
1825 inversionstatement_AST = currentAST.root;
1826 break;
1827 }
1828 case HARMONIC:
1829 {
1830 ANTLR_USE_NAMESPACE(antlr)RefAST tmp205_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1831 tmp205_AST = astFactory->create(LT(1));
1832 astFactory->makeASTRoot(currentAST, tmp205_AST);
1833 match(HARMONIC);
1834 match(LPAREN);
1835 doubleNumberTuple();
1836 astFactory->addASTChild( currentAST, returnAST );
1837 match(RPAREN);
1838 match(SEMICOLON);
1839 inversionstatement_AST = currentAST.root;
1840 break;
1841 }
1842 case CENTRALATOMHEIGHT:
1843 {
1844 ANTLR_USE_NAMESPACE(antlr)RefAST tmp209_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1845 tmp209_AST = astFactory->create(LT(1));
1846 astFactory->makeASTRoot(currentAST, tmp209_AST);
1847 match(CENTRALATOMHEIGHT);
1848 match(LPAREN);
1849 doubleNumberTuple();
1850 astFactory->addASTChild( currentAST, returnAST );
1851 match(RPAREN);
1852 match(SEMICOLON);
1853 inversionstatement_AST = currentAST.root;
1854 break;
1855 }
1856 case DREIDING:
1857 {
1858 ANTLR_USE_NAMESPACE(antlr)RefAST tmp213_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1859 tmp213_AST = astFactory->create(LT(1));
1860 astFactory->makeASTRoot(currentAST, tmp213_AST);
1861 match(DREIDING);
1862 match(LPAREN);
1863 doubleNumberTuple();
1864 astFactory->addASTChild( currentAST, returnAST );
1865 match(RPAREN);
1866 match(SEMICOLON);
1867 inversionstatement_AST = currentAST.root;
1868 break;
1869 }
1870 default:
1871 {
1872 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1873 }
1874 }
1875 }
1876 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1877 reportError(ex);
1878 recover(ex,_tokenSet_21);
1879 }
1880 returnAST = inversionstatement_AST;
1881}
1882
1883void MDParser::rigidbodystatement() {
1884 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1885 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1886 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1887
1888 try { // for error handling
1889 switch ( LA(1)) {
1890 case ID:
1891 {
1892 assignment();
1893 astFactory->addASTChild( currentAST, returnAST );
1894 rigidbodystatement_AST = currentAST.root;
1895 break;
1896 }
1897 case MEMBERS:
1898 {
1899 ANTLR_USE_NAMESPACE(antlr)RefAST tmp217_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1900 tmp217_AST = astFactory->create(LT(1));
1901 astFactory->makeASTRoot(currentAST, tmp217_AST);
1902 match(MEMBERS);
1903 match(LPAREN);
1904 inttuple();
1905 astFactory->addASTChild( currentAST, returnAST );
1906 match(RPAREN);
1907 match(SEMICOLON);
1908 rigidbodystatement_AST = currentAST.root;
1909 break;
1910 }
1911 default:
1912 {
1913 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1914 }
1915 }
1916 }
1917 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1918 reportError(ex);
1919 recover(ex,_tokenSet_22);
1920 }
1921 returnAST = rigidbodystatement_AST;
1922}
1923
1924void MDParser::cutoffgroupstatement() {
1925 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1926 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1927 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1928
1929 try { // for error handling
1930 switch ( LA(1)) {
1931 case ID:
1932 {
1933 assignment();
1934 astFactory->addASTChild( currentAST, returnAST );
1935 cutoffgroupstatement_AST = currentAST.root;
1936 break;
1937 }
1938 case MEMBERS:
1939 {
1940 ANTLR_USE_NAMESPACE(antlr)RefAST tmp221_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1941 tmp221_AST = astFactory->create(LT(1));
1942 astFactory->makeASTRoot(currentAST, tmp221_AST);
1943 match(MEMBERS);
1944 match(LPAREN);
1945 inttuple();
1946 astFactory->addASTChild( currentAST, returnAST );
1947 match(RPAREN);
1948 match(SEMICOLON);
1949 cutoffgroupstatement_AST = currentAST.root;
1950 break;
1951 }
1952 default:
1953 {
1954 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1955 }
1956 }
1957 }
1958 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1959 reportError(ex);
1960 recover(ex,_tokenSet_22);
1961 }
1962 returnAST = cutoffgroupstatement_AST;
1963}
1964
1965void MDParser::nodesblock() {
1966 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1967 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1968 ANTLR_USE_NAMESPACE(antlr)RefAST nodesblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1969
1970 try { // for error handling
1971 ANTLR_USE_NAMESPACE(antlr)RefAST tmp225_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1972 tmp225_AST = astFactory->create(LT(1));
1973 astFactory->makeASTRoot(currentAST, tmp225_AST);
1974 match(NODES);
1975 {
1976 switch ( LA(1)) {
1977 case LBRACKET:
1978 {
1979 match(LBRACKET);
1980 intConst();
1981 match(RBRACKET);
1982 break;
1983 }
1984 case LCURLY:
1985 {
1986 break;
1987 }
1988 default:
1989 {
1990 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1991 }
1992 }
1993 }
1994 match(LCURLY);
1995 { // ( ... )*
1996 for (;;) {
1997 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1998 nodesstatement();
1999 astFactory->addASTChild( currentAST, returnAST );
2000 }
2001 else {
2002 goto _loop65;
2003 }
2004
2005 }
2006 _loop65:;
2007 } // ( ... )*
2008 ANTLR_USE_NAMESPACE(antlr)RefAST tmp229_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2009 tmp229_AST = astFactory->create(LT(1));
2010 astFactory->addASTChild(currentAST, tmp229_AST);
2011 match(RCURLY);
2012#line 210 "MDParser.g"
2013 tmp229_AST->setType(ENDBLOCK);
2014#line 2015 "MDParser.cpp"
2015 nodesblock_AST = currentAST.root;
2016 }
2017 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2018 reportError(ex);
2019 recover(ex,_tokenSet_23);
2020 }
2021 returnAST = nodesblock_AST;
2022}
2023
2024void MDParser::nodesstatement() {
2025 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2026 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2027 ANTLR_USE_NAMESPACE(antlr)RefAST nodesstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2028
2029 try { // for error handling
2030 switch ( LA(1)) {
2031 case ID:
2032 {
2033 assignment();
2034 astFactory->addASTChild( currentAST, returnAST );
2035 nodesstatement_AST = currentAST.root;
2036 break;
2037 }
2038 case MEMBERS:
2039 {
2040 ANTLR_USE_NAMESPACE(antlr)RefAST tmp230_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2041 tmp230_AST = astFactory->create(LT(1));
2042 astFactory->makeASTRoot(currentAST, tmp230_AST);
2043 match(MEMBERS);
2044 match(LPAREN);
2045 inttuple();
2046 astFactory->addASTChild( currentAST, returnAST );
2047 match(RPAREN);
2048 match(SEMICOLON);
2049 nodesstatement_AST = currentAST.root;
2050 break;
2051 }
2052 default:
2053 {
2054 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2055 }
2056 }
2057 }
2058 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2059 reportError(ex);
2060 recover(ex,_tokenSet_22);
2061 }
2062 returnAST = nodesstatement_AST;
2063}
2064
2065void MDParser::fragmentstatement() {
2066 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2067 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2068 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2069
2070 try { // for error handling
2071 switch ( LA(1)) {
2072 case ID:
2073 {
2074 assignment();
2075 astFactory->addASTChild( currentAST, returnAST );
2076 fragmentstatement_AST = currentAST.root;
2077 break;
2078 }
2079 case ATOM:
2080 {
2081 atomblock();
2082 astFactory->addASTChild( currentAST, returnAST );
2083 fragmentstatement_AST = currentAST.root;
2084 break;
2085 }
2086 case BOND:
2087 {
2088 bondblock();
2089 astFactory->addASTChild( currentAST, returnAST );
2090 fragmentstatement_AST = currentAST.root;
2091 break;
2092 }
2093 case BEND:
2094 {
2095 bendblock();
2096 astFactory->addASTChild( currentAST, returnAST );
2097 fragmentstatement_AST = currentAST.root;
2098 break;
2099 }
2100 case TORSION:
2101 {
2102 torsionblock();
2103 astFactory->addASTChild( currentAST, returnAST );
2104 fragmentstatement_AST = currentAST.root;
2105 break;
2106 }
2107 case INVERSION:
2108 {
2109 inversionblock();
2110 astFactory->addASTChild( currentAST, returnAST );
2111 fragmentstatement_AST = currentAST.root;
2112 break;
2113 }
2114 case RIGIDBODY:
2115 {
2116 rigidbodyblock();
2117 astFactory->addASTChild( currentAST, returnAST );
2118 fragmentstatement_AST = currentAST.root;
2119 break;
2120 }
2121 case CUTOFFGROUP:
2122 {
2123 cutoffgroupblock();
2124 astFactory->addASTChild( currentAST, returnAST );
2125 fragmentstatement_AST = currentAST.root;
2126 break;
2127 }
2128 case CONSTRAINT:
2129 {
2130 constraintblock();
2131 astFactory->addASTChild( currentAST, returnAST );
2132 fragmentstatement_AST = currentAST.root;
2133 break;
2134 }
2135 case NODES:
2136 {
2137 nodesblock();
2138 astFactory->addASTChild( currentAST, returnAST );
2139 fragmentstatement_AST = currentAST.root;
2140 break;
2141 }
2142 default:
2143 {
2144 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2145 }
2146 }
2147 }
2148 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2149 reportError(ex);
2150 recover(ex,_tokenSet_23);
2151 }
2152 returnAST = fragmentstatement_AST;
2153}
2154
2155void MDParser::constraintstatement() {
2156 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2157 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2158 ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2159
2160 try { // for error handling
2161 switch ( LA(1)) {
2162 case ID:
2163 {
2164 assignment();
2165 astFactory->addASTChild( currentAST, returnAST );
2166 constraintstatement_AST = currentAST.root;
2167 break;
2168 }
2169 case MEMBERS:
2170 {
2171 ANTLR_USE_NAMESPACE(antlr)RefAST tmp234_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2172 tmp234_AST = astFactory->create(LT(1));
2173 astFactory->makeASTRoot(currentAST, tmp234_AST);
2174 match(MEMBERS);
2175 match(LPAREN);
2176 inttuple();
2177 astFactory->addASTChild( currentAST, returnAST );
2178 match(RPAREN);
2179 match(SEMICOLON);
2180 constraintstatement_AST = currentAST.root;
2181 break;
2182 }
2183 default:
2184 {
2185 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2186 }
2187 }
2188 }
2189 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2190 reportError(ex);
2191 recover(ex,_tokenSet_22);
2192 }
2193 returnAST = constraintstatement_AST;
2194}
2195
2196void MDParser::doubleNumber() {
2197 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2198 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
2199 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
2200
2201 try { // for error handling
2202 {
2203 switch ( LA(1)) {
2204 case NUM_INT:
2205 case NUM_LONG:
2206 {
2207 intConst();
2208 astFactory->addASTChild( currentAST, returnAST );
2209 break;
2210 }
2211 case NUM_FLOAT:
2212 case NUM_DOUBLE:
2213 {
2214 floatConst();
2215 astFactory->addASTChild( currentAST, returnAST );
2216 break;
2217 }
2218 default:
2219 {
2220 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
2221 }
2222 }
2223 }
2224 doubleNumber_AST = currentAST.root;
2225 }
2226 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2227 reportError(ex);
2228 recover(ex,_tokenSet_24);
2229 }
2230 returnAST = doubleNumber_AST;
2231}
2232
2233void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
2234{
2235 factory.setMaxNodeType(79);
2236}
2237const char* MDParser::tokenNames[] = {
2238 "<0>",
2239 "EOF",
2240 "<2>",
2241 "NULL_TREE_LOOKAHEAD",
2242 "\"component\"",
2243 "\"molecule\"",
2244 "\"zconstraint\"",
2245 "\"restraint\"",
2246 "\"atom\"",
2247 "\"bond\"",
2248 "\"bend\"",
2249 "\"torsion\"",
2250 "\"inversion\"",
2251 "\"rigidBody\"",
2252 "\"cutoffGroup\"",
2253 "\"constraint\"",
2254 "\"distance\"",
2255 "\"fragment\"",
2256 "\"sequence\"",
2257 "\"members\"",
2258 "\"center\"",
2259 "\"satellites\"",
2260 "\"position\"",
2261 "\"orientation\"",
2262 "\"flucQ\"",
2263 "\"RNEMD\"",
2264 "\"minimizer\"",
2265 "\"Fixed\"",
2266 "\"Harmonic\"",
2267 "\"Cubic\"",
2268 "\"Quartic\"",
2269 "\"Polynomial\"",
2270 "\"Morse\"",
2271 "\"GhostBend\"",
2272 "\"UreyBradley\"",
2273 "\"Cosine\"",
2274 "\"GhostTorsion\"",
2275 "\"Charmm\"",
2276 "\"Opls\"",
2277 "\"Trappe\"",
2278 "\"AmberImproper\"",
2279 "\"ImproperCosine\"",
2280 "\"CentralAtomHeight\"",
2281 "\"Dreiding\"",
2282 "\"charge\"",
2283 "\"nodes\"",
2284 "ENDBLOCK",
2285 "ID",
2286 "ASSIGNEQUAL",
2287 "SEMICOLON",
2288 "StringLiteral",
2289 "LCURLY",
2290 "RCURLY",
2291 "LBRACKET",
2292 "RBRACKET",
2293 "LPAREN",
2294 "RPAREN",
2295 "COMMA",
2296 "NUM_INT",
2297 "NUM_LONG",
2298 "NUM_FLOAT",
2299 "NUM_DOUBLE",
2300 "DOT",
2301 "COLON",
2302 "QUESTIONMARK",
2303 "Whitespace",
2304 "Comment",
2305 "CPPComment",
2306 "a line directive",
2307 "LineDirective",
2308 "Space",
2309 "CharLiteral",
2310 "EndOfLine",
2311 "Escape",
2312 "Vocabulary",
2313 "Digit",
2314 "Decimal",
2315 "HEX_DIGIT",
2316 "EXPONENT",
2317 "FLOAT_SUFFIX",
2318 0
2319};
2320
2321const unsigned long MDParser::_tokenSet_0_data_[] = { 117571824UL, 32768UL, 0UL, 0UL };
2322// "component" "molecule" "zconstraint" "restraint" "fragment" "flucQ"
2323// "RNEMD" "minimizer" ID
2324const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
2325const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
2326// EOF
2327const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
2328const unsigned long MDParser::_tokenSet_2_data_[] = { 117571826UL, 32768UL, 0UL, 0UL };
2329// EOF "component" "molecule" "zconstraint" "restraint" "fragment" "flucQ"
2330// "RNEMD" "minimizer" ID
2331const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
2332const unsigned long MDParser::_tokenSet_3_data_[] = { 4294901746UL, 1097727UL, 0UL, 0UL };
2333// EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
2334// "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment"
2335// "sequence" "members" "center" "satellites" "position" "orientation"
2336// "flucQ" "RNEMD" "minimizer" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial"
2337// "Morse" "GhostBend" "UreyBradley" "Cosine" "GhostTorsion" "Charmm" "Opls"
2338// "Trappe" "AmberImproper" "ImproperCosine" "CentralAtomHeight" "Dreiding"
2339// "charge" "nodes" ID RCURLY
2340const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
2341const unsigned long MDParser::_tokenSet_4_data_[] = { 327424UL, 32768UL, 0UL, 0UL };
2342// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2343// "constraint" "sequence" ID
2344const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
2345const unsigned long MDParser::_tokenSet_5_data_[] = { 65280UL, 40960UL, 0UL, 0UL };
2346// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2347// "constraint" "nodes" ID
2348const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
2349const unsigned long MDParser::_tokenSet_6_data_[] = { 0UL, 131072UL, 0UL, 0UL };
2350// SEMICOLON
2351const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
2352const unsigned long MDParser::_tokenSet_7_data_[] = { 0UL, 54657024UL, 0UL, 0UL };
2353// SEMICOLON RBRACKET RPAREN COMMA
2354const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
2355const unsigned long MDParser::_tokenSet_8_data_[] = { 0UL, 50462720UL, 0UL, 0UL };
2356// SEMICOLON RPAREN COMMA
2357const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
2358const unsigned long MDParser::_tokenSet_9_data_[] = { 327424UL, 1081344UL, 0UL, 0UL };
2359// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2360// "constraint" "sequence" ID RCURLY
2361const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
2362const unsigned long MDParser::_tokenSet_10_data_[] = { 12582912UL, 36864UL, 0UL, 0UL };
2363// "position" "orientation" "charge" ID
2364const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
2365const unsigned long MDParser::_tokenSet_11_data_[] = { 327424UL, 1089536UL, 0UL, 0UL };
2366// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2367// "constraint" "sequence" "nodes" ID RCURLY
2368const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
2369const unsigned long MDParser::_tokenSet_12_data_[] = { 4161273856UL, 32769UL, 0UL, 0UL };
2370// "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse"
2371// ID
2372const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
2373const unsigned long MDParser::_tokenSet_13_data_[] = { 4027056128UL, 32782UL, 0UL, 0UL };
2374// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley"
2375// "Cosine" ID
2376const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
2377const unsigned long MDParser::_tokenSet_14_data_[] = { 4027056128UL, 33008UL, 0UL, 0UL };
2378// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm"
2379// "Opls" "Trappe" ID
2380const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
2381const unsigned long MDParser::_tokenSet_15_data_[] = { 271581184UL, 36608UL, 0UL, 0UL };
2382// "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight"
2383// "Dreiding" ID
2384const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
2385const unsigned long MDParser::_tokenSet_16_data_[] = { 12582912UL, 1085440UL, 0UL, 0UL };
2386// "position" "orientation" "charge" ID RCURLY
2387const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
2388const unsigned long MDParser::_tokenSet_17_data_[] = { 0UL, 16777216UL, 0UL, 0UL };
2389// RPAREN
2390const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_17(_tokenSet_17_data_,4);
2391const unsigned long MDParser::_tokenSet_18_data_[] = { 4161273856UL, 1081345UL, 0UL, 0UL };
2392// "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse"
2393// ID RCURLY
2394const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_18(_tokenSet_18_data_,4);
2395const unsigned long MDParser::_tokenSet_19_data_[] = { 4027056128UL, 1081358UL, 0UL, 0UL };
2396// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley"
2397// "Cosine" ID RCURLY
2398const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_19(_tokenSet_19_data_,4);
2399const unsigned long MDParser::_tokenSet_20_data_[] = { 4027056128UL, 1081584UL, 0UL, 0UL };
2400// "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm"
2401// "Opls" "Trappe" ID RCURLY
2402const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_20(_tokenSet_20_data_,4);
2403const unsigned long MDParser::_tokenSet_21_data_[] = { 271581184UL, 1085184UL, 0UL, 0UL };
2404// "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight"
2405// "Dreiding" ID RCURLY
2406const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_21(_tokenSet_21_data_,4);
2407const unsigned long MDParser::_tokenSet_22_data_[] = { 524288UL, 1081344UL, 0UL, 0UL };
2408// "members" ID RCURLY
2409const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_22(_tokenSet_22_data_,4);
2410const unsigned long MDParser::_tokenSet_23_data_[] = { 65280UL, 1089536UL, 0UL, 0UL };
2411// "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2412// "constraint" "nodes" ID RCURLY
2413const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_23(_tokenSet_23_data_,4);
2414const unsigned long MDParser::_tokenSet_24_data_[] = { 0UL, 50331648UL, 0UL, 0UL };
2415// RPAREN COMMA
2416const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_24(_tokenSet_24_data_,4);
2417
2418