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