ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDTreeParser.cpp
Revision: 1746
Committed: Wed Jun 6 02:18:54 2012 UTC (12 years, 10 months ago) by gezelter
File size: 44046 byte(s)
Log Message: 
added a minimizer parsing block

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

Properties

Name Value
svn:keywords Author Id Revision Date