ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDParser.cpp
Revision: 1275
Committed: Fri Jul 4 20:54:29 2008 UTC (16 years, 9 months ago) by cli2
File size: 38099 byte(s)
Log Message: 
Changes required for Inversions and Base Atom types.  This will
break OOPSE badly for a few days or so...

File Contents

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