ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDParser.cpp
Revision: 2040
Committed: Thu Nov 13 17:49:44 2014 UTC (10 years, 5 months ago) by gezelter
File size: 47504 byte(s)
Log Message: 
Added a vcorr2spectrum script to simplify the task of computing spectra

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date