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

File Contents

# User Rev Content
1 gezelter 1979 /* $ANTLR 2.7.7 (20140107): "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 1782 case FLUCQ:
104     {
105     flucqblock();
106     astFactory->addASTChild( currentAST, returnAST );
107     statement_AST = currentAST.root;
108     break;
109     }
110     case RNEMD:
111     {
112     rnemdblock();
113     astFactory->addASTChild( currentAST, returnAST );
114     statement_AST = currentAST.root;
115     break;
116     }
117     case MINIMIZER:
118     {
119     minimizerblock();
120     astFactory->addASTChild( currentAST, returnAST );
121     statement_AST = currentAST.root;
122     break;
123     }
124 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 1979 #line 77 "MDParser.g"
192 tim 770 tmp6_AST->setType(ENDBLOCK);
193 gezelter 1782 #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 1782 goto _loop27;
222 tim 770 }
223    
224     }
225 gezelter 1782 _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 1979 #line 95 "MDParser.g"
232 tim 770 tmp9_AST->setType(ENDBLOCK);
233 gezelter 1782 #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 1979 #line 80 "MDParser.g"
272 tim 770 tmp12_AST->setType(ENDBLOCK);
273 gezelter 1782 #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 1979 #line 83 "MDParser.g"
312 cli2 1360 tmp15_AST->setType(ENDBLOCK);
313 gezelter 1782 #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 1782 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 1979 #line 86 "MDParser.g"
352 gezelter 1782 tmp18_AST->setType(ENDBLOCK);
353     #line 354 "MDParser.cpp"
354     flucqblock_AST = currentAST.root;
355     }
356     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
357     reportError(ex);
358     recover(ex,_tokenSet_2);
359     }
360     returnAST = flucqblock_AST;
361     }
362    
363     void MDParser::rnemdblock() {
364     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
365     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
366     ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
367    
368     try { // for error handling
369     ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
370     tmp19_AST = astFactory->create(LT(1));
371     astFactory->makeASTRoot(currentAST, tmp19_AST);
372     match(RNEMD);
373     match(LCURLY);
374     { // ( ... )*
375     for (;;) {
376     if ((LA(1) == ID)) {
377     assignment();
378     astFactory->addASTChild( currentAST, returnAST );
379     }
380     else {
381     goto _loop21;
382     }
383    
384     }
385     _loop21:;
386     } // ( ... )*
387     ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
388     tmp21_AST = astFactory->create(LT(1));
389     astFactory->addASTChild(currentAST, tmp21_AST);
390     match(RCURLY);
391 gezelter 1979 #line 89 "MDParser.g"
392 gezelter 1782 tmp21_AST->setType(ENDBLOCK);
393     #line 394 "MDParser.cpp"
394     rnemdblock_AST = currentAST.root;
395     }
396     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
397     reportError(ex);
398     recover(ex,_tokenSet_2);
399     }
400     returnAST = rnemdblock_AST;
401     }
402    
403     void MDParser::minimizerblock() {
404     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
405     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
406     ANTLR_USE_NAMESPACE(antlr)RefAST minimizerblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
407    
408     try { // for error handling
409     ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
410     tmp22_AST = astFactory->create(LT(1));
411     astFactory->makeASTRoot(currentAST, tmp22_AST);
412     match(MINIMIZER);
413     match(LCURLY);
414     { // ( ... )*
415     for (;;) {
416     if ((LA(1) == ID)) {
417     assignment();
418     astFactory->addASTChild( currentAST, returnAST );
419     }
420     else {
421     goto _loop24;
422     }
423    
424     }
425     _loop24:;
426     } // ( ... )*
427     ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
428     tmp24_AST = astFactory->create(LT(1));
429     astFactory->addASTChild(currentAST, tmp24_AST);
430     match(RCURLY);
431 gezelter 1979 #line 92 "MDParser.g"
432 gezelter 1782 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 1782 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 1782 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 1782 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 1782 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 1782 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 1782 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 1782 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 1782 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 gezelter 1979 case CONSTRAINT:
688     {
689     constraintblock();
690     astFactory->addASTChild( currentAST, returnAST );
691     moleculestatement_AST = currentAST.root;
692     break;
693     }
694 tim 770 default:
695     {
696     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
697     }
698     }
699     }
700     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
701     reportError(ex);
702 gezelter 1277 recover(ex,_tokenSet_8);
703 tim 770 }
704     returnAST = moleculestatement_AST;
705     }
706    
707     void MDParser::atomblock() {
708     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
709     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
710     ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
711    
712     try { // for error handling
713 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
714     tmp35_AST = astFactory->create(LT(1));
715     astFactory->makeASTRoot(currentAST, tmp35_AST);
716 tim 770 match(ATOM);
717     match(LBRACKET);
718     intConst();
719     astFactory->addASTChild( currentAST, returnAST );
720     match(RBRACKET);
721     match(LCURLY);
722     { // ( ... )*
723     for (;;) {
724 tim 814 if ((_tokenSet_9.member(LA(1)))) {
725 tim 770 atomstatement();
726     astFactory->addASTChild( currentAST, returnAST );
727     }
728     else {
729 gezelter 1782 goto _loop31;
730 tim 770 }
731    
732     }
733 gezelter 1782 _loop31:;
734 tim 770 } // ( ... )*
735 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
736     tmp39_AST = astFactory->create(LT(1));
737     astFactory->addASTChild(currentAST, tmp39_AST);
738 tim 770 match(RCURLY);
739 gezelter 1979 #line 110 "MDParser.g"
740 gezelter 1782 tmp39_AST->setType(ENDBLOCK);
741 gezelter 1979 #line 742 "MDParser.cpp"
742 tim 770 atomblock_AST = currentAST.root;
743     }
744     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
745     reportError(ex);
746 gezelter 1277 recover(ex,_tokenSet_8);
747 tim 770 }
748     returnAST = atomblock_AST;
749     }
750    
751     void MDParser::bondblock() {
752     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
753     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
754     ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
755    
756     try { // for error handling
757 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
758     tmp40_AST = astFactory->create(LT(1));
759     astFactory->makeASTRoot(currentAST, tmp40_AST);
760 tim 770 match(BOND);
761     {
762     switch ( LA(1)) {
763     case LBRACKET:
764     {
765     match(LBRACKET);
766     intConst();
767     match(RBRACKET);
768     break;
769     }
770     case LCURLY:
771     {
772     break;
773     }
774     default:
775     {
776     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
777     }
778     }
779     }
780     match(LCURLY);
781     { // ( ... )*
782     for (;;) {
783     if ((LA(1) == MEMBERS || LA(1) == ID)) {
784     bondstatement();
785     astFactory->addASTChild( currentAST, returnAST );
786     }
787     else {
788 gezelter 1782 goto _loop36;
789 tim 770 }
790    
791     }
792 gezelter 1782 _loop36:;
793 tim 770 } // ( ... )*
794 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
795     tmp44_AST = astFactory->create(LT(1));
796     astFactory->addASTChild(currentAST, tmp44_AST);
797 tim 770 match(RCURLY);
798 gezelter 1979 #line 119 "MDParser.g"
799 gezelter 1782 tmp44_AST->setType(ENDBLOCK);
800 gezelter 1979 #line 801 "MDParser.cpp"
801 tim 770 bondblock_AST = currentAST.root;
802     }
803     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
804     reportError(ex);
805 gezelter 1277 recover(ex,_tokenSet_8);
806 tim 770 }
807     returnAST = bondblock_AST;
808     }
809    
810     void MDParser::bendblock() {
811     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
812     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
813     ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
814    
815     try { // for error handling
816 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
817     tmp45_AST = astFactory->create(LT(1));
818     astFactory->makeASTRoot(currentAST, tmp45_AST);
819 tim 770 match(BEND);
820     {
821     switch ( LA(1)) {
822     case LBRACKET:
823     {
824     match(LBRACKET);
825     intConst();
826     match(RBRACKET);
827     break;
828     }
829     case LCURLY:
830     {
831     break;
832     }
833     default:
834     {
835     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
836     }
837     }
838     }
839     match(LCURLY);
840     { // ( ... )*
841     for (;;) {
842     if ((LA(1) == MEMBERS || LA(1) == ID)) {
843     bendstatement();
844     astFactory->addASTChild( currentAST, returnAST );
845     }
846     else {
847 gezelter 1782 goto _loop41;
848 tim 770 }
849    
850     }
851 gezelter 1782 _loop41:;
852 tim 770 } // ( ... )*
853 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
854     tmp49_AST = astFactory->create(LT(1));
855     astFactory->addASTChild(currentAST, tmp49_AST);
856 tim 770 match(RCURLY);
857 gezelter 1979 #line 126 "MDParser.g"
858 gezelter 1782 tmp49_AST->setType(ENDBLOCK);
859 gezelter 1979 #line 860 "MDParser.cpp"
860 tim 770 bendblock_AST = currentAST.root;
861     }
862     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
863     reportError(ex);
864 gezelter 1277 recover(ex,_tokenSet_8);
865 tim 770 }
866     returnAST = bendblock_AST;
867     }
868    
869     void MDParser::torsionblock() {
870     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
871     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
872     ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
873    
874     try { // for error handling
875 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
876     tmp50_AST = astFactory->create(LT(1));
877     astFactory->makeASTRoot(currentAST, tmp50_AST);
878 tim 770 match(TORSION);
879     {
880     switch ( LA(1)) {
881     case LBRACKET:
882     {
883     match(LBRACKET);
884     intConst();
885     match(RBRACKET);
886     break;
887     }
888     case LCURLY:
889     {
890     break;
891     }
892     default:
893     {
894     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
895     }
896     }
897     }
898     match(LCURLY);
899     { // ( ... )*
900     for (;;) {
901     if ((LA(1) == MEMBERS || LA(1) == ID)) {
902     torsionstatement();
903     astFactory->addASTChild( currentAST, returnAST );
904     }
905     else {
906 gezelter 1782 goto _loop46;
907 tim 770 }
908    
909     }
910 gezelter 1782 _loop46:;
911 tim 770 } // ( ... )*
912 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
913     tmp54_AST = astFactory->create(LT(1));
914     astFactory->addASTChild(currentAST, tmp54_AST);
915 tim 770 match(RCURLY);
916 gezelter 1979 #line 133 "MDParser.g"
917 gezelter 1782 tmp54_AST->setType(ENDBLOCK);
918 gezelter 1979 #line 919 "MDParser.cpp"
919 tim 770 torsionblock_AST = currentAST.root;
920     }
921     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
922     reportError(ex);
923 gezelter 1277 recover(ex,_tokenSet_8);
924 tim 770 }
925     returnAST = torsionblock_AST;
926     }
927    
928 gezelter 1277 void MDParser::inversionblock() {
929 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
930     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
931 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
932 tim 770
933     try { // for error handling
934 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
935     tmp55_AST = astFactory->create(LT(1));
936     astFactory->makeASTRoot(currentAST, tmp55_AST);
937 gezelter 1277 match(INVERSION);
938     {
939     switch ( LA(1)) {
940     case LBRACKET:
941     {
942     match(LBRACKET);
943     intConst();
944     match(RBRACKET);
945     break;
946     }
947     case LCURLY:
948     {
949     break;
950     }
951     default:
952     {
953     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
954     }
955     }
956     }
957     match(LCURLY);
958     { // ( ... )*
959     for (;;) {
960 gezelter 1902 if ((_tokenSet_10.member(LA(1)))) {
961 gezelter 1277 inversionstatement();
962     astFactory->addASTChild( currentAST, returnAST );
963     }
964     else {
965 gezelter 1782 goto _loop51;
966 gezelter 1277 }
967    
968     }
969 gezelter 1782 _loop51:;
970 gezelter 1277 } // ( ... )*
971 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
972     tmp59_AST = astFactory->create(LT(1));
973     astFactory->addASTChild(currentAST, tmp59_AST);
974 gezelter 1277 match(RCURLY);
975 gezelter 1979 #line 140 "MDParser.g"
976 gezelter 1782 tmp59_AST->setType(ENDBLOCK);
977 gezelter 1979 #line 978 "MDParser.cpp"
978 gezelter 1277 inversionblock_AST = currentAST.root;
979     }
980     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
981     reportError(ex);
982     recover(ex,_tokenSet_8);
983     }
984     returnAST = inversionblock_AST;
985     }
986    
987     void MDParser::rigidbodyblock() {
988     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
989     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
990     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
991    
992     try { // for error handling
993 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
994     tmp60_AST = astFactory->create(LT(1));
995     astFactory->makeASTRoot(currentAST, tmp60_AST);
996 tim 770 match(RIGIDBODY);
997     match(LBRACKET);
998     intConst();
999     astFactory->addASTChild( currentAST, returnAST );
1000     match(RBRACKET);
1001     match(LCURLY);
1002     { // ( ... )*
1003     for (;;) {
1004     if ((LA(1) == MEMBERS || LA(1) == ID)) {
1005     rigidbodystatement();
1006     astFactory->addASTChild( currentAST, returnAST );
1007     }
1008     else {
1009 gezelter 1782 goto _loop55;
1010 tim 770 }
1011    
1012     }
1013 gezelter 1782 _loop55:;
1014 tim 770 } // ( ... )*
1015 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1016     tmp64_AST = astFactory->create(LT(1));
1017     astFactory->addASTChild(currentAST, tmp64_AST);
1018 tim 770 match(RCURLY);
1019 gezelter 1979 #line 148 "MDParser.g"
1020 gezelter 1782 tmp64_AST->setType(ENDBLOCK);
1021 gezelter 1979 #line 1022 "MDParser.cpp"
1022 tim 770 rigidbodyblock_AST = currentAST.root;
1023     }
1024     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1025     reportError(ex);
1026 gezelter 1277 recover(ex,_tokenSet_8);
1027 tim 770 }
1028     returnAST = rigidbodyblock_AST;
1029     }
1030    
1031     void MDParser::cutoffgroupblock() {
1032     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1033     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1034     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1035    
1036     try { // for error handling
1037 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1038     tmp65_AST = astFactory->create(LT(1));
1039     astFactory->makeASTRoot(currentAST, tmp65_AST);
1040 tim 770 match(CUTOFFGROUP);
1041     {
1042     switch ( LA(1)) {
1043     case LBRACKET:
1044     {
1045     match(LBRACKET);
1046     intConst();
1047     match(RBRACKET);
1048     break;
1049     }
1050     case LCURLY:
1051     {
1052     break;
1053     }
1054     default:
1055     {
1056     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1057     }
1058     }
1059     }
1060     match(LCURLY);
1061     { // ( ... )*
1062     for (;;) {
1063     if ((LA(1) == MEMBERS || LA(1) == ID)) {
1064     cutoffgroupstatement();
1065     astFactory->addASTChild( currentAST, returnAST );
1066     }
1067     else {
1068 gezelter 1782 goto _loop60;
1069 tim 770 }
1070    
1071     }
1072 gezelter 1782 _loop60:;
1073 tim 770 } // ( ... )*
1074 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1075     tmp69_AST = astFactory->create(LT(1));
1076     astFactory->addASTChild(currentAST, tmp69_AST);
1077 tim 770 match(RCURLY);
1078 gezelter 1979 #line 155 "MDParser.g"
1079 gezelter 1782 tmp69_AST->setType(ENDBLOCK);
1080 gezelter 1979 #line 1081 "MDParser.cpp"
1081 tim 770 cutoffgroupblock_AST = currentAST.root;
1082     }
1083     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1084     reportError(ex);
1085 gezelter 1277 recover(ex,_tokenSet_8);
1086 tim 770 }
1087     returnAST = cutoffgroupblock_AST;
1088     }
1089    
1090     void MDParser::fragmentblock() {
1091     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1092     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1093     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1094    
1095     try { // for error handling
1096 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1097     tmp70_AST = astFactory->create(LT(1));
1098     astFactory->makeASTRoot(currentAST, tmp70_AST);
1099 tim 770 match(FRAGMENT);
1100     match(LBRACKET);
1101     intConst();
1102     astFactory->addASTChild( currentAST, returnAST );
1103     match(RBRACKET);
1104     match(LCURLY);
1105     { // ( ... )*
1106     for (;;) {
1107     if ((LA(1) == ID)) {
1108     fragmentstatement();
1109     astFactory->addASTChild( currentAST, returnAST );
1110     }
1111     else {
1112 gezelter 1782 goto _loop64;
1113 tim 770 }
1114    
1115     }
1116 gezelter 1782 _loop64:;
1117 tim 770 } // ( ... )*
1118 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp74_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1119     tmp74_AST = astFactory->create(LT(1));
1120     astFactory->addASTChild(currentAST, tmp74_AST);
1121 tim 770 match(RCURLY);
1122 gezelter 1979 #line 162 "MDParser.g"
1123 gezelter 1782 tmp74_AST->setType(ENDBLOCK);
1124 gezelter 1979 #line 1125 "MDParser.cpp"
1125 tim 770 fragmentblock_AST = currentAST.root;
1126     }
1127     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1128     reportError(ex);
1129 gezelter 1277 recover(ex,_tokenSet_8);
1130 tim 770 }
1131     returnAST = fragmentblock_AST;
1132     }
1133    
1134 gezelter 1979 void MDParser::constraintblock() {
1135     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1136     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1137     ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1138    
1139     try { // for error handling
1140     ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1141     tmp75_AST = astFactory->create(LT(1));
1142     astFactory->makeASTRoot(currentAST, tmp75_AST);
1143     match(CONSTRAINT);
1144     {
1145     switch ( LA(1)) {
1146     case LBRACKET:
1147     {
1148     match(LBRACKET);
1149     intConst();
1150     match(RBRACKET);
1151     break;
1152     }
1153     case LCURLY:
1154     {
1155     break;
1156     }
1157     default:
1158     {
1159     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1160     }
1161     }
1162     }
1163     match(LCURLY);
1164     { // ( ... )*
1165     for (;;) {
1166     if ((LA(1) == MEMBERS || LA(1) == ID)) {
1167     constraintstatement();
1168     astFactory->addASTChild( currentAST, returnAST );
1169     }
1170     else {
1171     goto _loop69;
1172     }
1173    
1174     }
1175     _loop69:;
1176     } // ( ... )*
1177     ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1178     tmp79_AST = astFactory->create(LT(1));
1179     astFactory->addASTChild(currentAST, tmp79_AST);
1180     match(RCURLY);
1181     #line 168 "MDParser.g"
1182     tmp79_AST->setType(ENDBLOCK);
1183     #line 1184 "MDParser.cpp"
1184     constraintblock_AST = currentAST.root;
1185     }
1186     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1187     reportError(ex);
1188     recover(ex,_tokenSet_8);
1189     }
1190     returnAST = constraintblock_AST;
1191     }
1192    
1193 tim 770 void MDParser::atomstatement() {
1194     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1195     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1196     ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1197    
1198     try { // for error handling
1199     switch ( LA(1)) {
1200     case ID:
1201     {
1202     assignment();
1203     astFactory->addASTChild( currentAST, returnAST );
1204     atomstatement_AST = currentAST.root;
1205     break;
1206     }
1207     case POSITION:
1208     {
1209 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1210     tmp80_AST = astFactory->create(LT(1));
1211     astFactory->makeASTRoot(currentAST, tmp80_AST);
1212 tim 770 match(POSITION);
1213     match(LPAREN);
1214 tim 814 doubleNumberTuple();
1215 tim 770 astFactory->addASTChild( currentAST, returnAST );
1216     match(RPAREN);
1217     match(SEMICOLON);
1218     atomstatement_AST = currentAST.root;
1219     break;
1220     }
1221     case ORIENTATION:
1222     {
1223 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1224     tmp84_AST = astFactory->create(LT(1));
1225     astFactory->makeASTRoot(currentAST, tmp84_AST);
1226 tim 770 match(ORIENTATION);
1227     match(LPAREN);
1228 tim 814 doubleNumberTuple();
1229 tim 770 astFactory->addASTChild( currentAST, returnAST );
1230     match(RPAREN);
1231     match(SEMICOLON);
1232     atomstatement_AST = currentAST.root;
1233     break;
1234     }
1235     default:
1236     {
1237     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1238     }
1239     }
1240     }
1241     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1242     reportError(ex);
1243 gezelter 1902 recover(ex,_tokenSet_11);
1244 tim 770 }
1245     returnAST = atomstatement_AST;
1246     }
1247    
1248 tim 814 void MDParser::doubleNumberTuple() {
1249 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1250     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1251 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1252 tim 770
1253     try { // for error handling
1254 tim 814 doubleNumber();
1255 tim 770 astFactory->addASTChild( currentAST, returnAST );
1256     { // ( ... )*
1257     for (;;) {
1258     if ((LA(1) == COMMA)) {
1259     match(COMMA);
1260 tim 814 doubleNumber();
1261 tim 770 astFactory->addASTChild( currentAST, returnAST );
1262     }
1263     else {
1264 gezelter 1979 goto _loop73;
1265 tim 770 }
1266    
1267     }
1268 gezelter 1979 _loop73:;
1269 tim 770 } // ( ... )*
1270 tim 814 doubleNumberTuple_AST = currentAST.root;
1271 tim 770 }
1272     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1273     reportError(ex);
1274 gezelter 1902 recover(ex,_tokenSet_12);
1275 tim 770 }
1276 tim 814 returnAST = doubleNumberTuple_AST;
1277 tim 770 }
1278    
1279     void MDParser::bondstatement() {
1280     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1281     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1282     ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1283    
1284     try { // for error handling
1285     switch ( LA(1)) {
1286     case ID:
1287     {
1288     assignment();
1289     astFactory->addASTChild( currentAST, returnAST );
1290     bondstatement_AST = currentAST.root;
1291     break;
1292     }
1293     case MEMBERS:
1294     {
1295 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp89_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1296     tmp89_AST = astFactory->create(LT(1));
1297     astFactory->makeASTRoot(currentAST, tmp89_AST);
1298 tim 770 match(MEMBERS);
1299     match(LPAREN);
1300     inttuple();
1301     astFactory->addASTChild( currentAST, returnAST );
1302     match(RPAREN);
1303     match(SEMICOLON);
1304     bondstatement_AST = currentAST.root;
1305     break;
1306     }
1307     default:
1308     {
1309     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1310     }
1311     }
1312     }
1313     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1314     reportError(ex);
1315 gezelter 1902 recover(ex,_tokenSet_13);
1316 tim 770 }
1317     returnAST = bondstatement_AST;
1318     }
1319    
1320     void MDParser::inttuple() {
1321     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1322     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1323     ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1324    
1325     try { // for error handling
1326     intConst();
1327     astFactory->addASTChild( currentAST, returnAST );
1328     { // ( ... )*
1329     for (;;) {
1330     if ((LA(1) == COMMA)) {
1331     match(COMMA);
1332     intConst();
1333     astFactory->addASTChild( currentAST, returnAST );
1334     }
1335     else {
1336 gezelter 1979 goto _loop76;
1337 tim 770 }
1338    
1339     }
1340 gezelter 1979 _loop76:;
1341 tim 770 } // ( ... )*
1342     inttuple_AST = currentAST.root;
1343     }
1344     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1345     reportError(ex);
1346 gezelter 1902 recover(ex,_tokenSet_12);
1347 tim 770 }
1348     returnAST = inttuple_AST;
1349     }
1350    
1351     void MDParser::bendstatement() {
1352     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1353     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1354     ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1355    
1356     try { // for error handling
1357     switch ( LA(1)) {
1358     case ID:
1359     {
1360     assignment();
1361     astFactory->addASTChild( currentAST, returnAST );
1362     bendstatement_AST = currentAST.root;
1363     break;
1364     }
1365     case MEMBERS:
1366     {
1367 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1368     tmp94_AST = astFactory->create(LT(1));
1369     astFactory->makeASTRoot(currentAST, tmp94_AST);
1370 tim 770 match(MEMBERS);
1371     match(LPAREN);
1372     inttuple();
1373     astFactory->addASTChild( currentAST, returnAST );
1374     match(RPAREN);
1375     match(SEMICOLON);
1376     bendstatement_AST = currentAST.root;
1377     break;
1378     }
1379     default:
1380     {
1381     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1382     }
1383     }
1384     }
1385     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1386     reportError(ex);
1387 gezelter 1902 recover(ex,_tokenSet_13);
1388 tim 770 }
1389     returnAST = bendstatement_AST;
1390     }
1391    
1392     void MDParser::torsionstatement() {
1393     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1394     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1395     ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1396    
1397     try { // for error handling
1398     switch ( LA(1)) {
1399     case ID:
1400     {
1401     assignment();
1402     astFactory->addASTChild( currentAST, returnAST );
1403     torsionstatement_AST = currentAST.root;
1404     break;
1405     }
1406     case MEMBERS:
1407     {
1408 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1409     tmp98_AST = astFactory->create(LT(1));
1410     astFactory->makeASTRoot(currentAST, tmp98_AST);
1411 tim 770 match(MEMBERS);
1412     match(LPAREN);
1413     inttuple();
1414     astFactory->addASTChild( currentAST, returnAST );
1415     match(RPAREN);
1416     match(SEMICOLON);
1417     torsionstatement_AST = currentAST.root;
1418     break;
1419     }
1420     default:
1421     {
1422     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1423     }
1424     }
1425     }
1426     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1427     reportError(ex);
1428 gezelter 1902 recover(ex,_tokenSet_13);
1429 tim 770 }
1430     returnAST = torsionstatement_AST;
1431     }
1432    
1433 cli2 1275 void MDParser::inversionstatement() {
1434     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1435     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1436     ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1437    
1438     try { // for error handling
1439     switch ( LA(1)) {
1440     case ID:
1441     {
1442     assignment();
1443     astFactory->addASTChild( currentAST, returnAST );
1444     inversionstatement_AST = currentAST.root;
1445     break;
1446     }
1447     case CENTER:
1448     {
1449 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp102_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1450     tmp102_AST = astFactory->create(LT(1));
1451     astFactory->makeASTRoot(currentAST, tmp102_AST);
1452 cli2 1275 match(CENTER);
1453     match(LPAREN);
1454     intConst();
1455     astFactory->addASTChild( currentAST, returnAST );
1456     match(RPAREN);
1457     match(SEMICOLON);
1458     inversionstatement_AST = currentAST.root;
1459     break;
1460     }
1461 gezelter 1902 case SATELLITES:
1462     {
1463 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp106_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1464     tmp106_AST = astFactory->create(LT(1));
1465     astFactory->makeASTRoot(currentAST, tmp106_AST);
1466 gezelter 1902 match(SATELLITES);
1467     match(LPAREN);
1468     inttuple();
1469     astFactory->addASTChild( currentAST, returnAST );
1470     match(RPAREN);
1471     match(SEMICOLON);
1472     inversionstatement_AST = currentAST.root;
1473     break;
1474     }
1475 cli2 1275 default:
1476     {
1477     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1478     }
1479     }
1480     }
1481     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1482     reportError(ex);
1483 gezelter 1902 recover(ex,_tokenSet_14);
1484 cli2 1275 }
1485     returnAST = inversionstatement_AST;
1486     }
1487    
1488 tim 770 void MDParser::rigidbodystatement() {
1489     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1490     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1491     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1492    
1493     try { // for error handling
1494     switch ( LA(1)) {
1495     case ID:
1496     {
1497     assignment();
1498     astFactory->addASTChild( currentAST, returnAST );
1499     rigidbodystatement_AST = currentAST.root;
1500     break;
1501     }
1502     case MEMBERS:
1503     {
1504 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp110_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1505     tmp110_AST = astFactory->create(LT(1));
1506     astFactory->makeASTRoot(currentAST, tmp110_AST);
1507 tim 770 match(MEMBERS);
1508     match(LPAREN);
1509     inttuple();
1510     astFactory->addASTChild( currentAST, returnAST );
1511     match(RPAREN);
1512     match(SEMICOLON);
1513     rigidbodystatement_AST = currentAST.root;
1514     break;
1515     }
1516     default:
1517     {
1518     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1519     }
1520     }
1521     }
1522     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1523     reportError(ex);
1524 gezelter 1902 recover(ex,_tokenSet_13);
1525 tim 770 }
1526     returnAST = rigidbodystatement_AST;
1527     }
1528    
1529     void MDParser::cutoffgroupstatement() {
1530     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1531     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1532     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1533    
1534     try { // for error handling
1535     switch ( LA(1)) {
1536     case ID:
1537     {
1538     assignment();
1539     astFactory->addASTChild( currentAST, returnAST );
1540     cutoffgroupstatement_AST = currentAST.root;
1541     break;
1542     }
1543     case MEMBERS:
1544     {
1545 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp114_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1546     tmp114_AST = astFactory->create(LT(1));
1547     astFactory->makeASTRoot(currentAST, tmp114_AST);
1548 tim 770 match(MEMBERS);
1549     match(LPAREN);
1550     inttuple();
1551     astFactory->addASTChild( currentAST, returnAST );
1552     match(RPAREN);
1553     match(SEMICOLON);
1554     cutoffgroupstatement_AST = currentAST.root;
1555     break;
1556     }
1557     default:
1558     {
1559     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1560     }
1561     }
1562     }
1563     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1564     reportError(ex);
1565 gezelter 1902 recover(ex,_tokenSet_13);
1566 tim 770 }
1567     returnAST = cutoffgroupstatement_AST;
1568     }
1569    
1570     void MDParser::fragmentstatement() {
1571     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1572     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1573     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1574    
1575     try { // for error handling
1576     assignment();
1577     astFactory->addASTChild( currentAST, returnAST );
1578     fragmentstatement_AST = currentAST.root;
1579     }
1580     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1581     reportError(ex);
1582 gezelter 1902 recover(ex,_tokenSet_15);
1583 tim 770 }
1584     returnAST = fragmentstatement_AST;
1585     }
1586    
1587 gezelter 1979 void MDParser::constraintstatement() {
1588     returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1589     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1590     ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1591    
1592     try { // for error handling
1593     switch ( LA(1)) {
1594     case ID:
1595     {
1596     assignment();
1597     astFactory->addASTChild( currentAST, returnAST );
1598     constraintstatement_AST = currentAST.root;
1599     break;
1600     }
1601     case MEMBERS:
1602     {
1603     ANTLR_USE_NAMESPACE(antlr)RefAST tmp118_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1604     tmp118_AST = astFactory->create(LT(1));
1605     astFactory->makeASTRoot(currentAST, tmp118_AST);
1606     match(MEMBERS);
1607     match(LPAREN);
1608     inttuple();
1609     astFactory->addASTChild( currentAST, returnAST );
1610     match(RPAREN);
1611     match(SEMICOLON);
1612     constraintstatement_AST = currentAST.root;
1613     break;
1614     }
1615     default:
1616     {
1617     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1618     }
1619     }
1620     }
1621     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1622     reportError(ex);
1623     recover(ex,_tokenSet_13);
1624     }
1625     returnAST = constraintstatement_AST;
1626     }
1627    
1628 tim 814 void MDParser::doubleNumber() {
1629 tim 770 returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1630     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
1631 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1632 tim 770
1633     try { // for error handling
1634 tim 814 {
1635 tim 770 switch ( LA(1)) {
1636 tim 814 case NUM_INT:
1637     case NUM_LONG:
1638 tim 770 {
1639 tim 814 intConst();
1640     astFactory->addASTChild( currentAST, returnAST );
1641 tim 770 break;
1642     }
1643 tim 814 case NUM_FLOAT:
1644     case NUM_DOUBLE:
1645 tim 770 {
1646 tim 814 floatConst();
1647     astFactory->addASTChild( currentAST, returnAST );
1648 tim 770 break;
1649     }
1650     default:
1651     {
1652     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
1653     }
1654     }
1655 tim 814 }
1656     doubleNumber_AST = currentAST.root;
1657 tim 770 }
1658     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1659     reportError(ex);
1660 gezelter 1902 recover(ex,_tokenSet_16);
1661 tim 770 }
1662 tim 814 returnAST = doubleNumber_AST;
1663 tim 770 }
1664    
1665     void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1666     {
1667 gezelter 1979 factory.setMaxNodeType(59);
1668 tim 770 }
1669     const char* MDParser::tokenNames[] = {
1670     "<0>",
1671     "EOF",
1672     "<2>",
1673     "NULL_TREE_LOOKAHEAD",
1674     "\"component\"",
1675     "\"molecule\"",
1676     "\"zconstraint\"",
1677 cli2 1360 "\"restraint\"",
1678 tim 770 "\"atom\"",
1679     "\"bond\"",
1680     "\"bend\"",
1681     "\"torsion\"",
1682 cli2 1275 "\"inversion\"",
1683 tim 770 "\"rigidBody\"",
1684     "\"cutoffGroup\"",
1685 gezelter 1979 "\"constraint\"",
1686     "\"distance\"",
1687 tim 770 "\"fragment\"",
1688     "\"members\"",
1689 cli2 1275 "\"center\"",
1690 gezelter 1902 "\"satellites\"",
1691 tim 770 "\"position\"",
1692     "\"orientation\"",
1693 gezelter 1782 "\"flucQ\"",
1694     "\"RNEMD\"",
1695     "\"minimizer\"",
1696 tim 770 "ENDBLOCK",
1697     "ID",
1698     "ASSIGNEQUAL",
1699     "SEMICOLON",
1700     "StringLiteral",
1701     "LCURLY",
1702     "RCURLY",
1703     "LBRACKET",
1704     "RBRACKET",
1705     "LPAREN",
1706     "RPAREN",
1707     "COMMA",
1708 tim 814 "NUM_INT",
1709     "NUM_LONG",
1710     "NUM_FLOAT",
1711     "NUM_DOUBLE",
1712 tim 770 "DOT",
1713     "COLON",
1714     "QUESTIONMARK",
1715     "Whitespace",
1716     "Comment",
1717     "CPPComment",
1718     "a line directive",
1719     "LineDirective",
1720     "Space",
1721     "CharLiteral",
1722     "EndOfLine",
1723     "Escape",
1724 tim 814 "Vocabulary",
1725 tim 770 "Digit",
1726     "Decimal",
1727 tim 814 "HEX_DIGIT",
1728     "EXPONENT",
1729     "FLOAT_SUFFIX",
1730 tim 770 0
1731     };
1732    
1733 gezelter 1979 const unsigned long MDParser::_tokenSet_0_data_[] = { 192938224UL, 0UL, 0UL, 0UL };
1734 gezelter 1782 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1735     // ID
1736 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1737     const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1738     // EOF
1739     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1740 gezelter 1979 const unsigned long MDParser::_tokenSet_2_data_[] = { 192938226UL, 0UL, 0UL, 0UL };
1741 gezelter 1782 // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1742     // "minimizer" ID
1743 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1744 gezelter 1979 const unsigned long MDParser::_tokenSet_3_data_[] = { 201261042UL, 1UL, 0UL, 0UL };
1745 cli2 1360 // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1746 gezelter 1979 // "torsion" "inversion" "rigidBody" "cutoffGroup" "constraint" "fragment"
1747     // "members" "center" "satellites" "position" "orientation" "flucQ" "RNEMD"
1748     // "minimizer" ID RCURLY
1749 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1750 gezelter 1979 const unsigned long MDParser::_tokenSet_4_data_[] = { 134414080UL, 0UL, 0UL, 0UL };
1751 gezelter 1277 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1752 gezelter 1979 // "constraint" "fragment" ID
1753 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1754 gezelter 1979 const unsigned long MDParser::_tokenSet_5_data_[] = { 536870912UL, 0UL, 0UL, 0UL };
1755 tim 770 // SEMICOLON
1756     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1757 gezelter 1979 const unsigned long MDParser::_tokenSet_6_data_[] = { 536870912UL, 52UL, 0UL, 0UL };
1758 tim 814 // SEMICOLON RBRACKET RPAREN COMMA
1759     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1760 gezelter 1979 const unsigned long MDParser::_tokenSet_7_data_[] = { 536870912UL, 48UL, 0UL, 0UL };
1761 tim 770 // SEMICOLON RPAREN COMMA
1762 tim 814 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1763 gezelter 1979 const unsigned long MDParser::_tokenSet_8_data_[] = { 134414080UL, 1UL, 0UL, 0UL };
1764 gezelter 1277 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1765 gezelter 1979 // "constraint" "fragment" ID RCURLY
1766 tim 814 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1767 gezelter 1979 const unsigned long MDParser::_tokenSet_9_data_[] = { 140509184UL, 0UL, 0UL, 0UL };
1768 tim 770 // "position" "orientation" ID
1769     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1770 gezelter 1979 const unsigned long MDParser::_tokenSet_10_data_[] = { 135790592UL, 0UL, 0UL, 0UL };
1771 gezelter 1902 // "center" "satellites" ID
1772     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1773 gezelter 1979 const unsigned long MDParser::_tokenSet_11_data_[] = { 140509184UL, 1UL, 0UL, 0UL };
1774 tim 770 // "position" "orientation" ID RCURLY
1775 gezelter 1902 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1776 gezelter 1979 const unsigned long MDParser::_tokenSet_12_data_[] = { 0UL, 16UL, 0UL, 0UL };
1777 tim 770 // RPAREN
1778 gezelter 1902 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1779 gezelter 1979 const unsigned long MDParser::_tokenSet_13_data_[] = { 134479872UL, 1UL, 0UL, 0UL };
1780 tim 770 // "members" ID RCURLY
1781 cli2 1275 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1782 gezelter 1979 const unsigned long MDParser::_tokenSet_14_data_[] = { 135790592UL, 1UL, 0UL, 0UL };
1783 gezelter 1902 // "center" "satellites" ID RCURLY
1784     const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1785 gezelter 1979 const unsigned long MDParser::_tokenSet_15_data_[] = { 134217728UL, 1UL, 0UL, 0UL };
1786 tim 770 // ID RCURLY
1787 gezelter 1902 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1788 gezelter 1979 const unsigned long MDParser::_tokenSet_16_data_[] = { 0UL, 48UL, 0UL, 0UL };
1789 tim 814 // RPAREN COMMA
1790 gezelter 1902 const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_16(_tokenSet_16_data_,4);
1791 tim 770
1792    

Properties

Name Value
svn:keywords Author Id Revision Date