ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 1782
Committed: Wed Aug 22 02:28:28 2012 UTC (12 years, 8 months ago) by gezelter
File size: 44908 byte(s)
Log Message: 
MERGE OpenMD development branch 1465:1781 into trunk

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date