ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDTreeParser.cpp
Revision: 1731
Committed: Thu May 31 12:25:30 2012 UTC (13 years, 5 months ago) by gezelter
File size: 42633 byte(s)
Log Message: 
Reorganized source directories, added RNEMD and flucQ blocks for
options parsing.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date