ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDParser.cpp
Revision: 1277
Committed: Mon Jul 14 12:35:58 2008 UTC (17 years, 3 months ago) by gezelter
File size: 37864 byte(s)
Log Message: 
Changes for implementing Amber force field:  Added Inversions and
worked on BaseAtomTypes so that they'd function with the fortran side.

File Contents

# User Rev Content
1 gezelter 1277 /* $ANTLR 2.7.7 (20080702): "MDParser.g" -> "MDParser.cpp"$ */
2 tim 770 #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 gezelter 1277 recover(ex,_tokenSet_1);
57 tim 770 }
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     default:
97     {
98     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
99     }
100     }
101     }
102     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
103     reportError(ex);
104 gezelter 1277 recover(ex,_tokenSet_2);
105 tim 770 }
106     returnAST = statement_AST;
107     }
108    
109     void MDParser::assignment() {
110     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
111     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
112     ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
113    
114     try { // for error handling
115     ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
116     tmp1_AST = astFactory->create(LT(1));
117     astFactory->addASTChild(currentAST, tmp1_AST);
118     match(ID);
119     ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
120     tmp2_AST = astFactory->create(LT(1));
121     astFactory->makeASTRoot(currentAST, tmp2_AST);
122     match(ASSIGNEQUAL);
123     constant();
124     astFactory->addASTChild( currentAST, returnAST );
125     match(SEMICOLON);
126     assignment_AST = currentAST.root;
127     }
128     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
129     reportError(ex);
130 gezelter 1277 recover(ex,_tokenSet_3);
131 tim 770 }
132     returnAST = assignment_AST;
133     }
134    
135     void MDParser::componentblock() {
136     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
137     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
138     ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
139    
140     try { // for error handling
141     ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
142     tmp4_AST = astFactory->create(LT(1));
143     astFactory->makeASTRoot(currentAST, tmp4_AST);
144     match(COMPONENT);
145     match(LCURLY);
146     { // ( ... )*
147     for (;;) {
148     if ((LA(1) == ID)) {
149     assignment();
150     astFactory->addASTChild( currentAST, returnAST );
151     }
152     else {
153     goto _loop9;
154     }
155    
156     }
157     _loop9:;
158     } // ( ... )*
159     ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
160     tmp6_AST = astFactory->create(LT(1));
161     astFactory->addASTChild(currentAST, tmp6_AST);
162     match(RCURLY);
163 cli2 1275 #line 65 "MDParser.g"
164 tim 770 tmp6_AST->setType(ENDBLOCK);
165 gezelter 1277 #line 166 "MDParser.cpp"
166 tim 770 componentblock_AST = currentAST.root;
167     }
168     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
169     reportError(ex);
170 gezelter 1277 recover(ex,_tokenSet_2);
171 tim 770 }
172     returnAST = componentblock_AST;
173     }
174    
175     void MDParser::moleculeblock() {
176     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
177     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
178     ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
179    
180     try { // for error handling
181     ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
182     tmp7_AST = astFactory->create(LT(1));
183     astFactory->makeASTRoot(currentAST, tmp7_AST);
184     match(MOLECULE);
185     match(LCURLY);
186     { // ( ... )*
187     for (;;) {
188     if ((_tokenSet_4.member(LA(1)))) {
189     moleculestatement();
190     astFactory->addASTChild( currentAST, returnAST );
191     }
192     else {
193     goto _loop15;
194     }
195    
196     }
197     _loop15:;
198     } // ( ... )*
199     ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
200     tmp9_AST = astFactory->create(LT(1));
201     astFactory->addASTChild(currentAST, tmp9_AST);
202     match(RCURLY);
203 cli2 1275 #line 71 "MDParser.g"
204 tim 770 tmp9_AST->setType(ENDBLOCK);
205 gezelter 1277 #line 206 "MDParser.cpp"
206 tim 770 moleculeblock_AST = currentAST.root;
207     }
208     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
209     reportError(ex);
210 gezelter 1277 recover(ex,_tokenSet_2);
211 tim 770 }
212     returnAST = moleculeblock_AST;
213     }
214    
215     void MDParser::zconstraintblock() {
216     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
217     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
218     ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
219    
220     try { // for error handling
221     ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
222     tmp10_AST = astFactory->create(LT(1));
223     astFactory->makeASTRoot(currentAST, tmp10_AST);
224     match(ZCONSTRAINT);
225     match(LCURLY);
226     { // ( ... )*
227     for (;;) {
228     if ((LA(1) == ID)) {
229     assignment();
230     astFactory->addASTChild( currentAST, returnAST );
231     }
232     else {
233     goto _loop12;
234     }
235    
236     }
237     _loop12:;
238     } // ( ... )*
239     ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
240     tmp12_AST = astFactory->create(LT(1));
241     astFactory->addASTChild(currentAST, tmp12_AST);
242     match(RCURLY);
243 cli2 1275 #line 68 "MDParser.g"
244 tim 770 tmp12_AST->setType(ENDBLOCK);
245 gezelter 1277 #line 246 "MDParser.cpp"
246 tim 770 zconstraintblock_AST = currentAST.root;
247     }
248     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
249     reportError(ex);
250 gezelter 1277 recover(ex,_tokenSet_2);
251 tim 770 }
252     returnAST = zconstraintblock_AST;
253     }
254    
255     void MDParser::constant() {
256     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
257     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
258     ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
259    
260     try { // for error handling
261     switch ( LA(1)) {
262 tim 814 case NUM_INT:
263     case NUM_LONG:
264 tim 770 {
265 tim 814 intConst();
266 tim 770 astFactory->addASTChild( currentAST, returnAST );
267     constant_AST = currentAST.root;
268     break;
269     }
270 tim 814 case NUM_FLOAT:
271     case NUM_DOUBLE:
272     {
273     floatConst();
274     astFactory->addASTChild( currentAST, returnAST );
275     constant_AST = currentAST.root;
276     break;
277     }
278 tim 770 case ID:
279     {
280     ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
281     tmp13_AST = astFactory->create(LT(1));
282     astFactory->addASTChild(currentAST, tmp13_AST);
283     match(ID);
284     constant_AST = currentAST.root;
285     break;
286     }
287     case StringLiteral:
288     {
289     ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
290     tmp14_AST = astFactory->create(LT(1));
291     astFactory->addASTChild(currentAST, tmp14_AST);
292     match(StringLiteral);
293     constant_AST = currentAST.root;
294     break;
295     }
296     default:
297     {
298     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
299     }
300     }
301     }
302     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
303     reportError(ex);
304 gezelter 1277 recover(ex,_tokenSet_5);
305 tim 770 }
306     returnAST = constant_AST;
307     }
308    
309 tim 814 void MDParser::intConst() {
310 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
311     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
312 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
313 tim 770
314     try { // for error handling
315     switch ( LA(1)) {
316 tim 814 case NUM_INT:
317 tim 770 {
318 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
319     tmp15_AST = astFactory->create(LT(1));
320     astFactory->addASTChild(currentAST, tmp15_AST);
321     match(NUM_INT);
322     intConst_AST = currentAST.root;
323 tim 770 break;
324     }
325 tim 814 case NUM_LONG:
326 tim 770 {
327 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
328     tmp16_AST = astFactory->create(LT(1));
329     astFactory->addASTChild(currentAST, tmp16_AST);
330     match(NUM_LONG);
331     intConst_AST = currentAST.root;
332 tim 770 break;
333     }
334     default:
335     {
336     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
337     }
338     }
339     }
340     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
341     reportError(ex);
342 gezelter 1277 recover(ex,_tokenSet_6);
343 tim 770 }
344 tim 814 returnAST = intConst_AST;
345 tim 770 }
346    
347 tim 814 void MDParser::floatConst() {
348     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
349     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
350     ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
351    
352     try { // for error handling
353     switch ( LA(1)) {
354     case NUM_FLOAT:
355     {
356     ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
357     tmp17_AST = astFactory->create(LT(1));
358     astFactory->addASTChild(currentAST, tmp17_AST);
359     match(NUM_FLOAT);
360     floatConst_AST = currentAST.root;
361     break;
362     }
363     case NUM_DOUBLE:
364     {
365     ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
366     tmp18_AST = astFactory->create(LT(1));
367     astFactory->addASTChild(currentAST, tmp18_AST);
368     match(NUM_DOUBLE);
369     floatConst_AST = currentAST.root;
370     break;
371     }
372     default:
373     {
374     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
375     }
376     }
377     }
378     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
379     reportError(ex);
380 gezelter 1277 recover(ex,_tokenSet_7);
381 tim 814 }
382     returnAST = floatConst_AST;
383     }
384    
385 tim 770 void MDParser::moleculestatement() {
386     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
387     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
388     ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
389    
390     try { // for error handling
391     switch ( LA(1)) {
392     case ID:
393     {
394     assignment();
395     astFactory->addASTChild( currentAST, returnAST );
396     moleculestatement_AST = currentAST.root;
397     break;
398     }
399     case ATOM:
400     {
401     atomblock();
402     astFactory->addASTChild( currentAST, returnAST );
403     moleculestatement_AST = currentAST.root;
404     break;
405     }
406     case BOND:
407     {
408     bondblock();
409     astFactory->addASTChild( currentAST, returnAST );
410     moleculestatement_AST = currentAST.root;
411     break;
412     }
413     case BEND:
414     {
415     bendblock();
416     astFactory->addASTChild( currentAST, returnAST );
417     moleculestatement_AST = currentAST.root;
418     break;
419     }
420     case TORSION:
421     {
422     torsionblock();
423     astFactory->addASTChild( currentAST, returnAST );
424     moleculestatement_AST = currentAST.root;
425     break;
426     }
427 gezelter 1277 case INVERSION:
428     {
429     inversionblock();
430     astFactory->addASTChild( currentAST, returnAST );
431     moleculestatement_AST = currentAST.root;
432     break;
433     }
434 tim 770 case RIGIDBODY:
435     {
436     rigidbodyblock();
437     astFactory->addASTChild( currentAST, returnAST );
438     moleculestatement_AST = currentAST.root;
439     break;
440     }
441     case CUTOFFGROUP:
442     {
443     cutoffgroupblock();
444     astFactory->addASTChild( currentAST, returnAST );
445     moleculestatement_AST = currentAST.root;
446     break;
447     }
448     case FRAGMENT:
449     {
450     fragmentblock();
451     astFactory->addASTChild( currentAST, returnAST );
452     moleculestatement_AST = currentAST.root;
453     break;
454     }
455     default:
456     {
457     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
458     }
459     }
460     }
461     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
462     reportError(ex);
463 gezelter 1277 recover(ex,_tokenSet_8);
464 tim 770 }
465     returnAST = moleculestatement_AST;
466     }
467    
468     void MDParser::atomblock() {
469     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
470     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
471     ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
472    
473     try { // for error handling
474 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
475     tmp19_AST = astFactory->create(LT(1));
476     astFactory->makeASTRoot(currentAST, tmp19_AST);
477 tim 770 match(ATOM);
478     match(LBRACKET);
479     intConst();
480     astFactory->addASTChild( currentAST, returnAST );
481     match(RBRACKET);
482     match(LCURLY);
483     { // ( ... )*
484     for (;;) {
485 tim 814 if ((_tokenSet_9.member(LA(1)))) {
486 tim 770 atomstatement();
487     astFactory->addASTChild( currentAST, returnAST );
488     }
489     else {
490     goto _loop19;
491     }
492    
493     }
494     _loop19:;
495     } // ( ... )*
496 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
497     tmp23_AST = astFactory->create(LT(1));
498     astFactory->addASTChild(currentAST, tmp23_AST);
499 tim 770 match(RCURLY);
500 gezelter 1277 #line 85 "MDParser.g"
501 tim 814 tmp23_AST->setType(ENDBLOCK);
502 gezelter 1277 #line 503 "MDParser.cpp"
503 tim 770 atomblock_AST = currentAST.root;
504     }
505     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
506     reportError(ex);
507 gezelter 1277 recover(ex,_tokenSet_8);
508 tim 770 }
509     returnAST = atomblock_AST;
510     }
511    
512     void MDParser::bondblock() {
513     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
514     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
515     ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
516    
517     try { // for error handling
518 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
519     tmp24_AST = astFactory->create(LT(1));
520     astFactory->makeASTRoot(currentAST, tmp24_AST);
521 tim 770 match(BOND);
522     {
523     switch ( LA(1)) {
524     case LBRACKET:
525     {
526     match(LBRACKET);
527     intConst();
528     match(RBRACKET);
529     break;
530     }
531     case LCURLY:
532     {
533     break;
534     }
535     default:
536     {
537     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
538     }
539     }
540     }
541     match(LCURLY);
542     { // ( ... )*
543     for (;;) {
544     if ((LA(1) == MEMBERS || LA(1) == ID)) {
545     bondstatement();
546     astFactory->addASTChild( currentAST, returnAST );
547     }
548     else {
549     goto _loop24;
550     }
551    
552     }
553     _loop24:;
554     } // ( ... )*
555 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
556     tmp28_AST = astFactory->create(LT(1));
557     astFactory->addASTChild(currentAST, tmp28_AST);
558 tim 770 match(RCURLY);
559 gezelter 1277 #line 94 "MDParser.g"
560 tim 814 tmp28_AST->setType(ENDBLOCK);
561 gezelter 1277 #line 562 "MDParser.cpp"
562 tim 770 bondblock_AST = currentAST.root;
563     }
564     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
565     reportError(ex);
566 gezelter 1277 recover(ex,_tokenSet_8);
567 tim 770 }
568     returnAST = bondblock_AST;
569     }
570    
571     void MDParser::bendblock() {
572     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
573     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
574     ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
575    
576     try { // for error handling
577 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
578     tmp29_AST = astFactory->create(LT(1));
579     astFactory->makeASTRoot(currentAST, tmp29_AST);
580 tim 770 match(BEND);
581     {
582     switch ( LA(1)) {
583     case LBRACKET:
584     {
585     match(LBRACKET);
586     intConst();
587     match(RBRACKET);
588     break;
589     }
590     case LCURLY:
591     {
592     break;
593     }
594     default:
595     {
596     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
597     }
598     }
599     }
600     match(LCURLY);
601     { // ( ... )*
602     for (;;) {
603     if ((LA(1) == MEMBERS || LA(1) == ID)) {
604     bendstatement();
605     astFactory->addASTChild( currentAST, returnAST );
606     }
607     else {
608     goto _loop29;
609     }
610    
611     }
612     _loop29:;
613     } // ( ... )*
614 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
615     tmp33_AST = astFactory->create(LT(1));
616     astFactory->addASTChild(currentAST, tmp33_AST);
617 tim 770 match(RCURLY);
618 gezelter 1277 #line 101 "MDParser.g"
619 tim 814 tmp33_AST->setType(ENDBLOCK);
620 gezelter 1277 #line 621 "MDParser.cpp"
621 tim 770 bendblock_AST = currentAST.root;
622     }
623     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
624     reportError(ex);
625 gezelter 1277 recover(ex,_tokenSet_8);
626 tim 770 }
627     returnAST = bendblock_AST;
628     }
629    
630     void MDParser::torsionblock() {
631     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
632     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
633     ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
634    
635     try { // for error handling
636 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
637     tmp34_AST = astFactory->create(LT(1));
638     astFactory->makeASTRoot(currentAST, tmp34_AST);
639 tim 770 match(TORSION);
640     {
641     switch ( LA(1)) {
642     case LBRACKET:
643     {
644     match(LBRACKET);
645     intConst();
646     match(RBRACKET);
647     break;
648     }
649     case LCURLY:
650     {
651     break;
652     }
653     default:
654     {
655     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
656     }
657     }
658     }
659     match(LCURLY);
660     { // ( ... )*
661     for (;;) {
662     if ((LA(1) == MEMBERS || LA(1) == ID)) {
663     torsionstatement();
664     astFactory->addASTChild( currentAST, returnAST );
665     }
666     else {
667     goto _loop34;
668     }
669    
670     }
671     _loop34:;
672     } // ( ... )*
673 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
674     tmp38_AST = astFactory->create(LT(1));
675     astFactory->addASTChild(currentAST, tmp38_AST);
676 tim 770 match(RCURLY);
677 gezelter 1277 #line 108 "MDParser.g"
678 tim 814 tmp38_AST->setType(ENDBLOCK);
679 gezelter 1277 #line 680 "MDParser.cpp"
680 tim 770 torsionblock_AST = currentAST.root;
681     }
682     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
683     reportError(ex);
684 gezelter 1277 recover(ex,_tokenSet_8);
685 tim 770 }
686     returnAST = torsionblock_AST;
687     }
688    
689 gezelter 1277 void MDParser::inversionblock() {
690 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
691     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
692 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
693 tim 770
694     try { // for error handling
695 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
696     tmp39_AST = astFactory->create(LT(1));
697     astFactory->makeASTRoot(currentAST, tmp39_AST);
698 gezelter 1277 match(INVERSION);
699     {
700     switch ( LA(1)) {
701     case LBRACKET:
702     {
703     match(LBRACKET);
704     intConst();
705     match(RBRACKET);
706     break;
707     }
708     case LCURLY:
709     {
710     break;
711     }
712     default:
713     {
714     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
715     }
716     }
717     }
718     match(LCURLY);
719     { // ( ... )*
720     for (;;) {
721     if ((LA(1) == CENTER || LA(1) == ID)) {
722     inversionstatement();
723     astFactory->addASTChild( currentAST, returnAST );
724     }
725     else {
726     goto _loop39;
727     }
728    
729     }
730     _loop39:;
731     } // ( ... )*
732     ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
733     tmp43_AST = astFactory->create(LT(1));
734     astFactory->addASTChild(currentAST, tmp43_AST);
735     match(RCURLY);
736     #line 115 "MDParser.g"
737     tmp43_AST->setType(ENDBLOCK);
738     #line 739 "MDParser.cpp"
739     inversionblock_AST = currentAST.root;
740     }
741     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
742     reportError(ex);
743     recover(ex,_tokenSet_8);
744     }
745     returnAST = inversionblock_AST;
746     }
747    
748     void MDParser::rigidbodyblock() {
749     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
750     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
751     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
752    
753     try { // for error handling
754     ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755     tmp44_AST = astFactory->create(LT(1));
756     astFactory->makeASTRoot(currentAST, tmp44_AST);
757 tim 770 match(RIGIDBODY);
758     match(LBRACKET);
759     intConst();
760     astFactory->addASTChild( currentAST, returnAST );
761     match(RBRACKET);
762     match(LCURLY);
763     { // ( ... )*
764     for (;;) {
765     if ((LA(1) == MEMBERS || LA(1) == ID)) {
766     rigidbodystatement();
767     astFactory->addASTChild( currentAST, returnAST );
768     }
769     else {
770 cli2 1275 goto _loop43;
771 tim 770 }
772    
773     }
774 cli2 1275 _loop43:;
775 tim 770 } // ( ... )*
776 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
777     tmp48_AST = astFactory->create(LT(1));
778     astFactory->addASTChild(currentAST, tmp48_AST);
779 tim 770 match(RCURLY);
780 gezelter 1277 #line 122 "MDParser.g"
781     tmp48_AST->setType(ENDBLOCK);
782     #line 783 "MDParser.cpp"
783 tim 770 rigidbodyblock_AST = currentAST.root;
784     }
785     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
786     reportError(ex);
787 gezelter 1277 recover(ex,_tokenSet_8);
788 tim 770 }
789     returnAST = rigidbodyblock_AST;
790     }
791    
792     void MDParser::cutoffgroupblock() {
793     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
794     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
795     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
796    
797     try { // for error handling
798 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
799     tmp49_AST = astFactory->create(LT(1));
800     astFactory->makeASTRoot(currentAST, tmp49_AST);
801 tim 770 match(CUTOFFGROUP);
802     {
803     switch ( LA(1)) {
804     case LBRACKET:
805     {
806     match(LBRACKET);
807     intConst();
808     match(RBRACKET);
809     break;
810     }
811     case LCURLY:
812     {
813     break;
814     }
815     default:
816     {
817     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
818     }
819     }
820     }
821     match(LCURLY);
822     { // ( ... )*
823     for (;;) {
824     if ((LA(1) == MEMBERS || LA(1) == ID)) {
825     cutoffgroupstatement();
826     astFactory->addASTChild( currentAST, returnAST );
827     }
828     else {
829 cli2 1275 goto _loop48;
830 tim 770 }
831    
832     }
833 cli2 1275 _loop48:;
834 tim 770 } // ( ... )*
835 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
836     tmp53_AST = astFactory->create(LT(1));
837     astFactory->addASTChild(currentAST, tmp53_AST);
838 tim 770 match(RCURLY);
839 gezelter 1277 #line 129 "MDParser.g"
840     tmp53_AST->setType(ENDBLOCK);
841     #line 842 "MDParser.cpp"
842 tim 770 cutoffgroupblock_AST = currentAST.root;
843     }
844     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
845     reportError(ex);
846 gezelter 1277 recover(ex,_tokenSet_8);
847 tim 770 }
848     returnAST = cutoffgroupblock_AST;
849     }
850    
851     void MDParser::fragmentblock() {
852     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
853     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
854     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
855    
856     try { // for error handling
857 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
858     tmp54_AST = astFactory->create(LT(1));
859     astFactory->makeASTRoot(currentAST, tmp54_AST);
860 tim 770 match(FRAGMENT);
861     match(LBRACKET);
862     intConst();
863     astFactory->addASTChild( currentAST, returnAST );
864     match(RBRACKET);
865     match(LCURLY);
866     { // ( ... )*
867     for (;;) {
868     if ((LA(1) == ID)) {
869     fragmentstatement();
870     astFactory->addASTChild( currentAST, returnAST );
871     }
872     else {
873 cli2 1275 goto _loop52;
874 tim 770 }
875    
876     }
877 cli2 1275 _loop52:;
878 tim 770 } // ( ... )*
879 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
880     tmp58_AST = astFactory->create(LT(1));
881     astFactory->addASTChild(currentAST, tmp58_AST);
882 tim 770 match(RCURLY);
883 gezelter 1277 #line 136 "MDParser.g"
884     tmp58_AST->setType(ENDBLOCK);
885     #line 886 "MDParser.cpp"
886 tim 770 fragmentblock_AST = currentAST.root;
887     }
888     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
889     reportError(ex);
890 gezelter 1277 recover(ex,_tokenSet_8);
891 tim 770 }
892     returnAST = fragmentblock_AST;
893     }
894    
895     void MDParser::atomstatement() {
896     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
897     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
898     ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
899    
900     try { // for error handling
901     switch ( LA(1)) {
902     case ID:
903     {
904     assignment();
905     astFactory->addASTChild( currentAST, returnAST );
906     atomstatement_AST = currentAST.root;
907     break;
908     }
909     case POSITION:
910     {
911 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
912     tmp59_AST = astFactory->create(LT(1));
913     astFactory->makeASTRoot(currentAST, tmp59_AST);
914 tim 770 match(POSITION);
915     match(LPAREN);
916 tim 814 doubleNumberTuple();
917 tim 770 astFactory->addASTChild( currentAST, returnAST );
918     match(RPAREN);
919     match(SEMICOLON);
920     atomstatement_AST = currentAST.root;
921     break;
922     }
923     case ORIENTATION:
924     {
925 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
926     tmp63_AST = astFactory->create(LT(1));
927     astFactory->makeASTRoot(currentAST, tmp63_AST);
928 tim 770 match(ORIENTATION);
929     match(LPAREN);
930 tim 814 doubleNumberTuple();
931 tim 770 astFactory->addASTChild( currentAST, returnAST );
932     match(RPAREN);
933     match(SEMICOLON);
934     atomstatement_AST = currentAST.root;
935     break;
936     }
937     default:
938     {
939     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
940     }
941     }
942     }
943     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
944     reportError(ex);
945 gezelter 1277 recover(ex,_tokenSet_10);
946 tim 770 }
947     returnAST = atomstatement_AST;
948     }
949    
950 tim 814 void MDParser::doubleNumberTuple() {
951 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
952     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
953 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
954 tim 770
955     try { // for error handling
956 tim 814 doubleNumber();
957 tim 770 astFactory->addASTChild( currentAST, returnAST );
958     { // ( ... )*
959     for (;;) {
960     if ((LA(1) == COMMA)) {
961     match(COMMA);
962 tim 814 doubleNumber();
963 tim 770 astFactory->addASTChild( currentAST, returnAST );
964     }
965     else {
966 cli2 1275 goto _loop56;
967 tim 770 }
968    
969     }
970 cli2 1275 _loop56:;
971 tim 770 } // ( ... )*
972 tim 814 doubleNumberTuple_AST = currentAST.root;
973 tim 770 }
974     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
975     reportError(ex);
976 gezelter 1277 recover(ex,_tokenSet_11);
977 tim 770 }
978 tim 814 returnAST = doubleNumberTuple_AST;
979 tim 770 }
980    
981     void MDParser::bondstatement() {
982     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
983     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
984     ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
985    
986     try { // for error handling
987     switch ( LA(1)) {
988     case ID:
989     {
990     assignment();
991     astFactory->addASTChild( currentAST, returnAST );
992     bondstatement_AST = currentAST.root;
993     break;
994     }
995     case MEMBERS:
996     {
997 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
998     tmp68_AST = astFactory->create(LT(1));
999     astFactory->makeASTRoot(currentAST, tmp68_AST);
1000 tim 770 match(MEMBERS);
1001     match(LPAREN);
1002     inttuple();
1003     astFactory->addASTChild( currentAST, returnAST );
1004     match(RPAREN);
1005     match(SEMICOLON);
1006     bondstatement_AST = currentAST.root;
1007     break;
1008     }
1009     default:
1010     {
1011     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1012     }
1013     }
1014     }
1015     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1016     reportError(ex);
1017 gezelter 1277 recover(ex,_tokenSet_12);
1018 tim 770 }
1019     returnAST = bondstatement_AST;
1020     }
1021    
1022     void MDParser::inttuple() {
1023     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1024     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1025     ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1026    
1027     try { // for error handling
1028     intConst();
1029     astFactory->addASTChild( currentAST, returnAST );
1030     { // ( ... )*
1031     for (;;) {
1032     if ((LA(1) == COMMA)) {
1033     match(COMMA);
1034     intConst();
1035     astFactory->addASTChild( currentAST, returnAST );
1036     }
1037     else {
1038 cli2 1275 goto _loop59;
1039 tim 770 }
1040    
1041     }
1042 cli2 1275 _loop59:;
1043 tim 770 } // ( ... )*
1044     inttuple_AST = currentAST.root;
1045     }
1046     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1047     reportError(ex);
1048 gezelter 1277 recover(ex,_tokenSet_11);
1049 tim 770 }
1050     returnAST = inttuple_AST;
1051     }
1052    
1053     void MDParser::bendstatement() {
1054     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1055     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1056     ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1057    
1058     try { // for error handling
1059     switch ( LA(1)) {
1060     case ID:
1061     {
1062     assignment();
1063     astFactory->addASTChild( currentAST, returnAST );
1064     bendstatement_AST = currentAST.root;
1065     break;
1066     }
1067     case MEMBERS:
1068     {
1069 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1070     tmp73_AST = astFactory->create(LT(1));
1071     astFactory->makeASTRoot(currentAST, tmp73_AST);
1072 tim 770 match(MEMBERS);
1073     match(LPAREN);
1074     inttuple();
1075     astFactory->addASTChild( currentAST, returnAST );
1076     match(RPAREN);
1077     match(SEMICOLON);
1078     bendstatement_AST = currentAST.root;
1079     break;
1080     }
1081     default:
1082     {
1083     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1084     }
1085     }
1086     }
1087     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1088     reportError(ex);
1089 gezelter 1277 recover(ex,_tokenSet_12);
1090 tim 770 }
1091     returnAST = bendstatement_AST;
1092     }
1093    
1094     void MDParser::torsionstatement() {
1095     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1096     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1097     ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1098    
1099     try { // for error handling
1100     switch ( LA(1)) {
1101     case ID:
1102     {
1103     assignment();
1104     astFactory->addASTChild( currentAST, returnAST );
1105     torsionstatement_AST = currentAST.root;
1106     break;
1107     }
1108     case MEMBERS:
1109     {
1110 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1111     tmp77_AST = astFactory->create(LT(1));
1112     astFactory->makeASTRoot(currentAST, tmp77_AST);
1113 tim 770 match(MEMBERS);
1114     match(LPAREN);
1115     inttuple();
1116     astFactory->addASTChild( currentAST, returnAST );
1117     match(RPAREN);
1118     match(SEMICOLON);
1119     torsionstatement_AST = currentAST.root;
1120     break;
1121     }
1122     default:
1123     {
1124     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1125     }
1126     }
1127     }
1128     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1129     reportError(ex);
1130 gezelter 1277 recover(ex,_tokenSet_12);
1131 tim 770 }
1132     returnAST = torsionstatement_AST;
1133     }
1134    
1135 cli2 1275 void MDParser::inversionstatement() {
1136     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1137     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1138     ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1139    
1140     try { // for error handling
1141     switch ( LA(1)) {
1142     case ID:
1143     {
1144     assignment();
1145     astFactory->addASTChild( currentAST, returnAST );
1146     inversionstatement_AST = currentAST.root;
1147     break;
1148     }
1149     case CENTER:
1150     {
1151     ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1152     tmp81_AST = astFactory->create(LT(1));
1153     astFactory->makeASTRoot(currentAST, tmp81_AST);
1154     match(CENTER);
1155     match(LPAREN);
1156     intConst();
1157     astFactory->addASTChild( currentAST, returnAST );
1158     match(RPAREN);
1159     match(SEMICOLON);
1160     inversionstatement_AST = currentAST.root;
1161     break;
1162     }
1163     default:
1164     {
1165     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1166     }
1167     }
1168     }
1169     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1170     reportError(ex);
1171 gezelter 1277 recover(ex,_tokenSet_13);
1172 cli2 1275 }
1173     returnAST = inversionstatement_AST;
1174     }
1175    
1176 tim 770 void MDParser::rigidbodystatement() {
1177     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1178     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1179     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1180    
1181     try { // for error handling
1182     switch ( LA(1)) {
1183     case ID:
1184     {
1185     assignment();
1186     astFactory->addASTChild( currentAST, returnAST );
1187     rigidbodystatement_AST = currentAST.root;
1188     break;
1189     }
1190     case MEMBERS:
1191     {
1192 cli2 1275 ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1193     tmp85_AST = astFactory->create(LT(1));
1194     astFactory->makeASTRoot(currentAST, tmp85_AST);
1195 tim 770 match(MEMBERS);
1196     match(LPAREN);
1197     inttuple();
1198     astFactory->addASTChild( currentAST, returnAST );
1199     match(RPAREN);
1200     match(SEMICOLON);
1201     rigidbodystatement_AST = currentAST.root;
1202     break;
1203     }
1204     default:
1205     {
1206     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1207     }
1208     }
1209     }
1210     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1211     reportError(ex);
1212 gezelter 1277 recover(ex,_tokenSet_12);
1213 tim 770 }
1214     returnAST = rigidbodystatement_AST;
1215     }
1216    
1217     void MDParser::cutoffgroupstatement() {
1218     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1219     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1220     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1221    
1222     try { // for error handling
1223     switch ( LA(1)) {
1224     case ID:
1225     {
1226     assignment();
1227     astFactory->addASTChild( currentAST, returnAST );
1228     cutoffgroupstatement_AST = currentAST.root;
1229     break;
1230     }
1231     case MEMBERS:
1232     {
1233 cli2 1275 ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1234     tmp89_AST = astFactory->create(LT(1));
1235     astFactory->makeASTRoot(currentAST, tmp89_AST);
1236 tim 770 match(MEMBERS);
1237     match(LPAREN);
1238     inttuple();
1239     astFactory->addASTChild( currentAST, returnAST );
1240     match(RPAREN);
1241     match(SEMICOLON);
1242     cutoffgroupstatement_AST = currentAST.root;
1243     break;
1244     }
1245     default:
1246     {
1247     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1248     }
1249     }
1250     }
1251     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1252     reportError(ex);
1253 gezelter 1277 recover(ex,_tokenSet_12);
1254 tim 770 }
1255     returnAST = cutoffgroupstatement_AST;
1256     }
1257    
1258     void MDParser::fragmentstatement() {
1259     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1260     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1261     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1262    
1263     try { // for error handling
1264     assignment();
1265     astFactory->addASTChild( currentAST, returnAST );
1266     fragmentstatement_AST = currentAST.root;
1267     }
1268     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1269     reportError(ex);
1270 gezelter 1277 recover(ex,_tokenSet_14);
1271 tim 770 }
1272     returnAST = fragmentstatement_AST;
1273     }
1274    
1275 tim 814 void MDParser::doubleNumber() {
1276 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1277     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1278 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1279 tim 770
1280     try { // for error handling
1281 tim 814 {
1282 tim 770 switch ( LA(1)) {
1283 tim 814 case NUM_INT:
1284     case NUM_LONG:
1285 tim 770 {
1286 tim 814 intConst();
1287     astFactory->addASTChild( currentAST, returnAST );
1288 tim 770 break;
1289     }
1290 tim 814 case NUM_FLOAT:
1291     case NUM_DOUBLE:
1292 tim 770 {
1293 tim 814 floatConst();
1294     astFactory->addASTChild( currentAST, returnAST );
1295 tim 770 break;
1296     }
1297     default:
1298     {
1299     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1300     }
1301     }
1302 tim 814 }
1303     doubleNumber_AST = currentAST.root;
1304 tim 770 }
1305     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1306     reportError(ex);
1307 gezelter 1277 recover(ex,_tokenSet_15);
1308 tim 770 }
1309 tim 814 returnAST = doubleNumber_AST;
1310 tim 770 }
1311    
1312     void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1313     {
1314 cli2 1275 factory.setMaxNodeType(52);
1315 tim 770 }
1316     const char* MDParser::tokenNames[] = {
1317     "<0>",
1318     "EOF",
1319     "<2>",
1320     "NULL_TREE_LOOKAHEAD",
1321     "\"component\"",
1322     "\"molecule\"",
1323     "\"zconstraint\"",
1324     "\"atom\"",
1325     "\"bond\"",
1326     "\"bend\"",
1327     "\"torsion\"",
1328 cli2 1275 "\"inversion\"",
1329 tim 770 "\"rigidBody\"",
1330     "\"cutoffGroup\"",
1331     "\"fragment\"",
1332     "\"members\"",
1333 cli2 1275 "\"center\"",
1334 tim 770 "\"position\"",
1335     "\"orientation\"",
1336     "ENDBLOCK",
1337     "ID",
1338     "ASSIGNEQUAL",
1339     "SEMICOLON",
1340     "StringLiteral",
1341     "LCURLY",
1342     "RCURLY",
1343     "LBRACKET",
1344     "RBRACKET",
1345     "LPAREN",
1346     "RPAREN",
1347     "COMMA",
1348 tim 814 "NUM_INT",
1349     "NUM_LONG",
1350     "NUM_FLOAT",
1351     "NUM_DOUBLE",
1352 tim 770 "DOT",
1353     "COLON",
1354     "QUESTIONMARK",
1355     "Whitespace",
1356     "Comment",
1357     "CPPComment",
1358     "a line directive",
1359     "LineDirective",
1360     "Space",
1361     "CharLiteral",
1362     "EndOfLine",
1363     "Escape",
1364 tim 814 "Vocabulary",
1365 tim 770 "Digit",
1366     "Decimal",
1367 tim 814 "HEX_DIGIT",
1368     "EXPONENT",
1369     "FLOAT_SUFFIX",
1370 tim 770 0
1371     };
1372    
1373 cli2 1275 const unsigned long MDParser::_tokenSet_0_data_[] = { 1048688UL, 0UL, 0UL, 0UL };
1374 tim 770 // "component" "molecule" "zconstraint" ID
1375     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1376     const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1377     // EOF
1378     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1379 cli2 1275 const unsigned long MDParser::_tokenSet_2_data_[] = { 1048690UL, 0UL, 0UL, 0UL };
1380 tim 770 // EOF "component" "molecule" "zconstraint" ID
1381     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1382 gezelter 1277 const unsigned long MDParser::_tokenSet_3_data_[] = { 35127282UL, 0UL, 0UL, 0UL };
1383 tim 770 // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion"
1384 gezelter 1277 // "inversion" "rigidBody" "cutoffGroup" "fragment" "members" "center"
1385     // "position" "orientation" ID RCURLY
1386 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1387 gezelter 1277 const unsigned long MDParser::_tokenSet_4_data_[] = { 1081216UL, 0UL, 0UL, 0UL };
1388     // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1389     // "fragment" ID
1390 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1391 cli2 1275 const unsigned long MDParser::_tokenSet_5_data_[] = { 4194304UL, 0UL, 0UL, 0UL };
1392 tim 770 // SEMICOLON
1393     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1394 cli2 1275 const unsigned long MDParser::_tokenSet_6_data_[] = { 1749024768UL, 0UL, 0UL, 0UL };
1395 tim 814 // SEMICOLON RBRACKET RPAREN COMMA
1396     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1397 cli2 1275 const unsigned long MDParser::_tokenSet_7_data_[] = { 1614807040UL, 0UL, 0UL, 0UL };
1398 tim 770 // SEMICOLON RPAREN COMMA
1399 tim 814 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1400 gezelter 1277 const unsigned long MDParser::_tokenSet_8_data_[] = { 34635648UL, 0UL, 0UL, 0UL };
1401     // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1402     // "fragment" ID RCURLY
1403 tim 814 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1404 cli2 1275 const unsigned long MDParser::_tokenSet_9_data_[] = { 1441792UL, 0UL, 0UL, 0UL };
1405 tim 770 // "position" "orientation" ID
1406     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1407 cli2 1275 const unsigned long MDParser::_tokenSet_10_data_[] = { 34996224UL, 0UL, 0UL, 0UL };
1408 tim 770 // "position" "orientation" ID RCURLY
1409     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1410 cli2 1275 const unsigned long MDParser::_tokenSet_11_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1411 tim 770 // RPAREN
1412     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1413 cli2 1275 const unsigned long MDParser::_tokenSet_12_data_[] = { 34635776UL, 0UL, 0UL, 0UL };
1414 tim 770 // "members" ID RCURLY
1415     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1416 cli2 1275 const unsigned long MDParser::_tokenSet_13_data_[] = { 34668544UL, 0UL, 0UL, 0UL };
1417     // "center" ID RCURLY
1418     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1419     const unsigned long MDParser::_tokenSet_14_data_[] = { 34603008UL, 0UL, 0UL, 0UL };
1420 tim 770 // ID RCURLY
1421 cli2 1275 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1422     const unsigned long MDParser::_tokenSet_15_data_[] = { 1610612736UL, 0UL, 0UL, 0UL };
1423 tim 814 // RPAREN COMMA
1424 cli2 1275 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1425 tim 770
1426