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

File Contents

# Content
1 /* $ANTLR 2.7.7 (20140107): "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"
8 MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
9 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
10 {
11 }
12
13 MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
14 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
15 {
16 }
17
18 MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
19 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
20 {
21 }
22
23 MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
24 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
25 {
26 }
27
28 MDParser::MDParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
29 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
30 {
31 }
32
33 void 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
61 void 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 ZCONSTRAINT:
90 {
91 zconstraintblock();
92 astFactory->addASTChild( currentAST, returnAST );
93 statement_AST = currentAST.root;
94 break;
95 }
96 case RESTRAINT:
97 {
98 restraintblock();
99 astFactory->addASTChild( currentAST, returnAST );
100 statement_AST = currentAST.root;
101 break;
102 }
103 case FLUCQ:
104 {
105 flucqblock();
106 astFactory->addASTChild( currentAST, returnAST );
107 statement_AST = currentAST.root;
108 break;
109 }
110 case RNEMD:
111 {
112 rnemdblock();
113 astFactory->addASTChild( currentAST, returnAST );
114 statement_AST = currentAST.root;
115 break;
116 }
117 case MINIMIZER:
118 {
119 minimizerblock();
120 astFactory->addASTChild( currentAST, returnAST );
121 statement_AST = currentAST.root;
122 break;
123 }
124 default:
125 {
126 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
127 }
128 }
129 }
130 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
131 reportError(ex);
132 recover(ex,_tokenSet_2);
133 }
134 returnAST = statement_AST;
135 }
136
137 void MDParser::assignment() {
138 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
139 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
140 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
141
142 try { // for error handling
143 ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
144 tmp1_AST = astFactory->create(LT(1));
145 astFactory->addASTChild(currentAST, tmp1_AST);
146 match(ID);
147 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
148 tmp2_AST = astFactory->create(LT(1));
149 astFactory->makeASTRoot(currentAST, tmp2_AST);
150 match(ASSIGNEQUAL);
151 constant();
152 astFactory->addASTChild( currentAST, returnAST );
153 match(SEMICOLON);
154 assignment_AST = currentAST.root;
155 }
156 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
157 reportError(ex);
158 recover(ex,_tokenSet_3);
159 }
160 returnAST = assignment_AST;
161 }
162
163 void MDParser::componentblock() {
164 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
165 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
166 ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
167
168 try { // for error handling
169 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
170 tmp4_AST = astFactory->create(LT(1));
171 astFactory->makeASTRoot(currentAST, tmp4_AST);
172 match(COMPONENT);
173 match(LCURLY);
174 { // ( ... )*
175 for (;;) {
176 if ((LA(1) == ID)) {
177 assignment();
178 astFactory->addASTChild( currentAST, returnAST );
179 }
180 else {
181 goto _loop9;
182 }
183
184 }
185 _loop9:;
186 } // ( ... )*
187 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
188 tmp6_AST = astFactory->create(LT(1));
189 astFactory->addASTChild(currentAST, tmp6_AST);
190 match(RCURLY);
191 #line 77 "MDParser.g"
192 tmp6_AST->setType(ENDBLOCK);
193 #line 194 "MDParser.cpp"
194 componentblock_AST = currentAST.root;
195 }
196 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
197 reportError(ex);
198 recover(ex,_tokenSet_2);
199 }
200 returnAST = componentblock_AST;
201 }
202
203 void MDParser::moleculeblock() {
204 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
205 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
206 ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
207
208 try { // for error handling
209 ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
210 tmp7_AST = astFactory->create(LT(1));
211 astFactory->makeASTRoot(currentAST, tmp7_AST);
212 match(MOLECULE);
213 match(LCURLY);
214 { // ( ... )*
215 for (;;) {
216 if ((_tokenSet_4.member(LA(1)))) {
217 moleculestatement();
218 astFactory->addASTChild( currentAST, returnAST );
219 }
220 else {
221 goto _loop27;
222 }
223
224 }
225 _loop27:;
226 } // ( ... )*
227 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
228 tmp9_AST = astFactory->create(LT(1));
229 astFactory->addASTChild(currentAST, tmp9_AST);
230 match(RCURLY);
231 #line 95 "MDParser.g"
232 tmp9_AST->setType(ENDBLOCK);
233 #line 234 "MDParser.cpp"
234 moleculeblock_AST = currentAST.root;
235 }
236 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
237 reportError(ex);
238 recover(ex,_tokenSet_2);
239 }
240 returnAST = moleculeblock_AST;
241 }
242
243 void MDParser::zconstraintblock() {
244 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
245 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
246 ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
247
248 try { // for error handling
249 ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
250 tmp10_AST = astFactory->create(LT(1));
251 astFactory->makeASTRoot(currentAST, tmp10_AST);
252 match(ZCONSTRAINT);
253 match(LCURLY);
254 { // ( ... )*
255 for (;;) {
256 if ((LA(1) == ID)) {
257 assignment();
258 astFactory->addASTChild( currentAST, returnAST );
259 }
260 else {
261 goto _loop12;
262 }
263
264 }
265 _loop12:;
266 } // ( ... )*
267 ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
268 tmp12_AST = astFactory->create(LT(1));
269 astFactory->addASTChild(currentAST, tmp12_AST);
270 match(RCURLY);
271 #line 80 "MDParser.g"
272 tmp12_AST->setType(ENDBLOCK);
273 #line 274 "MDParser.cpp"
274 zconstraintblock_AST = currentAST.root;
275 }
276 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
277 reportError(ex);
278 recover(ex,_tokenSet_2);
279 }
280 returnAST = zconstraintblock_AST;
281 }
282
283 void MDParser::restraintblock() {
284 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
285 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
286 ANTLR_USE_NAMESPACE(antlr)RefAST restraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
287
288 try { // for error handling
289 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
290 tmp13_AST = astFactory->create(LT(1));
291 astFactory->makeASTRoot(currentAST, tmp13_AST);
292 match(RESTRAINT);
293 match(LCURLY);
294 { // ( ... )*
295 for (;;) {
296 if ((LA(1) == ID)) {
297 assignment();
298 astFactory->addASTChild( currentAST, returnAST );
299 }
300 else {
301 goto _loop15;
302 }
303
304 }
305 _loop15:;
306 } // ( ... )*
307 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
308 tmp15_AST = astFactory->create(LT(1));
309 astFactory->addASTChild(currentAST, tmp15_AST);
310 match(RCURLY);
311 #line 83 "MDParser.g"
312 tmp15_AST->setType(ENDBLOCK);
313 #line 314 "MDParser.cpp"
314 restraintblock_AST = currentAST.root;
315 }
316 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
317 reportError(ex);
318 recover(ex,_tokenSet_2);
319 }
320 returnAST = restraintblock_AST;
321 }
322
323 void MDParser::flucqblock() {
324 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
325 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
326 ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
327
328 try { // for error handling
329 ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
330 tmp16_AST = astFactory->create(LT(1));
331 astFactory->makeASTRoot(currentAST, tmp16_AST);
332 match(FLUCQ);
333 match(LCURLY);
334 { // ( ... )*
335 for (;;) {
336 if ((LA(1) == ID)) {
337 assignment();
338 astFactory->addASTChild( currentAST, returnAST );
339 }
340 else {
341 goto _loop18;
342 }
343
344 }
345 _loop18:;
346 } // ( ... )*
347 ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
348 tmp18_AST = astFactory->create(LT(1));
349 astFactory->addASTChild(currentAST, tmp18_AST);
350 match(RCURLY);
351 #line 86 "MDParser.g"
352 tmp18_AST->setType(ENDBLOCK);
353 #line 354 "MDParser.cpp"
354 flucqblock_AST = currentAST.root;
355 }
356 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
357 reportError(ex);
358 recover(ex,_tokenSet_2);
359 }
360 returnAST = flucqblock_AST;
361 }
362
363 void MDParser::rnemdblock() {
364 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
365 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
366 ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
367
368 try { // for error handling
369 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
370 tmp19_AST = astFactory->create(LT(1));
371 astFactory->makeASTRoot(currentAST, tmp19_AST);
372 match(RNEMD);
373 match(LCURLY);
374 { // ( ... )*
375 for (;;) {
376 if ((LA(1) == ID)) {
377 assignment();
378 astFactory->addASTChild( currentAST, returnAST );
379 }
380 else {
381 goto _loop21;
382 }
383
384 }
385 _loop21:;
386 } // ( ... )*
387 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
388 tmp21_AST = astFactory->create(LT(1));
389 astFactory->addASTChild(currentAST, tmp21_AST);
390 match(RCURLY);
391 #line 89 "MDParser.g"
392 tmp21_AST->setType(ENDBLOCK);
393 #line 394 "MDParser.cpp"
394 rnemdblock_AST = currentAST.root;
395 }
396 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
397 reportError(ex);
398 recover(ex,_tokenSet_2);
399 }
400 returnAST = rnemdblock_AST;
401 }
402
403 void MDParser::minimizerblock() {
404 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
405 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
406 ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
407
408 try { // for error handling
409 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
410 tmp22_AST = astFactory->create(LT(1));
411 astFactory->makeASTRoot(currentAST, tmp22_AST);
412 match(MINIMIZER);
413 match(LCURLY);
414 { // ( ... )*
415 for (;;) {
416 if ((LA(1) == ID)) {
417 assignment();
418 astFactory->addASTChild( currentAST, returnAST );
419 }
420 else {
421 goto _loop24;
422 }
423
424 }
425 _loop24:;
426 } // ( ... )*
427 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
428 tmp24_AST = astFactory->create(LT(1));
429 astFactory->addASTChild(currentAST, tmp24_AST);
430 match(RCURLY);
431 #line 92 "MDParser.g"
432 tmp24_AST->setType(ENDBLOCK);
433 #line 434 "MDParser.cpp"
434 minimizerblock_AST = currentAST.root;
435 }
436 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
437 reportError(ex);
438 recover(ex,_tokenSet_2);
439 }
440 returnAST = minimizerblock_AST;
441 }
442
443 void MDParser::constant() {
444 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
445 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
446 ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
447
448 try { // for error handling
449 switch ( LA(1)) {
450 case NUM_INT:
451 case NUM_LONG:
452 {
453 intConst();
454 astFactory->addASTChild( currentAST, returnAST );
455 constant_AST = currentAST.root;
456 break;
457 }
458 case NUM_FLOAT:
459 case NUM_DOUBLE:
460 {
461 floatConst();
462 astFactory->addASTChild( currentAST, returnAST );
463 constant_AST = currentAST.root;
464 break;
465 }
466 case LPAREN:
467 {
468 vectorConst();
469 astFactory->addASTChild( currentAST, returnAST );
470 constant_AST = currentAST.root;
471 break;
472 }
473 case ID:
474 {
475 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
476 tmp25_AST = astFactory->create(LT(1));
477 astFactory->addASTChild(currentAST, tmp25_AST);
478 match(ID);
479 constant_AST = currentAST.root;
480 break;
481 }
482 case StringLiteral:
483 {
484 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
485 tmp26_AST = astFactory->create(LT(1));
486 astFactory->addASTChild(currentAST, tmp26_AST);
487 match(StringLiteral);
488 constant_AST = currentAST.root;
489 break;
490 }
491 default:
492 {
493 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
494 }
495 }
496 }
497 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
498 reportError(ex);
499 recover(ex,_tokenSet_5);
500 }
501 returnAST = constant_AST;
502 }
503
504 void MDParser::intConst() {
505 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
506 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
507 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
508
509 try { // for error handling
510 switch ( LA(1)) {
511 case NUM_INT:
512 {
513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514 tmp27_AST = astFactory->create(LT(1));
515 astFactory->addASTChild(currentAST, tmp27_AST);
516 match(NUM_INT);
517 intConst_AST = currentAST.root;
518 break;
519 }
520 case NUM_LONG:
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(NUM_LONG);
526 intConst_AST = currentAST.root;
527 break;
528 }
529 default:
530 {
531 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
532 }
533 }
534 }
535 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
536 reportError(ex);
537 recover(ex,_tokenSet_6);
538 }
539 returnAST = intConst_AST;
540 }
541
542 void MDParser::floatConst() {
543 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
544 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
545 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
546
547 try { // for error handling
548 switch ( LA(1)) {
549 case NUM_FLOAT:
550 {
551 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
552 tmp29_AST = astFactory->create(LT(1));
553 astFactory->addASTChild(currentAST, tmp29_AST);
554 match(NUM_FLOAT);
555 floatConst_AST = currentAST.root;
556 break;
557 }
558 case NUM_DOUBLE:
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_DOUBLE);
564 floatConst_AST = currentAST.root;
565 break;
566 }
567 default:
568 {
569 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
570 }
571 }
572 }
573 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
574 reportError(ex);
575 recover(ex,_tokenSet_7);
576 }
577 returnAST = floatConst_AST;
578 }
579
580 void MDParser::vectorConst() {
581 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
582 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
583 ANTLR_USE_NAMESPACE(antlr)RefAST vectorConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
584
585 try { // for error handling
586 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
587 tmp31_AST = astFactory->create(LT(1));
588 astFactory->makeASTRoot(currentAST, tmp31_AST);
589 match(LPAREN);
590 doubleNumber();
591 astFactory->addASTChild( currentAST, returnAST );
592 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
593 tmp32_AST = astFactory->create(LT(1));
594 astFactory->addASTChild(currentAST, tmp32_AST);
595 match(COMMA);
596 doubleNumber();
597 astFactory->addASTChild( currentAST, returnAST );
598 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
599 tmp33_AST = astFactory->create(LT(1));
600 astFactory->addASTChild(currentAST, tmp33_AST);
601 match(COMMA);
602 doubleNumber();
603 astFactory->addASTChild( currentAST, returnAST );
604 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
605 tmp34_AST = astFactory->create(LT(1));
606 astFactory->addASTChild(currentAST, tmp34_AST);
607 match(RPAREN);
608 vectorConst_AST = currentAST.root;
609 }
610 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
611 reportError(ex);
612 recover(ex,_tokenSet_5);
613 }
614 returnAST = vectorConst_AST;
615 }
616
617 void MDParser::moleculestatement() {
618 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
619 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
620 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
621
622 try { // for error handling
623 switch ( LA(1)) {
624 case ID:
625 {
626 assignment();
627 astFactory->addASTChild( currentAST, returnAST );
628 moleculestatement_AST = currentAST.root;
629 break;
630 }
631 case ATOM:
632 {
633 atomblock();
634 astFactory->addASTChild( currentAST, returnAST );
635 moleculestatement_AST = currentAST.root;
636 break;
637 }
638 case BOND:
639 {
640 bondblock();
641 astFactory->addASTChild( currentAST, returnAST );
642 moleculestatement_AST = currentAST.root;
643 break;
644 }
645 case BEND:
646 {
647 bendblock();
648 astFactory->addASTChild( currentAST, returnAST );
649 moleculestatement_AST = currentAST.root;
650 break;
651 }
652 case TORSION:
653 {
654 torsionblock();
655 astFactory->addASTChild( currentAST, returnAST );
656 moleculestatement_AST = currentAST.root;
657 break;
658 }
659 case INVERSION:
660 {
661 inversionblock();
662 astFactory->addASTChild( currentAST, returnAST );
663 moleculestatement_AST = currentAST.root;
664 break;
665 }
666 case RIGIDBODY:
667 {
668 rigidbodyblock();
669 astFactory->addASTChild( currentAST, returnAST );
670 moleculestatement_AST = currentAST.root;
671 break;
672 }
673 case CUTOFFGROUP:
674 {
675 cutoffgroupblock();
676 astFactory->addASTChild( currentAST, returnAST );
677 moleculestatement_AST = currentAST.root;
678 break;
679 }
680 case FRAGMENT:
681 {
682 fragmentblock();
683 astFactory->addASTChild( currentAST, returnAST );
684 moleculestatement_AST = currentAST.root;
685 break;
686 }
687 case CONSTRAINT:
688 {
689 constraintblock();
690 astFactory->addASTChild( currentAST, returnAST );
691 moleculestatement_AST = currentAST.root;
692 break;
693 }
694 default:
695 {
696 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
697 }
698 }
699 }
700 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
701 reportError(ex);
702 recover(ex,_tokenSet_8);
703 }
704 returnAST = moleculestatement_AST;
705 }
706
707 void MDParser::atomblock() {
708 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
709 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
710 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
711
712 try { // for error handling
713 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
714 tmp35_AST = astFactory->create(LT(1));
715 astFactory->makeASTRoot(currentAST, tmp35_AST);
716 match(ATOM);
717 match(LBRACKET);
718 intConst();
719 astFactory->addASTChild( currentAST, returnAST );
720 match(RBRACKET);
721 match(LCURLY);
722 { // ( ... )*
723 for (;;) {
724 if ((_tokenSet_9.member(LA(1)))) {
725 atomstatement();
726 astFactory->addASTChild( currentAST, returnAST );
727 }
728 else {
729 goto _loop31;
730 }
731
732 }
733 _loop31:;
734 } // ( ... )*
735 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
736 tmp39_AST = astFactory->create(LT(1));
737 astFactory->addASTChild(currentAST, tmp39_AST);
738 match(RCURLY);
739 #line 110 "MDParser.g"
740 tmp39_AST->setType(ENDBLOCK);
741 #line 742 "MDParser.cpp"
742 atomblock_AST = currentAST.root;
743 }
744 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
745 reportError(ex);
746 recover(ex,_tokenSet_8);
747 }
748 returnAST = atomblock_AST;
749 }
750
751 void MDParser::bondblock() {
752 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
753 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
754 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755
756 try { // for error handling
757 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
758 tmp40_AST = astFactory->create(LT(1));
759 astFactory->makeASTRoot(currentAST, tmp40_AST);
760 match(BOND);
761 {
762 switch ( LA(1)) {
763 case LBRACKET:
764 {
765 match(LBRACKET);
766 intConst();
767 match(RBRACKET);
768 break;
769 }
770 case LCURLY:
771 {
772 break;
773 }
774 default:
775 {
776 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
777 }
778 }
779 }
780 match(LCURLY);
781 { // ( ... )*
782 for (;;) {
783 if ((LA(1) == MEMBERS || LA(1) == ID)) {
784 bondstatement();
785 astFactory->addASTChild( currentAST, returnAST );
786 }
787 else {
788 goto _loop36;
789 }
790
791 }
792 _loop36:;
793 } // ( ... )*
794 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
795 tmp44_AST = astFactory->create(LT(1));
796 astFactory->addASTChild(currentAST, tmp44_AST);
797 match(RCURLY);
798 #line 119 "MDParser.g"
799 tmp44_AST->setType(ENDBLOCK);
800 #line 801 "MDParser.cpp"
801 bondblock_AST = currentAST.root;
802 }
803 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
804 reportError(ex);
805 recover(ex,_tokenSet_8);
806 }
807 returnAST = bondblock_AST;
808 }
809
810 void MDParser::bendblock() {
811 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
812 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
813 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
814
815 try { // for error handling
816 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
817 tmp45_AST = astFactory->create(LT(1));
818 astFactory->makeASTRoot(currentAST, tmp45_AST);
819 match(BEND);
820 {
821 switch ( LA(1)) {
822 case LBRACKET:
823 {
824 match(LBRACKET);
825 intConst();
826 match(RBRACKET);
827 break;
828 }
829 case LCURLY:
830 {
831 break;
832 }
833 default:
834 {
835 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
836 }
837 }
838 }
839 match(LCURLY);
840 { // ( ... )*
841 for (;;) {
842 if ((LA(1) == MEMBERS || LA(1) == ID)) {
843 bendstatement();
844 astFactory->addASTChild( currentAST, returnAST );
845 }
846 else {
847 goto _loop41;
848 }
849
850 }
851 _loop41:;
852 } // ( ... )*
853 ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
854 tmp49_AST = astFactory->create(LT(1));
855 astFactory->addASTChild(currentAST, tmp49_AST);
856 match(RCURLY);
857 #line 126 "MDParser.g"
858 tmp49_AST->setType(ENDBLOCK);
859 #line 860 "MDParser.cpp"
860 bendblock_AST = currentAST.root;
861 }
862 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
863 reportError(ex);
864 recover(ex,_tokenSet_8);
865 }
866 returnAST = bendblock_AST;
867 }
868
869 void MDParser::torsionblock() {
870 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
871 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
872 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
873
874 try { // for error handling
875 ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
876 tmp50_AST = astFactory->create(LT(1));
877 astFactory->makeASTRoot(currentAST, tmp50_AST);
878 match(TORSION);
879 {
880 switch ( LA(1)) {
881 case LBRACKET:
882 {
883 match(LBRACKET);
884 intConst();
885 match(RBRACKET);
886 break;
887 }
888 case LCURLY:
889 {
890 break;
891 }
892 default:
893 {
894 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
895 }
896 }
897 }
898 match(LCURLY);
899 { // ( ... )*
900 for (;;) {
901 if ((LA(1) == MEMBERS || LA(1) == ID)) {
902 torsionstatement();
903 astFactory->addASTChild( currentAST, returnAST );
904 }
905 else {
906 goto _loop46;
907 }
908
909 }
910 _loop46:;
911 } // ( ... )*
912 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
913 tmp54_AST = astFactory->create(LT(1));
914 astFactory->addASTChild(currentAST, tmp54_AST);
915 match(RCURLY);
916 #line 133 "MDParser.g"
917 tmp54_AST->setType(ENDBLOCK);
918 #line 919 "MDParser.cpp"
919 torsionblock_AST = currentAST.root;
920 }
921 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
922 reportError(ex);
923 recover(ex,_tokenSet_8);
924 }
925 returnAST = torsionblock_AST;
926 }
927
928 void MDParser::inversionblock() {
929 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
930 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
931 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
932
933 try { // for error handling
934 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
935 tmp55_AST = astFactory->create(LT(1));
936 astFactory->makeASTRoot(currentAST, tmp55_AST);
937 match(INVERSION);
938 {
939 switch ( LA(1)) {
940 case LBRACKET:
941 {
942 match(LBRACKET);
943 intConst();
944 match(RBRACKET);
945 break;
946 }
947 case LCURLY:
948 {
949 break;
950 }
951 default:
952 {
953 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
954 }
955 }
956 }
957 match(LCURLY);
958 { // ( ... )*
959 for (;;) {
960 if ((_tokenSet_10.member(LA(1)))) {
961 inversionstatement();
962 astFactory->addASTChild( currentAST, returnAST );
963 }
964 else {
965 goto _loop51;
966 }
967
968 }
969 _loop51:;
970 } // ( ... )*
971 ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
972 tmp59_AST = astFactory->create(LT(1));
973 astFactory->addASTChild(currentAST, tmp59_AST);
974 match(RCURLY);
975 #line 140 "MDParser.g"
976 tmp59_AST->setType(ENDBLOCK);
977 #line 978 "MDParser.cpp"
978 inversionblock_AST = currentAST.root;
979 }
980 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
981 reportError(ex);
982 recover(ex,_tokenSet_8);
983 }
984 returnAST = inversionblock_AST;
985 }
986
987 void MDParser::rigidbodyblock() {
988 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
989 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
990 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
991
992 try { // for error handling
993 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
994 tmp60_AST = astFactory->create(LT(1));
995 astFactory->makeASTRoot(currentAST, tmp60_AST);
996 match(RIGIDBODY);
997 match(LBRACKET);
998 intConst();
999 astFactory->addASTChild( currentAST, returnAST );
1000 match(RBRACKET);
1001 match(LCURLY);
1002 { // ( ... )*
1003 for (;;) {
1004 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1005 rigidbodystatement();
1006 astFactory->addASTChild( currentAST, returnAST );
1007 }
1008 else {
1009 goto _loop55;
1010 }
1011
1012 }
1013 _loop55:;
1014 } // ( ... )*
1015 ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1016 tmp64_AST = astFactory->create(LT(1));
1017 astFactory->addASTChild(currentAST, tmp64_AST);
1018 match(RCURLY);
1019 #line 148 "MDParser.g"
1020 tmp64_AST->setType(ENDBLOCK);
1021 #line 1022 "MDParser.cpp"
1022 rigidbodyblock_AST = currentAST.root;
1023 }
1024 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1025 reportError(ex);
1026 recover(ex,_tokenSet_8);
1027 }
1028 returnAST = rigidbodyblock_AST;
1029 }
1030
1031 void MDParser::cutoffgroupblock() {
1032 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1033 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1034 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1035
1036 try { // for error handling
1037 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1038 tmp65_AST = astFactory->create(LT(1));
1039 astFactory->makeASTRoot(currentAST, tmp65_AST);
1040 match(CUTOFFGROUP);
1041 {
1042 switch ( LA(1)) {
1043 case LBRACKET:
1044 {
1045 match(LBRACKET);
1046 intConst();
1047 match(RBRACKET);
1048 break;
1049 }
1050 case LCURLY:
1051 {
1052 break;
1053 }
1054 default:
1055 {
1056 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1057 }
1058 }
1059 }
1060 match(LCURLY);
1061 { // ( ... )*
1062 for (;;) {
1063 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1064 cutoffgroupstatement();
1065 astFactory->addASTChild( currentAST, returnAST );
1066 }
1067 else {
1068 goto _loop60;
1069 }
1070
1071 }
1072 _loop60:;
1073 } // ( ... )*
1074 ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1075 tmp69_AST = astFactory->create(LT(1));
1076 astFactory->addASTChild(currentAST, tmp69_AST);
1077 match(RCURLY);
1078 #line 155 "MDParser.g"
1079 tmp69_AST->setType(ENDBLOCK);
1080 #line 1081 "MDParser.cpp"
1081 cutoffgroupblock_AST = currentAST.root;
1082 }
1083 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1084 reportError(ex);
1085 recover(ex,_tokenSet_8);
1086 }
1087 returnAST = cutoffgroupblock_AST;
1088 }
1089
1090 void MDParser::fragmentblock() {
1091 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1092 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1093 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1094
1095 try { // for error handling
1096 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1097 tmp70_AST = astFactory->create(LT(1));
1098 astFactory->makeASTRoot(currentAST, tmp70_AST);
1099 match(FRAGMENT);
1100 match(LBRACKET);
1101 intConst();
1102 astFactory->addASTChild( currentAST, returnAST );
1103 match(RBRACKET);
1104 match(LCURLY);
1105 { // ( ... )*
1106 for (;;) {
1107 if ((LA(1) == ID)) {
1108 fragmentstatement();
1109 astFactory->addASTChild( currentAST, returnAST );
1110 }
1111 else {
1112 goto _loop64;
1113 }
1114
1115 }
1116 _loop64:;
1117 } // ( ... )*
1118 ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1119 tmp74_AST = astFactory->create(LT(1));
1120 astFactory->addASTChild(currentAST, tmp74_AST);
1121 match(RCURLY);
1122 #line 162 "MDParser.g"
1123 tmp74_AST->setType(ENDBLOCK);
1124 #line 1125 "MDParser.cpp"
1125 fragmentblock_AST = currentAST.root;
1126 }
1127 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1128 reportError(ex);
1129 recover(ex,_tokenSet_8);
1130 }
1131 returnAST = fragmentblock_AST;
1132 }
1133
1134 void MDParser::constraintblock() {
1135 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1136 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1137 ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1138
1139 try { // for error handling
1140 ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1141 tmp75_AST = astFactory->create(LT(1));
1142 astFactory->makeASTRoot(currentAST, tmp75_AST);
1143 match(CONSTRAINT);
1144 {
1145 switch ( LA(1)) {
1146 case LBRACKET:
1147 {
1148 match(LBRACKET);
1149 intConst();
1150 match(RBRACKET);
1151 break;
1152 }
1153 case LCURLY:
1154 {
1155 break;
1156 }
1157 default:
1158 {
1159 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1160 }
1161 }
1162 }
1163 match(LCURLY);
1164 { // ( ... )*
1165 for (;;) {
1166 if ((LA(1) == MEMBERS || LA(1) == ID)) {
1167 constraintstatement();
1168 astFactory->addASTChild( currentAST, returnAST );
1169 }
1170 else {
1171 goto _loop69;
1172 }
1173
1174 }
1175 _loop69:;
1176 } // ( ... )*
1177 ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1178 tmp79_AST = astFactory->create(LT(1));
1179 astFactory->addASTChild(currentAST, tmp79_AST);
1180 match(RCURLY);
1181 #line 168 "MDParser.g"
1182 tmp79_AST->setType(ENDBLOCK);
1183 #line 1184 "MDParser.cpp"
1184 constraintblock_AST = currentAST.root;
1185 }
1186 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1187 reportError(ex);
1188 recover(ex,_tokenSet_8);
1189 }
1190 returnAST = constraintblock_AST;
1191 }
1192
1193 void MDParser::atomstatement() {
1194 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1195 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1196 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1197
1198 try { // for error handling
1199 switch ( LA(1)) {
1200 case ID:
1201 {
1202 assignment();
1203 astFactory->addASTChild( currentAST, returnAST );
1204 atomstatement_AST = currentAST.root;
1205 break;
1206 }
1207 case POSITION:
1208 {
1209 ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1210 tmp80_AST = astFactory->create(LT(1));
1211 astFactory->makeASTRoot(currentAST, tmp80_AST);
1212 match(POSITION);
1213 match(LPAREN);
1214 doubleNumberTuple();
1215 astFactory->addASTChild( currentAST, returnAST );
1216 match(RPAREN);
1217 match(SEMICOLON);
1218 atomstatement_AST = currentAST.root;
1219 break;
1220 }
1221 case ORIENTATION:
1222 {
1223 ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1224 tmp84_AST = astFactory->create(LT(1));
1225 astFactory->makeASTRoot(currentAST, tmp84_AST);
1226 match(ORIENTATION);
1227 match(LPAREN);
1228 doubleNumberTuple();
1229 astFactory->addASTChild( currentAST, returnAST );
1230 match(RPAREN);
1231 match(SEMICOLON);
1232 atomstatement_AST = currentAST.root;
1233 break;
1234 }
1235 default:
1236 {
1237 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1238 }
1239 }
1240 }
1241 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1242 reportError(ex);
1243 recover(ex,_tokenSet_11);
1244 }
1245 returnAST = atomstatement_AST;
1246 }
1247
1248 void MDParser::doubleNumberTuple() {
1249 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1250 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1251 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1252
1253 try { // for error handling
1254 doubleNumber();
1255 astFactory->addASTChild( currentAST, returnAST );
1256 { // ( ... )*
1257 for (;;) {
1258 if ((LA(1) == COMMA)) {
1259 match(COMMA);
1260 doubleNumber();
1261 astFactory->addASTChild( currentAST, returnAST );
1262 }
1263 else {
1264 goto _loop73;
1265 }
1266
1267 }
1268 _loop73:;
1269 } // ( ... )*
1270 doubleNumberTuple_AST = currentAST.root;
1271 }
1272 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1273 reportError(ex);
1274 recover(ex,_tokenSet_12);
1275 }
1276 returnAST = doubleNumberTuple_AST;
1277 }
1278
1279 void MDParser::bondstatement() {
1280 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1281 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1282 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1283
1284 try { // for error handling
1285 switch ( LA(1)) {
1286 case ID:
1287 {
1288 assignment();
1289 astFactory->addASTChild( currentAST, returnAST );
1290 bondstatement_AST = currentAST.root;
1291 break;
1292 }
1293 case MEMBERS:
1294 {
1295 ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1296 tmp89_AST = astFactory->create(LT(1));
1297 astFactory->makeASTRoot(currentAST, tmp89_AST);
1298 match(MEMBERS);
1299 match(LPAREN);
1300 inttuple();
1301 astFactory->addASTChild( currentAST, returnAST );
1302 match(RPAREN);
1303 match(SEMICOLON);
1304 bondstatement_AST = currentAST.root;
1305 break;
1306 }
1307 default:
1308 {
1309 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1310 }
1311 }
1312 }
1313 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1314 reportError(ex);
1315 recover(ex,_tokenSet_13);
1316 }
1317 returnAST = bondstatement_AST;
1318 }
1319
1320 void MDParser::inttuple() {
1321 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1322 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1323 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1324
1325 try { // for error handling
1326 intConst();
1327 astFactory->addASTChild( currentAST, returnAST );
1328 { // ( ... )*
1329 for (;;) {
1330 if ((LA(1) == COMMA)) {
1331 match(COMMA);
1332 intConst();
1333 astFactory->addASTChild( currentAST, returnAST );
1334 }
1335 else {
1336 goto _loop76;
1337 }
1338
1339 }
1340 _loop76:;
1341 } // ( ... )*
1342 inttuple_AST = currentAST.root;
1343 }
1344 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1345 reportError(ex);
1346 recover(ex,_tokenSet_12);
1347 }
1348 returnAST = inttuple_AST;
1349 }
1350
1351 void MDParser::bendstatement() {
1352 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1353 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1354 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1355
1356 try { // for error handling
1357 switch ( LA(1)) {
1358 case ID:
1359 {
1360 assignment();
1361 astFactory->addASTChild( currentAST, returnAST );
1362 bendstatement_AST = currentAST.root;
1363 break;
1364 }
1365 case MEMBERS:
1366 {
1367 ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1368 tmp94_AST = astFactory->create(LT(1));
1369 astFactory->makeASTRoot(currentAST, tmp94_AST);
1370 match(MEMBERS);
1371 match(LPAREN);
1372 inttuple();
1373 astFactory->addASTChild( currentAST, returnAST );
1374 match(RPAREN);
1375 match(SEMICOLON);
1376 bendstatement_AST = currentAST.root;
1377 break;
1378 }
1379 default:
1380 {
1381 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1382 }
1383 }
1384 }
1385 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1386 reportError(ex);
1387 recover(ex,_tokenSet_13);
1388 }
1389 returnAST = bendstatement_AST;
1390 }
1391
1392 void MDParser::torsionstatement() {
1393 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1394 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1395 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1396
1397 try { // for error handling
1398 switch ( LA(1)) {
1399 case ID:
1400 {
1401 assignment();
1402 astFactory->addASTChild( currentAST, returnAST );
1403 torsionstatement_AST = currentAST.root;
1404 break;
1405 }
1406 case MEMBERS:
1407 {
1408 ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1409 tmp98_AST = astFactory->create(LT(1));
1410 astFactory->makeASTRoot(currentAST, tmp98_AST);
1411 match(MEMBERS);
1412 match(LPAREN);
1413 inttuple();
1414 astFactory->addASTChild( currentAST, returnAST );
1415 match(RPAREN);
1416 match(SEMICOLON);
1417 torsionstatement_AST = currentAST.root;
1418 break;
1419 }
1420 default:
1421 {
1422 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1423 }
1424 }
1425 }
1426 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1427 reportError(ex);
1428 recover(ex,_tokenSet_13);
1429 }
1430 returnAST = torsionstatement_AST;
1431 }
1432
1433 void MDParser::inversionstatement() {
1434 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1435 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1436 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1437
1438 try { // for error handling
1439 switch ( LA(1)) {
1440 case ID:
1441 {
1442 assignment();
1443 astFactory->addASTChild( currentAST, returnAST );
1444 inversionstatement_AST = currentAST.root;
1445 break;
1446 }
1447 case CENTER:
1448 {
1449 ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1450 tmp102_AST = astFactory->create(LT(1));
1451 astFactory->makeASTRoot(currentAST, tmp102_AST);
1452 match(CENTER);
1453 match(LPAREN);
1454 intConst();
1455 astFactory->addASTChild( currentAST, returnAST );
1456 match(RPAREN);
1457 match(SEMICOLON);
1458 inversionstatement_AST = currentAST.root;
1459 break;
1460 }
1461 case SATELLITES:
1462 {
1463 ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1464 tmp106_AST = astFactory->create(LT(1));
1465 astFactory->makeASTRoot(currentAST, tmp106_AST);
1466 match(SATELLITES);
1467 match(LPAREN);
1468 inttuple();
1469 astFactory->addASTChild( currentAST, returnAST );
1470 match(RPAREN);
1471 match(SEMICOLON);
1472 inversionstatement_AST = currentAST.root;
1473 break;
1474 }
1475 default:
1476 {
1477 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1478 }
1479 }
1480 }
1481 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1482 reportError(ex);
1483 recover(ex,_tokenSet_14);
1484 }
1485 returnAST = inversionstatement_AST;
1486 }
1487
1488 void MDParser::rigidbodystatement() {
1489 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1490 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1491 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1492
1493 try { // for error handling
1494 switch ( LA(1)) {
1495 case ID:
1496 {
1497 assignment();
1498 astFactory->addASTChild( currentAST, returnAST );
1499 rigidbodystatement_AST = currentAST.root;
1500 break;
1501 }
1502 case MEMBERS:
1503 {
1504 ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1505 tmp110_AST = astFactory->create(LT(1));
1506 astFactory->makeASTRoot(currentAST, tmp110_AST);
1507 match(MEMBERS);
1508 match(LPAREN);
1509 inttuple();
1510 astFactory->addASTChild( currentAST, returnAST );
1511 match(RPAREN);
1512 match(SEMICOLON);
1513 rigidbodystatement_AST = currentAST.root;
1514 break;
1515 }
1516 default:
1517 {
1518 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1519 }
1520 }
1521 }
1522 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1523 reportError(ex);
1524 recover(ex,_tokenSet_13);
1525 }
1526 returnAST = rigidbodystatement_AST;
1527 }
1528
1529 void MDParser::cutoffgroupstatement() {
1530 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1531 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1532 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1533
1534 try { // for error handling
1535 switch ( LA(1)) {
1536 case ID:
1537 {
1538 assignment();
1539 astFactory->addASTChild( currentAST, returnAST );
1540 cutoffgroupstatement_AST = currentAST.root;
1541 break;
1542 }
1543 case MEMBERS:
1544 {
1545 ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1546 tmp114_AST = astFactory->create(LT(1));
1547 astFactory->makeASTRoot(currentAST, tmp114_AST);
1548 match(MEMBERS);
1549 match(LPAREN);
1550 inttuple();
1551 astFactory->addASTChild( currentAST, returnAST );
1552 match(RPAREN);
1553 match(SEMICOLON);
1554 cutoffgroupstatement_AST = currentAST.root;
1555 break;
1556 }
1557 default:
1558 {
1559 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1560 }
1561 }
1562 }
1563 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1564 reportError(ex);
1565 recover(ex,_tokenSet_13);
1566 }
1567 returnAST = cutoffgroupstatement_AST;
1568 }
1569
1570 void MDParser::fragmentstatement() {
1571 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1572 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1573 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1574
1575 try { // for error handling
1576 assignment();
1577 astFactory->addASTChild( currentAST, returnAST );
1578 fragmentstatement_AST = currentAST.root;
1579 }
1580 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1581 reportError(ex);
1582 recover(ex,_tokenSet_15);
1583 }
1584 returnAST = fragmentstatement_AST;
1585 }
1586
1587 void MDParser::constraintstatement() {
1588 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1589 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1590 ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1591
1592 try { // for error handling
1593 switch ( LA(1)) {
1594 case ID:
1595 {
1596 assignment();
1597 astFactory->addASTChild( currentAST, returnAST );
1598 constraintstatement_AST = currentAST.root;
1599 break;
1600 }
1601 case MEMBERS:
1602 {
1603 ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1604 tmp118_AST = astFactory->create(LT(1));
1605 astFactory->makeASTRoot(currentAST, tmp118_AST);
1606 match(MEMBERS);
1607 match(LPAREN);
1608 inttuple();
1609 astFactory->addASTChild( currentAST, returnAST );
1610 match(RPAREN);
1611 match(SEMICOLON);
1612 constraintstatement_AST = currentAST.root;
1613 break;
1614 }
1615 default:
1616 {
1617 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1618 }
1619 }
1620 }
1621 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1622 reportError(ex);
1623 recover(ex,_tokenSet_13);
1624 }
1625 returnAST = constraintstatement_AST;
1626 }
1627
1628 void MDParser::doubleNumber() {
1629 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1630 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1631 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1632
1633 try { // for error handling
1634 {
1635 switch ( LA(1)) {
1636 case NUM_INT:
1637 case NUM_LONG:
1638 {
1639 intConst();
1640 astFactory->addASTChild( currentAST, returnAST );
1641 break;
1642 }
1643 case NUM_FLOAT:
1644 case NUM_DOUBLE:
1645 {
1646 floatConst();
1647 astFactory->addASTChild( currentAST, returnAST );
1648 break;
1649 }
1650 default:
1651 {
1652 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1653 }
1654 }
1655 }
1656 doubleNumber_AST = currentAST.root;
1657 }
1658 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1659 reportError(ex);
1660 recover(ex,_tokenSet_16);
1661 }
1662 returnAST = doubleNumber_AST;
1663 }
1664
1665 void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1666 {
1667 factory.setMaxNodeType(59);
1668 }
1669 const char* MDParser::tokenNames[] = {
1670 "<0>",
1671 "EOF",
1672 "<2>",
1673 "NULL_TREE_LOOKAHEAD",
1674 "\"component\"",
1675 "\"molecule\"",
1676 "\"zconstraint\"",
1677 "\"restraint\"",
1678 "\"atom\"",
1679 "\"bond\"",
1680 "\"bend\"",
1681 "\"torsion\"",
1682 "\"inversion\"",
1683 "\"rigidBody\"",
1684 "\"cutoffGroup\"",
1685 "\"constraint\"",
1686 "\"distance\"",
1687 "\"fragment\"",
1688 "\"members\"",
1689 "\"center\"",
1690 "\"satellites\"",
1691 "\"position\"",
1692 "\"orientation\"",
1693 "\"flucQ\"",
1694 "\"RNEMD\"",
1695 "\"minimizer\"",
1696 "ENDBLOCK",
1697 "ID",
1698 "ASSIGNEQUAL",
1699 "SEMICOLON",
1700 "StringLiteral",
1701 "LCURLY",
1702 "RCURLY",
1703 "LBRACKET",
1704 "RBRACKET",
1705 "LPAREN",
1706 "RPAREN",
1707 "COMMA",
1708 "NUM_INT",
1709 "NUM_LONG",
1710 "NUM_FLOAT",
1711 "NUM_DOUBLE",
1712 "DOT",
1713 "COLON",
1714 "QUESTIONMARK",
1715 "Whitespace",
1716 "Comment",
1717 "CPPComment",
1718 "a line directive",
1719 "LineDirective",
1720 "Space",
1721 "CharLiteral",
1722 "EndOfLine",
1723 "Escape",
1724 "Vocabulary",
1725 "Digit",
1726 "Decimal",
1727 "HEX_DIGIT",
1728 "EXPONENT",
1729 "FLOAT_SUFFIX",
1730 0
1731 };
1732
1733 const unsigned long MDParser::_tokenSet_0_data_[] = { 192938224UL, 0UL, 0UL, 0UL };
1734 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1735 // ID
1736 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1737 const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1738 // EOF
1739 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1740 const unsigned long MDParser::_tokenSet_2_data_[] = { 192938226UL, 0UL, 0UL, 0UL };
1741 // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1742 // "minimizer" ID
1743 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1744 const unsigned long MDParser::_tokenSet_3_data_[] = { 201261042UL, 1UL, 0UL, 0UL };
1745 // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1746 // "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment"
1747 // "members" "center" "satellites" "position" "orientation" "flucQ" "RNEMD"
1748 // "minimizer" ID RCURLY
1749 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1750 const unsigned long MDParser::_tokenSet_4_data_[] = { 134414080UL, 0UL, 0UL, 0UL };
1751 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1752 // "constraint" "fragment" ID
1753 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1754 const unsigned long MDParser::_tokenSet_5_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1755 // SEMICOLON
1756 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1757 const unsigned long MDParser::_tokenSet_6_data_[] = { 536870912UL, 52UL, 0UL, 0UL };
1758 // SEMICOLON RBRACKET RPAREN COMMA
1759 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1760 const unsigned long MDParser::_tokenSet_7_data_[] = { 536870912UL, 48UL, 0UL, 0UL };
1761 // SEMICOLON RPAREN COMMA
1762 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1763 const unsigned long MDParser::_tokenSet_8_data_[] = { 134414080UL, 1UL, 0UL, 0UL };
1764 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1765 // "constraint" "fragment" ID RCURLY
1766 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1767 const unsigned long MDParser::_tokenSet_9_data_[] = { 140509184UL, 0UL, 0UL, 0UL };
1768 // "position" "orientation" ID
1769 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1770 const unsigned long MDParser::_tokenSet_10_data_[] = { 135790592UL, 0UL, 0UL, 0UL };
1771 // "center" "satellites" ID
1772 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1773 const unsigned long MDParser::_tokenSet_11_data_[] = { 140509184UL, 1UL, 0UL, 0UL };
1774 // "position" "orientation" ID RCURLY
1775 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1776 const unsigned long MDParser::_tokenSet_12_data_[] = { 0UL, 16UL, 0UL, 0UL };
1777 // RPAREN
1778 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1779 const unsigned long MDParser::_tokenSet_13_data_[] = { 134479872UL, 1UL, 0UL, 0UL };
1780 // "members" ID RCURLY
1781 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1782 const unsigned long MDParser::_tokenSet_14_data_[] = { 135790592UL, 1UL, 0UL, 0UL };
1783 // "center" "satellites" ID RCURLY
1784 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1785 const unsigned long MDParser::_tokenSet_15_data_[] = { 134217728UL, 1UL, 0UL, 0UL };
1786 // ID RCURLY
1787 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1788 const unsigned long MDParser::_tokenSet_16_data_[] = { 0UL, 48UL, 0UL, 0UL };
1789 // RPAREN COMMA
1790 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
1791
1792

Properties

Name Value
svn:keywords Author Id Revision Date