ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDParser.cpp
Revision: 2513
Committed: Fri Dec 16 02:57:00 2005 UTC (18 years, 7 months ago) by tim
File size: 34942 byte(s)
Log Message: 
replace grammar for numerical parsing

File Contents

# User Rev Content
1 tim 2469 /* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */
2     #include "MDParser.hpp"
3     #include <antlr/NoViableAltException.hpp>
4     #include <antlr/SemanticException.hpp>
5     #include <antlr/ASTFactory.hpp>
6     #line 1 "MDParser.g"
7     #line 8 "MDParser.cpp"
8     MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
9     : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
10     {
11     }
12    
13     MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
14     : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3)
15     {
16     }
17    
18     MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
19     : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
20     {
21     }
22    
23     MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
24     : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3)
25     {
26     }
27    
28     MDParser::MDParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
29     : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3)
30     {
31     }
32    
33     void MDParser::mdfile() {
34     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
35     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
36     ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
37    
38     try { // for error handling
39     { // ( ... )*
40     for (;;) {
41     if ((_tokenSet_0.member(LA(1)))) {
42     statement();
43     astFactory->addASTChild( currentAST, returnAST );
44     }
45     else {
46     goto _loop3;
47     }
48    
49     }
50     _loop3:;
51     } // ( ... )*
52     mdfile_AST = currentAST.root;
53     }
54     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
55     reportError(ex);
56     recover(ex,_tokenSet_1);
57     }
58     returnAST = mdfile_AST;
59     }
60    
61     void MDParser::statement() {
62     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
63     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
64     ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
65    
66     try { // for error handling
67     switch ( LA(1)) {
68     case ID:
69     {
70     assignment();
71     astFactory->addASTChild( currentAST, returnAST );
72     statement_AST = currentAST.root;
73     break;
74     }
75     case COMPONENT:
76     {
77     componentblock();
78     astFactory->addASTChild( currentAST, returnAST );
79     statement_AST = currentAST.root;
80     break;
81     }
82     case MOLECULE:
83     {
84     moleculeblock();
85     astFactory->addASTChild( currentAST, returnAST );
86     statement_AST = currentAST.root;
87     break;
88     }
89     case ZCONSTRAINT:
90     {
91     zconstraintblock();
92     astFactory->addASTChild( currentAST, returnAST );
93     statement_AST = currentAST.root;
94     break;
95     }
96     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     recover(ex,_tokenSet_2);
105     }
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     recover(ex,_tokenSet_3);
131     }
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 tim 2513 #line 63 "MDParser.g"
164 tim 2469 tmp6_AST->setType(ENDBLOCK);
165     #line 166 "MDParser.cpp"
166     componentblock_AST = currentAST.root;
167     }
168     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
169     reportError(ex);
170     recover(ex,_tokenSet_2);
171     }
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 tim 2513 #line 69 "MDParser.g"
204 tim 2469 tmp9_AST->setType(ENDBLOCK);
205     #line 206 "MDParser.cpp"
206     moleculeblock_AST = currentAST.root;
207     }
208     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
209     reportError(ex);
210     recover(ex,_tokenSet_2);
211     }
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 tim 2513 #line 66 "MDParser.g"
244 tim 2469 tmp12_AST->setType(ENDBLOCK);
245     #line 246 "MDParser.cpp"
246     zconstraintblock_AST = currentAST.root;
247     }
248     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
249     reportError(ex);
250     recover(ex,_tokenSet_2);
251     }
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 2513 case NUM_INT:
263     case NUM_LONG:
264 tim 2469 {
265 tim 2513 intConst();
266 tim 2469 astFactory->addASTChild( currentAST, returnAST );
267     constant_AST = currentAST.root;
268     break;
269     }
270 tim 2513 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 2469 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     recover(ex,_tokenSet_5);
305     }
306     returnAST = constant_AST;
307     }
308    
309 tim 2513 void MDParser::intConst() {
310 tim 2469 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
311     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
312 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
313 tim 2469
314     try { // for error handling
315     switch ( LA(1)) {
316 tim 2513 case NUM_INT:
317 tim 2469 {
318 tim 2513 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 2469 break;
324     }
325 tim 2513 case NUM_LONG:
326 tim 2469 {
327 tim 2513 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 2469 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     recover(ex,_tokenSet_6);
343     }
344 tim 2513 returnAST = intConst_AST;
345 tim 2469 }
346    
347 tim 2513 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     recover(ex,_tokenSet_7);
381     }
382     returnAST = floatConst_AST;
383     }
384    
385 tim 2469 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     case RIGIDBODY:
428     {
429     rigidbodyblock();
430     astFactory->addASTChild( currentAST, returnAST );
431     moleculestatement_AST = currentAST.root;
432     break;
433     }
434     case CUTOFFGROUP:
435     {
436     cutoffgroupblock();
437     astFactory->addASTChild( currentAST, returnAST );
438     moleculestatement_AST = currentAST.root;
439     break;
440     }
441     case FRAGMENT:
442     {
443     fragmentblock();
444     astFactory->addASTChild( currentAST, returnAST );
445     moleculestatement_AST = currentAST.root;
446     break;
447     }
448     default:
449     {
450     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
451     }
452     }
453     }
454     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
455     reportError(ex);
456 tim 2513 recover(ex,_tokenSet_8);
457 tim 2469 }
458     returnAST = moleculestatement_AST;
459     }
460    
461     void MDParser::atomblock() {
462     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
463     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
464     ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
465    
466     try { // for error handling
467 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
468     tmp19_AST = astFactory->create(LT(1));
469     astFactory->makeASTRoot(currentAST, tmp19_AST);
470 tim 2469 match(ATOM);
471     match(LBRACKET);
472     intConst();
473     astFactory->addASTChild( currentAST, returnAST );
474     match(RBRACKET);
475     match(LCURLY);
476     { // ( ... )*
477     for (;;) {
478 tim 2513 if ((_tokenSet_9.member(LA(1)))) {
479 tim 2469 atomstatement();
480     astFactory->addASTChild( currentAST, returnAST );
481     }
482     else {
483     goto _loop19;
484     }
485    
486     }
487     _loop19:;
488     } // ( ... )*
489 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
490     tmp23_AST = astFactory->create(LT(1));
491     astFactory->addASTChild(currentAST, tmp23_AST);
492 tim 2469 match(RCURLY);
493 tim 2513 #line 82 "MDParser.g"
494     tmp23_AST->setType(ENDBLOCK);
495     #line 496 "MDParser.cpp"
496 tim 2469 atomblock_AST = currentAST.root;
497     }
498     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
499     reportError(ex);
500 tim 2513 recover(ex,_tokenSet_8);
501 tim 2469 }
502     returnAST = atomblock_AST;
503     }
504    
505     void MDParser::bondblock() {
506     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
508     ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
509    
510     try { // for error handling
511 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
512     tmp24_AST = astFactory->create(LT(1));
513     astFactory->makeASTRoot(currentAST, tmp24_AST);
514 tim 2469 match(BOND);
515     {
516     switch ( LA(1)) {
517     case LBRACKET:
518     {
519     match(LBRACKET);
520     intConst();
521     match(RBRACKET);
522     break;
523     }
524     case LCURLY:
525     {
526     break;
527     }
528     default:
529     {
530     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
531     }
532     }
533     }
534     match(LCURLY);
535     { // ( ... )*
536     for (;;) {
537     if ((LA(1) == MEMBERS || LA(1) == ID)) {
538     bondstatement();
539     astFactory->addASTChild( currentAST, returnAST );
540     }
541     else {
542     goto _loop24;
543     }
544    
545     }
546     _loop24:;
547     } // ( ... )*
548 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
549     tmp28_AST = astFactory->create(LT(1));
550     astFactory->addASTChild(currentAST, tmp28_AST);
551 tim 2469 match(RCURLY);
552 tim 2513 #line 91 "MDParser.g"
553     tmp28_AST->setType(ENDBLOCK);
554     #line 555 "MDParser.cpp"
555 tim 2469 bondblock_AST = currentAST.root;
556     }
557     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
558     reportError(ex);
559 tim 2513 recover(ex,_tokenSet_8);
560 tim 2469 }
561     returnAST = bondblock_AST;
562     }
563    
564     void MDParser::bendblock() {
565     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
566     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
567     ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
568    
569     try { // for error handling
570 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
571     tmp29_AST = astFactory->create(LT(1));
572     astFactory->makeASTRoot(currentAST, tmp29_AST);
573 tim 2469 match(BEND);
574     {
575     switch ( LA(1)) {
576     case LBRACKET:
577     {
578     match(LBRACKET);
579     intConst();
580     match(RBRACKET);
581     break;
582     }
583     case LCURLY:
584     {
585     break;
586     }
587     default:
588     {
589     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
590     }
591     }
592     }
593     match(LCURLY);
594     { // ( ... )*
595     for (;;) {
596     if ((LA(1) == MEMBERS || LA(1) == ID)) {
597     bendstatement();
598     astFactory->addASTChild( currentAST, returnAST );
599     }
600     else {
601     goto _loop29;
602     }
603    
604     }
605     _loop29:;
606     } // ( ... )*
607 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
608     tmp33_AST = astFactory->create(LT(1));
609     astFactory->addASTChild(currentAST, tmp33_AST);
610 tim 2469 match(RCURLY);
611 tim 2513 #line 98 "MDParser.g"
612     tmp33_AST->setType(ENDBLOCK);
613     #line 614 "MDParser.cpp"
614 tim 2469 bendblock_AST = currentAST.root;
615     }
616     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
617     reportError(ex);
618 tim 2513 recover(ex,_tokenSet_8);
619 tim 2469 }
620     returnAST = bendblock_AST;
621     }
622    
623     void MDParser::torsionblock() {
624     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
625     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
626     ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
627    
628     try { // for error handling
629 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
630     tmp34_AST = astFactory->create(LT(1));
631     astFactory->makeASTRoot(currentAST, tmp34_AST);
632 tim 2469 match(TORSION);
633     {
634     switch ( LA(1)) {
635     case LBRACKET:
636     {
637     match(LBRACKET);
638     intConst();
639     match(RBRACKET);
640     break;
641     }
642     case LCURLY:
643     {
644     break;
645     }
646     default:
647     {
648     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
649     }
650     }
651     }
652     match(LCURLY);
653     { // ( ... )*
654     for (;;) {
655     if ((LA(1) == MEMBERS || LA(1) == ID)) {
656     torsionstatement();
657     astFactory->addASTChild( currentAST, returnAST );
658     }
659     else {
660     goto _loop34;
661     }
662    
663     }
664     _loop34:;
665     } // ( ... )*
666 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
667     tmp38_AST = astFactory->create(LT(1));
668     astFactory->addASTChild(currentAST, tmp38_AST);
669 tim 2469 match(RCURLY);
670 tim 2513 #line 105 "MDParser.g"
671     tmp38_AST->setType(ENDBLOCK);
672     #line 673 "MDParser.cpp"
673 tim 2469 torsionblock_AST = currentAST.root;
674     }
675     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
676     reportError(ex);
677 tim 2513 recover(ex,_tokenSet_8);
678 tim 2469 }
679     returnAST = torsionblock_AST;
680     }
681    
682     void MDParser::rigidbodyblock() {
683     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
684     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
685     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
686    
687     try { // for error handling
688 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
689     tmp39_AST = astFactory->create(LT(1));
690     astFactory->makeASTRoot(currentAST, tmp39_AST);
691 tim 2469 match(RIGIDBODY);
692     match(LBRACKET);
693     intConst();
694     astFactory->addASTChild( currentAST, returnAST );
695     match(RBRACKET);
696     match(LCURLY);
697     { // ( ... )*
698     for (;;) {
699     if ((LA(1) == MEMBERS || LA(1) == ID)) {
700     rigidbodystatement();
701     astFactory->addASTChild( currentAST, returnAST );
702     }
703     else {
704     goto _loop38;
705     }
706    
707     }
708     _loop38:;
709     } // ( ... )*
710 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
711     tmp43_AST = astFactory->create(LT(1));
712     astFactory->addASTChild(currentAST, tmp43_AST);
713 tim 2469 match(RCURLY);
714 tim 2513 #line 112 "MDParser.g"
715     tmp43_AST->setType(ENDBLOCK);
716     #line 717 "MDParser.cpp"
717 tim 2469 rigidbodyblock_AST = currentAST.root;
718     }
719     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
720     reportError(ex);
721 tim 2513 recover(ex,_tokenSet_8);
722 tim 2469 }
723     returnAST = rigidbodyblock_AST;
724     }
725    
726     void MDParser::cutoffgroupblock() {
727     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
728     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
729     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
730    
731     try { // for error handling
732 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
733     tmp44_AST = astFactory->create(LT(1));
734     astFactory->makeASTRoot(currentAST, tmp44_AST);
735 tim 2469 match(CUTOFFGROUP);
736     {
737     switch ( LA(1)) {
738     case LBRACKET:
739     {
740     match(LBRACKET);
741     intConst();
742     match(RBRACKET);
743     break;
744     }
745     case LCURLY:
746     {
747     break;
748     }
749     default:
750     {
751     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
752     }
753     }
754     }
755     match(LCURLY);
756     { // ( ... )*
757     for (;;) {
758     if ((LA(1) == MEMBERS || LA(1) == ID)) {
759     cutoffgroupstatement();
760     astFactory->addASTChild( currentAST, returnAST );
761     }
762     else {
763     goto _loop43;
764     }
765    
766     }
767     _loop43:;
768     } // ( ... )*
769 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
770     tmp48_AST = astFactory->create(LT(1));
771     astFactory->addASTChild(currentAST, tmp48_AST);
772 tim 2469 match(RCURLY);
773 tim 2513 #line 119 "MDParser.g"
774     tmp48_AST->setType(ENDBLOCK);
775     #line 776 "MDParser.cpp"
776 tim 2469 cutoffgroupblock_AST = currentAST.root;
777     }
778     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
779     reportError(ex);
780 tim 2513 recover(ex,_tokenSet_8);
781 tim 2469 }
782     returnAST = cutoffgroupblock_AST;
783     }
784    
785     void MDParser::fragmentblock() {
786     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
787     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
788     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
789    
790     try { // for error handling
791 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
792     tmp49_AST = astFactory->create(LT(1));
793     astFactory->makeASTRoot(currentAST, tmp49_AST);
794 tim 2469 match(FRAGMENT);
795     match(LBRACKET);
796     intConst();
797     astFactory->addASTChild( currentAST, returnAST );
798     match(RBRACKET);
799     match(LCURLY);
800     { // ( ... )*
801     for (;;) {
802     if ((LA(1) == ID)) {
803     fragmentstatement();
804     astFactory->addASTChild( currentAST, returnAST );
805     }
806     else {
807     goto _loop47;
808     }
809    
810     }
811     _loop47:;
812     } // ( ... )*
813 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
814     tmp53_AST = astFactory->create(LT(1));
815     astFactory->addASTChild(currentAST, tmp53_AST);
816 tim 2469 match(RCURLY);
817 tim 2513 #line 126 "MDParser.g"
818     tmp53_AST->setType(ENDBLOCK);
819     #line 820 "MDParser.cpp"
820 tim 2469 fragmentblock_AST = currentAST.root;
821     }
822     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
823     reportError(ex);
824 tim 2513 recover(ex,_tokenSet_8);
825 tim 2469 }
826     returnAST = fragmentblock_AST;
827     }
828    
829     void MDParser::atomstatement() {
830     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
831     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
832     ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
833    
834     try { // for error handling
835     switch ( LA(1)) {
836     case ID:
837     {
838     assignment();
839     astFactory->addASTChild( currentAST, returnAST );
840     atomstatement_AST = currentAST.root;
841     break;
842     }
843     case POSITION:
844     {
845 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
846     tmp54_AST = astFactory->create(LT(1));
847     astFactory->makeASTRoot(currentAST, tmp54_AST);
848 tim 2469 match(POSITION);
849     match(LPAREN);
850 tim 2513 doubleNumberTuple();
851 tim 2469 astFactory->addASTChild( currentAST, returnAST );
852     match(RPAREN);
853     match(SEMICOLON);
854     atomstatement_AST = currentAST.root;
855     break;
856     }
857     case ORIENTATION:
858     {
859 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
860     tmp58_AST = astFactory->create(LT(1));
861     astFactory->makeASTRoot(currentAST, tmp58_AST);
862 tim 2469 match(ORIENTATION);
863     match(LPAREN);
864 tim 2513 doubleNumberTuple();
865 tim 2469 astFactory->addASTChild( currentAST, returnAST );
866     match(RPAREN);
867     match(SEMICOLON);
868     atomstatement_AST = currentAST.root;
869     break;
870     }
871     default:
872     {
873     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
874     }
875     }
876     }
877     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
878     reportError(ex);
879     recover(ex,_tokenSet_10);
880     }
881     returnAST = atomstatement_AST;
882     }
883    
884 tim 2513 void MDParser::doubleNumberTuple() {
885 tim 2469 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
886     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
887 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
888 tim 2469
889     try { // for error handling
890 tim 2513 doubleNumber();
891 tim 2469 astFactory->addASTChild( currentAST, returnAST );
892     { // ( ... )*
893     for (;;) {
894     if ((LA(1) == COMMA)) {
895     match(COMMA);
896 tim 2513 doubleNumber();
897 tim 2469 astFactory->addASTChild( currentAST, returnAST );
898     }
899     else {
900     goto _loop51;
901     }
902    
903     }
904     _loop51:;
905     } // ( ... )*
906 tim 2513 doubleNumberTuple_AST = currentAST.root;
907 tim 2469 }
908     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
909     reportError(ex);
910     recover(ex,_tokenSet_11);
911     }
912 tim 2513 returnAST = doubleNumberTuple_AST;
913 tim 2469 }
914    
915     void MDParser::bondstatement() {
916     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
917     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
918     ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
919    
920     try { // for error handling
921     switch ( LA(1)) {
922     case ID:
923     {
924     assignment();
925     astFactory->addASTChild( currentAST, returnAST );
926     bondstatement_AST = currentAST.root;
927     break;
928     }
929     case MEMBERS:
930     {
931 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
932     tmp63_AST = astFactory->create(LT(1));
933     astFactory->makeASTRoot(currentAST, tmp63_AST);
934 tim 2469 match(MEMBERS);
935     match(LPAREN);
936     inttuple();
937     astFactory->addASTChild( currentAST, returnAST );
938     match(RPAREN);
939     match(SEMICOLON);
940     bondstatement_AST = currentAST.root;
941     break;
942     }
943     default:
944     {
945     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
946     }
947     }
948     }
949     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
950     reportError(ex);
951     recover(ex,_tokenSet_12);
952     }
953     returnAST = bondstatement_AST;
954     }
955    
956     void MDParser::inttuple() {
957     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
958     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
959     ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
960    
961     try { // for error handling
962     intConst();
963     astFactory->addASTChild( currentAST, returnAST );
964     { // ( ... )*
965     for (;;) {
966     if ((LA(1) == COMMA)) {
967     match(COMMA);
968     intConst();
969     astFactory->addASTChild( currentAST, returnAST );
970     }
971     else {
972     goto _loop54;
973     }
974    
975     }
976     _loop54:;
977     } // ( ... )*
978     inttuple_AST = currentAST.root;
979     }
980     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
981     reportError(ex);
982     recover(ex,_tokenSet_11);
983     }
984     returnAST = inttuple_AST;
985     }
986    
987     void MDParser::bendstatement() {
988     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
989     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
990     ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
991    
992     try { // for error handling
993     switch ( LA(1)) {
994     case ID:
995     {
996     assignment();
997     astFactory->addASTChild( currentAST, returnAST );
998     bendstatement_AST = currentAST.root;
999     break;
1000     }
1001     case MEMBERS:
1002     {
1003 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1004     tmp68_AST = astFactory->create(LT(1));
1005     astFactory->makeASTRoot(currentAST, tmp68_AST);
1006 tim 2469 match(MEMBERS);
1007     match(LPAREN);
1008     inttuple();
1009     astFactory->addASTChild( currentAST, returnAST );
1010     match(RPAREN);
1011     match(SEMICOLON);
1012     bendstatement_AST = currentAST.root;
1013     break;
1014     }
1015     default:
1016     {
1017     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1018     }
1019     }
1020     }
1021     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1022     reportError(ex);
1023     recover(ex,_tokenSet_12);
1024     }
1025     returnAST = bendstatement_AST;
1026     }
1027    
1028     void MDParser::torsionstatement() {
1029     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1030     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1031     ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1032    
1033     try { // for error handling
1034     switch ( LA(1)) {
1035     case ID:
1036     {
1037     assignment();
1038     astFactory->addASTChild( currentAST, returnAST );
1039     torsionstatement_AST = currentAST.root;
1040     break;
1041     }
1042     case MEMBERS:
1043     {
1044 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1045     tmp72_AST = astFactory->create(LT(1));
1046     astFactory->makeASTRoot(currentAST, tmp72_AST);
1047 tim 2469 match(MEMBERS);
1048     match(LPAREN);
1049     inttuple();
1050     astFactory->addASTChild( currentAST, returnAST );
1051     match(RPAREN);
1052     match(SEMICOLON);
1053     torsionstatement_AST = currentAST.root;
1054     break;
1055     }
1056     default:
1057     {
1058     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1059     }
1060     }
1061     }
1062     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1063     reportError(ex);
1064     recover(ex,_tokenSet_12);
1065     }
1066     returnAST = torsionstatement_AST;
1067     }
1068    
1069     void MDParser::rigidbodystatement() {
1070     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1071     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1072     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1073    
1074     try { // for error handling
1075     switch ( LA(1)) {
1076     case ID:
1077     {
1078     assignment();
1079     astFactory->addASTChild( currentAST, returnAST );
1080     rigidbodystatement_AST = currentAST.root;
1081     break;
1082     }
1083     case MEMBERS:
1084     {
1085 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1086     tmp76_AST = astFactory->create(LT(1));
1087     astFactory->makeASTRoot(currentAST, tmp76_AST);
1088 tim 2469 match(MEMBERS);
1089     match(LPAREN);
1090     inttuple();
1091     astFactory->addASTChild( currentAST, returnAST );
1092     match(RPAREN);
1093     match(SEMICOLON);
1094     rigidbodystatement_AST = currentAST.root;
1095     break;
1096     }
1097     default:
1098     {
1099     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1100     }
1101     }
1102     }
1103     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1104     reportError(ex);
1105     recover(ex,_tokenSet_12);
1106     }
1107     returnAST = rigidbodystatement_AST;
1108     }
1109    
1110     void MDParser::cutoffgroupstatement() {
1111     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1112     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1113     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1114    
1115     try { // for error handling
1116     switch ( LA(1)) {
1117     case ID:
1118     {
1119     assignment();
1120     astFactory->addASTChild( currentAST, returnAST );
1121     cutoffgroupstatement_AST = currentAST.root;
1122     break;
1123     }
1124     case MEMBERS:
1125     {
1126 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1127     tmp80_AST = astFactory->create(LT(1));
1128     astFactory->makeASTRoot(currentAST, tmp80_AST);
1129 tim 2469 match(MEMBERS);
1130     match(LPAREN);
1131     inttuple();
1132     astFactory->addASTChild( currentAST, returnAST );
1133     match(RPAREN);
1134     match(SEMICOLON);
1135     cutoffgroupstatement_AST = currentAST.root;
1136     break;
1137     }
1138     default:
1139     {
1140     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1141     }
1142     }
1143     }
1144     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1145     reportError(ex);
1146     recover(ex,_tokenSet_12);
1147     }
1148     returnAST = cutoffgroupstatement_AST;
1149     }
1150    
1151     void MDParser::fragmentstatement() {
1152     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1153     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1154     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1155    
1156     try { // for error handling
1157     assignment();
1158     astFactory->addASTChild( currentAST, returnAST );
1159     fragmentstatement_AST = currentAST.root;
1160     }
1161     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1162     reportError(ex);
1163     recover(ex,_tokenSet_13);
1164     }
1165     returnAST = fragmentstatement_AST;
1166     }
1167    
1168 tim 2513 void MDParser::doubleNumber() {
1169 tim 2469 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1170     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1171 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1172 tim 2469
1173     try { // for error handling
1174 tim 2513 {
1175 tim 2469 switch ( LA(1)) {
1176 tim 2513 case NUM_INT:
1177     case NUM_LONG:
1178 tim 2469 {
1179 tim 2513 intConst();
1180     astFactory->addASTChild( currentAST, returnAST );
1181 tim 2469 break;
1182     }
1183 tim 2513 case NUM_FLOAT:
1184     case NUM_DOUBLE:
1185 tim 2469 {
1186 tim 2513 floatConst();
1187     astFactory->addASTChild( currentAST, returnAST );
1188 tim 2469 break;
1189     }
1190     default:
1191     {
1192     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1193     }
1194     }
1195 tim 2513 }
1196     doubleNumber_AST = currentAST.root;
1197 tim 2469 }
1198     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1199     reportError(ex);
1200 tim 2513 recover(ex,_tokenSet_14);
1201 tim 2469 }
1202 tim 2513 returnAST = doubleNumber_AST;
1203 tim 2469 }
1204    
1205     void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1206     {
1207 tim 2513 factory.setMaxNodeType(50);
1208 tim 2469 }
1209     const char* MDParser::tokenNames[] = {
1210     "<0>",
1211     "EOF",
1212     "<2>",
1213     "NULL_TREE_LOOKAHEAD",
1214     "\"component\"",
1215     "\"molecule\"",
1216     "\"zconstraint\"",
1217     "\"atom\"",
1218     "\"bond\"",
1219     "\"bend\"",
1220     "\"torsion\"",
1221     "\"rigidBody\"",
1222     "\"cutoffGroup\"",
1223     "\"fragment\"",
1224     "\"members\"",
1225     "\"position\"",
1226     "\"orientation\"",
1227     "ENDBLOCK",
1228     "ID",
1229     "ASSIGNEQUAL",
1230     "SEMICOLON",
1231     "StringLiteral",
1232     "LCURLY",
1233     "RCURLY",
1234     "LBRACKET",
1235     "RBRACKET",
1236     "LPAREN",
1237     "RPAREN",
1238     "COMMA",
1239 tim 2513 "NUM_INT",
1240     "NUM_LONG",
1241     "NUM_FLOAT",
1242     "NUM_DOUBLE",
1243 tim 2469 "DOT",
1244     "COLON",
1245     "QUESTIONMARK",
1246     "Whitespace",
1247     "Comment",
1248     "CPPComment",
1249     "a line directive",
1250     "LineDirective",
1251     "Space",
1252     "CharLiteral",
1253     "EndOfLine",
1254     "Escape",
1255 tim 2513 "Vocabulary",
1256 tim 2469 "Digit",
1257     "Decimal",
1258 tim 2513 "HEX_DIGIT",
1259     "EXPONENT",
1260     "FLOAT_SUFFIX",
1261 tim 2469 0
1262     };
1263    
1264     const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL };
1265     // "component" "molecule" "zconstraint" ID
1266     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1267     const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1268     // EOF
1269     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1270     const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL };
1271     // EOF "component" "molecule" "zconstraint" ID
1272     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1273     const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL };
1274     // EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion"
1275     // "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation"
1276     // ID RCURLY
1277     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1278     const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL };
1279     // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1280     // ID
1281     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1282     const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL };
1283     // SEMICOLON
1284     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1285 tim 2513 const unsigned long MDParser::_tokenSet_6_data_[] = { 437256192UL, 0UL, 0UL, 0UL };
1286     // SEMICOLON RBRACKET RPAREN COMMA
1287     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1288     const unsigned long MDParser::_tokenSet_7_data_[] = { 403701760UL, 0UL, 0UL, 0UL };
1289 tim 2469 // SEMICOLON RPAREN COMMA
1290 tim 2513 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1291     const unsigned long MDParser::_tokenSet_8_data_[] = { 8667008UL, 0UL, 0UL, 0UL };
1292 tim 2469 // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1293     // ID RCURLY
1294 tim 2513 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1295     const unsigned long MDParser::_tokenSet_9_data_[] = { 360448UL, 0UL, 0UL, 0UL };
1296 tim 2469 // "position" "orientation" ID
1297     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1298     const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL };
1299     // "position" "orientation" ID RCURLY
1300     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1301     const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL };
1302     // RPAREN
1303     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1304     const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL };
1305     // "members" ID RCURLY
1306     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1307     const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL };
1308     // ID RCURLY
1309     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1310 tim 2513 const unsigned long MDParser::_tokenSet_14_data_[] = { 402653184UL, 0UL, 0UL, 0UL };
1311     // RPAREN COMMA
1312     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1313 tim 2469
1314