ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDParser.cpp
Revision: 1776
Committed: Thu Aug 9 15:52:59 2012 UTC (13 years, 2 months ago) by gezelter
File size: 44619 byte(s)
Log Message: 
Fixes to mdParser to handle vector assignments, fixes for VelocityVerletIntegrator deleting rnemd_ when it doesn't exist yet.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date