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

File Contents

# User Rev Content
1 gezelter 1979 /* $ANTLR 2.7.7 (20140107): "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 1979 #line 314 "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 1979 #line 315 "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 1979 #line 316 "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 1979 #line 326 "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 1979 #line 327 "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 1979 #line 328 "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 gezelter 1979 #line 320 "MDTreeParser.g"
644 gezelter 1782 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 gezelter 1979 #line 321 "MDTreeParser.g"
661 gezelter 1782 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 gezelter 1979 #line 322 "MDTreeParser.g"
672 gezelter 1782 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 gezelter 1979 case CONSTRAINT:
753     {
754     constraintblock(_t);
755     _t = _retTree;
756     break;
757     }
758 tim 770 default:
759     {
760     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
761     }
762     }
763     }
764     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
765     reportError(ex);
766     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
767     _t = _t->getNextSibling();
768     }
769     _retTree = _t;
770     }
771    
772     void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
773 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
774 gezelter 1979 #line 120 "MDTreeParser.g"
775 tim 770
776     int index;
777    
778 gezelter 1979 #line 779 "MDTreeParser.cpp"
779 tim 770
780     try { // for error handling
781 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
782     ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
783 tim 770 match(_t,ATOM);
784     _t = _t->getFirstChild();
785     index=intConst(_t);
786     _t = _retTree;
787 gezelter 1979 #line 124 "MDTreeParser.g"
788 tim 770 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
789 gezelter 1979 #line 790 "MDTreeParser.cpp"
790 tim 770 { // ( ... )*
791     for (;;) {
792     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
793     _t = ASTNULL;
794     if ((_t->getType() == POSITION || _t->getType() == ORIENTATION || _t->getType() == ASSIGNEQUAL)) {
795     atomstatement(_t);
796     _t = _retTree;
797     }
798     else {
799 gezelter 1782 goto _loop41;
800 tim 770 }
801    
802     }
803 gezelter 1782 _loop41:;
804 tim 770 } // ( ... )*
805 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
806 tim 770 match(_t,ENDBLOCK);
807     _t = _t->getNextSibling();
808 gezelter 1782 _t = __t39;
809 tim 770 _t = _t->getNextSibling();
810 gezelter 1979 #line 126 "MDTreeParser.g"
811 tim 770
812     blockStack.top()->validate();
813     blockStack.pop();
814     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
815     currMoleculeStamp->addAtomStamp(currAtomStamp);
816    
817 gezelter 1979 #line 818 "MDTreeParser.cpp"
818 tim 770 }
819     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
820     reportError(ex);
821     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
822     _t = _t->getNextSibling();
823     }
824     _retTree = _t;
825     }
826    
827     void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
828 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
829 tim 770
830     try { // for error handling
831 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t46 = _t;
832     ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
833 tim 770 match(_t,BOND);
834     _t = _t->getFirstChild();
835 gezelter 1979 #line 146 "MDTreeParser.g"
836 tim 770 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
837 gezelter 1979 #line 838 "MDTreeParser.cpp"
838 tim 770 { // ( ... )*
839     for (;;) {
840     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
841     _t = ASTNULL;
842     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
843     bondstatement(_t);
844     _t = _retTree;
845     }
846     else {
847 gezelter 1782 goto _loop48;
848 tim 770 }
849    
850     }
851 gezelter 1782 _loop48:;
852 tim 770 } // ( ... )*
853 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
854 tim 770 match(_t,ENDBLOCK);
855     _t = _t->getNextSibling();
856 gezelter 1782 _t = __t46;
857 tim 770 _t = _t->getNextSibling();
858 gezelter 1979 #line 148 "MDTreeParser.g"
859 tim 770
860     blockStack.pop();
861     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
862     currMoleculeStamp->addBondStamp(currBondStamp);
863    
864 gezelter 1979 #line 865 "MDTreeParser.cpp"
865 tim 770 }
866     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
867     reportError(ex);
868     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
869     _t = _t->getNextSibling();
870     }
871     _retTree = _t;
872     }
873    
874     void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
875 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
876 tim 770
877     try { // for error handling
878 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
879     ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
880 tim 770 match(_t,BEND);
881     _t = _t->getFirstChild();
882 gezelter 1979 #line 164 "MDTreeParser.g"
883 tim 770 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
884 gezelter 1979 #line 885 "MDTreeParser.cpp"
885 tim 770 { // ( ... )*
886     for (;;) {
887     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
888     _t = ASTNULL;
889     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
890     bendstatement(_t);
891     _t = _retTree;
892     }
893     else {
894 gezelter 1782 goto _loop54;
895 tim 770 }
896    
897     }
898 gezelter 1782 _loop54:;
899 tim 770 } // ( ... )*
900 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
901 tim 770 match(_t,ENDBLOCK);
902     _t = _t->getNextSibling();
903 gezelter 1782 _t = __t52;
904 tim 770 _t = _t->getNextSibling();
905 gezelter 1979 #line 166 "MDTreeParser.g"
906 tim 770
907     blockStack.top()->validate();
908     blockStack.pop();
909     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
910     currMoleculeStamp->addBendStamp(currBendStamp);
911    
912 gezelter 1979 #line 913 "MDTreeParser.cpp"
913 tim 770 }
914     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
915     reportError(ex);
916     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
917     _t = _t->getNextSibling();
918     }
919     _retTree = _t;
920     }
921    
922     void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
923 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
924 tim 770
925     try { // for error handling
926 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t58 = _t;
927     ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
928 tim 770 match(_t,TORSION);
929     _t = _t->getFirstChild();
930 gezelter 1979 #line 183 "MDTreeParser.g"
931 tim 770 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
932 gezelter 1979 #line 933 "MDTreeParser.cpp"
933 tim 770 { // ( ... )*
934     for (;;) {
935     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
936     _t = ASTNULL;
937     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
938     torsionstatement(_t);
939     _t = _retTree;
940     }
941     else {
942 gezelter 1782 goto _loop60;
943 tim 770 }
944    
945     }
946 gezelter 1782 _loop60:;
947 tim 770 } // ( ... )*
948 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
949 tim 770 match(_t,ENDBLOCK);
950     _t = _t->getNextSibling();
951 gezelter 1782 _t = __t58;
952 tim 770 _t = _t->getNextSibling();
953 gezelter 1979 #line 185 "MDTreeParser.g"
954 tim 770
955     blockStack.top()->validate();
956     blockStack.pop();
957     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
958     currMoleculeStamp->addTorsionStamp(currTorsionStamp);
959    
960 gezelter 1979 #line 961 "MDTreeParser.cpp"
961 tim 770 }
962     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
963     reportError(ex);
964     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
965     _t = _t->getNextSibling();
966     }
967     _retTree = _t;
968     }
969    
970 cli2 1275 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
971 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
972 cli2 1275
973     try { // for error handling
974 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
975     ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
976 cli2 1275 match(_t,INVERSION);
977     _t = _t->getFirstChild();
978 gezelter 1979 #line 202 "MDTreeParser.g"
979 cli2 1275 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
980 gezelter 1979 #line 981 "MDTreeParser.cpp"
981 cli2 1275 { // ( ... )*
982     for (;;) {
983     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
984     _t = ASTNULL;
985 gezelter 1902 if ((_t->getType() == CENTER || _t->getType() == SATELLITES || _t->getType() == ASSIGNEQUAL)) {
986 cli2 1275 inversionstatement(_t);
987     _t = _retTree;
988     }
989     else {
990 gezelter 1782 goto _loop66;
991 cli2 1275 }
992    
993     }
994 gezelter 1782 _loop66:;
995 cli2 1275 } // ( ... )*
996 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
997 cli2 1275 match(_t,ENDBLOCK);
998     _t = _t->getNextSibling();
999 gezelter 1782 _t = __t64;
1000 cli2 1275 _t = _t->getNextSibling();
1001 gezelter 1979 #line 204 "MDTreeParser.g"
1002 cli2 1275
1003     blockStack.top()->validate();
1004     blockStack.pop();
1005     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1006     currMoleculeStamp->addInversionStamp(currInversionStamp);
1007    
1008 gezelter 1979 #line 1009 "MDTreeParser.cpp"
1009 cli2 1275 }
1010     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1011     reportError(ex);
1012     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1013     _t = _t->getNextSibling();
1014     }
1015     _retTree = _t;
1016     }
1017    
1018 tim 770 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1019 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1020 gezelter 1979 #line 223 "MDTreeParser.g"
1021 tim 770
1022     int index;
1023    
1024 gezelter 1979 #line 1025 "MDTreeParser.cpp"
1025 tim 770
1026     try { // for error handling
1027 gezelter 1902 ANTLR_USE_NAMESPACE(antlr)RefAST __t71 = _t;
1028 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1029 tim 770 match(_t,RIGIDBODY);
1030     _t = _t->getFirstChild();
1031     index=intConst(_t);
1032     _t = _retTree;
1033 gezelter 1979 #line 227 "MDTreeParser.g"
1034 tim 770 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1035 gezelter 1979 #line 1036 "MDTreeParser.cpp"
1036 tim 770 { // ( ... )*
1037     for (;;) {
1038     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1039     _t = ASTNULL;
1040     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1041     rigidbodystatement(_t);
1042     _t = _retTree;
1043     }
1044     else {
1045 gezelter 1902 goto _loop73;
1046 tim 770 }
1047    
1048     }
1049 gezelter 1902 _loop73:;
1050 tim 770 } // ( ... )*
1051 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1052 tim 770 match(_t,ENDBLOCK);
1053     _t = _t->getNextSibling();
1054 gezelter 1902 _t = __t71;
1055 tim 770 _t = _t->getNextSibling();
1056 gezelter 1979 #line 229 "MDTreeParser.g"
1057 tim 770
1058     blockStack.top()->validate();
1059     blockStack.pop();
1060     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1061     currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1062    
1063 gezelter 1979 #line 1064 "MDTreeParser.cpp"
1064 tim 770 }
1065     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1066     reportError(ex);
1067     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1068     _t = _t->getNextSibling();
1069     }
1070     _retTree = _t;
1071     }
1072    
1073     void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1074 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1075 tim 770
1076     try { // for error handling
1077 gezelter 1902 ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1078 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1079 tim 770 match(_t,CUTOFFGROUP);
1080     _t = _t->getFirstChild();
1081 gezelter 1979 #line 246 "MDTreeParser.g"
1082 tim 770 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1083 gezelter 1979 #line 1084 "MDTreeParser.cpp"
1084 tim 770 { // ( ... )*
1085     for (;;) {
1086     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1087     _t = ASTNULL;
1088     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1089     cutoffgroupstatement(_t);
1090     _t = _retTree;
1091     }
1092     else {
1093 gezelter 1902 goto _loop79;
1094 tim 770 }
1095    
1096     }
1097 gezelter 1902 _loop79:;
1098 tim 770 } // ( ... )*
1099 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1100 tim 770 match(_t,ENDBLOCK);
1101     _t = _t->getNextSibling();
1102 gezelter 1902 _t = __t77;
1103 tim 770 _t = _t->getNextSibling();
1104 gezelter 1979 #line 248 "MDTreeParser.g"
1105 tim 770
1106     blockStack.top()->validate();
1107     blockStack.pop();
1108     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1109     currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1110    
1111 gezelter 1979 #line 1112 "MDTreeParser.cpp"
1112 tim 770 }
1113     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1114     reportError(ex);
1115     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1116     _t = _t->getNextSibling();
1117     }
1118     _retTree = _t;
1119     }
1120    
1121     void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1122 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1123 gezelter 1979 #line 265 "MDTreeParser.g"
1124 tim 770 int ival;
1125 gezelter 1979 #line 1126 "MDTreeParser.cpp"
1126 tim 770
1127     try { // for error handling
1128 gezelter 1902 ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1129 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1130 tim 770 match(_t,FRAGMENT);
1131     _t = _t->getFirstChild();
1132     ival=intConst(_t);
1133     _t = _retTree;
1134 gezelter 1979 #line 266 "MDTreeParser.g"
1135 tim 770 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1136 gezelter 1979 #line 1137 "MDTreeParser.cpp"
1137 tim 770 { // ( ... )*
1138     for (;;) {
1139     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1140     _t = ASTNULL;
1141     if ((_t->getType() == ASSIGNEQUAL)) {
1142     fragmentstatement(_t);
1143     _t = _retTree;
1144     }
1145     else {
1146 gezelter 1902 goto _loop85;
1147 tim 770 }
1148    
1149     }
1150 gezelter 1902 _loop85:;
1151 tim 770 } // ( ... )*
1152 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1153 tim 770 match(_t,ENDBLOCK);
1154     _t = _t->getNextSibling();
1155 gezelter 1902 _t = __t83;
1156 tim 770 _t = _t->getNextSibling();
1157 gezelter 1979 #line 268 "MDTreeParser.g"
1158 tim 770
1159     blockStack.top()->validate();
1160     blockStack.pop();
1161     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1162     currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1163    
1164 gezelter 1979 #line 1165 "MDTreeParser.cpp"
1165 tim 770 }
1166     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1167     reportError(ex);
1168     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1169     _t = _t->getNextSibling();
1170     }
1171     _retTree = _t;
1172     }
1173    
1174 gezelter 1979 void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1175     ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1176    
1177     try { // for error handling
1178     ANTLR_USE_NAMESPACE(antlr)RefAST __t88 = _t;
1179     ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1180     match(_t,CONSTRAINT);
1181     _t = _t->getFirstChild();
1182     #line 279 "MDTreeParser.g"
1183     ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1184     #line 1185 "MDTreeParser.cpp"
1185     { // ( ... )*
1186     for (;;) {
1187     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1188     _t = ASTNULL;
1189     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1190     constraintstatement(_t);
1191     _t = _retTree;
1192     }
1193     else {
1194     goto _loop90;
1195     }
1196    
1197     }
1198     _loop90:;
1199     } // ( ... )*
1200     ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1201     match(_t,ENDBLOCK);
1202     _t = _t->getNextSibling();
1203     _t = __t88;
1204     _t = _t->getNextSibling();
1205     #line 281 "MDTreeParser.g"
1206    
1207     blockStack.pop();
1208     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1209     currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1210    
1211     #line 1212 "MDTreeParser.cpp"
1212     }
1213     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1214     reportError(ex);
1215     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1216     _t = _t->getNextSibling();
1217     }
1218     _retTree = _t;
1219     }
1220    
1221 tim 770 void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1222 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1223 gezelter 1979 #line 134 "MDTreeParser.g"
1224 tim 770
1225 tim 963 vector<RealType> dvec;
1226 tim 770 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1227    
1228    
1229 gezelter 1979 #line 1230 "MDTreeParser.cpp"
1230 tim 770
1231     try { // for error handling
1232     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1233     _t = ASTNULL;
1234     switch ( _t->getType()) {
1235     case ASSIGNEQUAL:
1236     {
1237     assignment(_t);
1238     _t = _retTree;
1239     break;
1240     }
1241     case POSITION:
1242     {
1243 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1244 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1245 tim 770 match(_t,POSITION);
1246     _t = _t->getFirstChild();
1247 tim 814 dvec=doubleNumberTuple(_t);
1248 tim 770 _t = _retTree;
1249 gezelter 1782 _t = __t43;
1250 tim 770 _t = _t->getNextSibling();
1251 gezelter 1979 #line 141 "MDTreeParser.g"
1252 tim 770 currAtomStamp->setPosition(dvec);
1253 gezelter 1979 #line 1254 "MDTreeParser.cpp"
1254 tim 770 break;
1255     }
1256     case ORIENTATION:
1257     {
1258 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1259 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1260 tim 770 match(_t,ORIENTATION);
1261     _t = _t->getFirstChild();
1262 tim 814 dvec=doubleNumberTuple(_t);
1263 tim 770 _t = _retTree;
1264 gezelter 1782 _t = __t44;
1265 tim 770 _t = _t->getNextSibling();
1266 gezelter 1979 #line 142 "MDTreeParser.g"
1267 tim 770 currAtomStamp->setOrientation(dvec);
1268 gezelter 1979 #line 1269 "MDTreeParser.cpp"
1269 tim 770 break;
1270     }
1271     default:
1272     {
1273     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1274     }
1275     }
1276     }
1277     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1278     reportError(ex);
1279     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1280     _t = _t->getNextSibling();
1281     }
1282     _retTree = _t;
1283     }
1284    
1285 tim 963 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1286 gezelter 1979 #line 298 "MDTreeParser.g"
1287 tim 963 vector<RealType> dvec;
1288 gezelter 1979 #line 1289 "MDTreeParser.cpp"
1289 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1290 gezelter 1979 #line 298 "MDTreeParser.g"
1291 tim 770
1292 tim 963 RealType dval;
1293 tim 770
1294 gezelter 1979 #line 1295 "MDTreeParser.cpp"
1295 tim 770
1296     try { // for error handling
1297     { // ( ... )+
1298 gezelter 1979 int _cnt95=0;
1299 tim 770 for (;;) {
1300     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1301     _t = ASTNULL;
1302 tim 814 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1303     dval=doubleNumber(_t);
1304 tim 770 _t = _retTree;
1305 gezelter 1979 #line 302 "MDTreeParser.g"
1306 tim 770 dvec.push_back(dval);
1307 gezelter 1979 #line 1308 "MDTreeParser.cpp"
1308 tim 770 }
1309     else {
1310 gezelter 1979 if ( _cnt95>=1 ) { goto _loop95; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1311 tim 770 }
1312    
1313 gezelter 1979 _cnt95++;
1314 tim 770 }
1315 gezelter 1979 _loop95:;
1316 tim 770 } // ( ... )+
1317     }
1318     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1319     reportError(ex);
1320     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1321     _t = _t->getNextSibling();
1322     }
1323     _retTree = _t;
1324     return dvec;
1325     }
1326    
1327     void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1328 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 gezelter 1979 #line 155 "MDTreeParser.g"
1330 tim 770
1331     vector<int> ivec;
1332     BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1333    
1334 gezelter 1979 #line 1335 "MDTreeParser.cpp"
1335 tim 770
1336     try { // for error handling
1337     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1338     _t = ASTNULL;
1339     switch ( _t->getType()) {
1340     case ASSIGNEQUAL:
1341     {
1342     assignment(_t);
1343     _t = _retTree;
1344     break;
1345     }
1346     case MEMBERS:
1347     {
1348 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t50 = _t;
1349 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1350 tim 770 match(_t,MEMBERS);
1351     _t = _t->getFirstChild();
1352     ivec=inttuple(_t);
1353     _t = _retTree;
1354 gezelter 1782 _t = __t50;
1355 tim 770 _t = _t->getNextSibling();
1356 gezelter 1979 #line 161 "MDTreeParser.g"
1357 tim 770 currBondStamp->setMembers(ivec);
1358 gezelter 1979 #line 1359 "MDTreeParser.cpp"
1359 tim 770 break;
1360     }
1361     default:
1362     {
1363     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1364     }
1365     }
1366     }
1367     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1368     reportError(ex);
1369     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1370     _t = _t->getNextSibling();
1371     }
1372     _retTree = _t;
1373     }
1374    
1375     vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1376 gezelter 1979 #line 306 "MDTreeParser.g"
1377 tim 770 vector<int> ivec;
1378 gezelter 1979 #line 1379 "MDTreeParser.cpp"
1379 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1380 gezelter 1979 #line 306 "MDTreeParser.g"
1381 tim 770
1382     int ival;
1383    
1384 gezelter 1979 #line 1385 "MDTreeParser.cpp"
1385 tim 770
1386     try { // for error handling
1387     { // ( ... )+
1388 gezelter 1979 int _cnt98=0;
1389 tim 770 for (;;) {
1390     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1391     _t = ASTNULL;
1392 tim 814 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1393 tim 770 ival=intConst(_t);
1394     _t = _retTree;
1395 gezelter 1979 #line 310 "MDTreeParser.g"
1396 tim 770 ivec.push_back(ival);
1397 gezelter 1979 #line 1398 "MDTreeParser.cpp"
1398 tim 770 }
1399     else {
1400 gezelter 1979 if ( _cnt98>=1 ) { goto _loop98; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1401 tim 770 }
1402    
1403 gezelter 1979 _cnt98++;
1404 tim 770 }
1405 gezelter 1979 _loop98:;
1406 tim 770 } // ( ... )+
1407     }
1408     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1409     reportError(ex);
1410     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1411     _t = _t->getNextSibling();
1412     }
1413     _retTree = _t;
1414     return ivec;
1415     }
1416    
1417     void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1418 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1419 gezelter 1979 #line 174 "MDTreeParser.g"
1420 tim 770
1421     vector<int> ivec;
1422     BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1423    
1424 gezelter 1979 #line 1425 "MDTreeParser.cpp"
1425 tim 770
1426     try { // for error handling
1427     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1428     _t = ASTNULL;
1429     switch ( _t->getType()) {
1430     case ASSIGNEQUAL:
1431     {
1432     assignment(_t);
1433     _t = _retTree;
1434     break;
1435     }
1436     case MEMBERS:
1437     {
1438 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1439 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1440 tim 770 match(_t,MEMBERS);
1441     _t = _t->getFirstChild();
1442     ivec=inttuple(_t);
1443     _t = _retTree;
1444 gezelter 1782 _t = __t56;
1445 tim 770 _t = _t->getNextSibling();
1446 gezelter 1979 #line 180 "MDTreeParser.g"
1447 tim 770 currBendStamp->setMembers(ivec);
1448 gezelter 1979 #line 1449 "MDTreeParser.cpp"
1449 tim 770 break;
1450     }
1451     default:
1452     {
1453     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1454     }
1455     }
1456     }
1457     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1458     reportError(ex);
1459     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1460     _t = _t->getNextSibling();
1461     }
1462     _retTree = _t;
1463     }
1464    
1465     void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1466 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1467 gezelter 1979 #line 193 "MDTreeParser.g"
1468 tim 770
1469     vector<int> ivec;
1470     TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1471    
1472 gezelter 1979 #line 1473 "MDTreeParser.cpp"
1473 tim 770
1474     try { // for error handling
1475     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1476     _t = ASTNULL;
1477     switch ( _t->getType()) {
1478     case ASSIGNEQUAL:
1479     {
1480     assignment(_t);
1481     _t = _retTree;
1482     break;
1483     }
1484     case MEMBERS:
1485     {
1486 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t62 = _t;
1487 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1488 tim 770 match(_t,MEMBERS);
1489     _t = _t->getFirstChild();
1490     ivec=inttuple(_t);
1491     _t = _retTree;
1492 gezelter 1782 _t = __t62;
1493 tim 770 _t = _t->getNextSibling();
1494 gezelter 1979 #line 199 "MDTreeParser.g"
1495 tim 770 currTorsionStamp->setMembers(ivec);
1496 gezelter 1979 #line 1497 "MDTreeParser.cpp"
1497 tim 770 break;
1498     }
1499     default:
1500     {
1501     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1502     }
1503     }
1504     }
1505     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1506     reportError(ex);
1507     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1508     _t = _t->getNextSibling();
1509     }
1510     _retTree = _t;
1511     }
1512    
1513 cli2 1275 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1514 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1515 gezelter 1979 #line 212 "MDTreeParser.g"
1516 cli2 1275
1517     int icent;
1518 gezelter 1902 vector<int> ivec;
1519 cli2 1275 InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1520    
1521 gezelter 1979 #line 1522 "MDTreeParser.cpp"
1522 cli2 1275
1523     try { // for error handling
1524     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1525     _t = ASTNULL;
1526     switch ( _t->getType()) {
1527     case ASSIGNEQUAL:
1528     {
1529     assignment(_t);
1530     _t = _retTree;
1531     break;
1532     }
1533     case CENTER:
1534     {
1535 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1536 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1537 cli2 1275 match(_t,CENTER);
1538     _t = _t->getFirstChild();
1539     icent=intConst(_t);
1540     _t = _retTree;
1541 gezelter 1782 _t = __t68;
1542 cli2 1275 _t = _t->getNextSibling();
1543 gezelter 1979 #line 219 "MDTreeParser.g"
1544 cli2 1275 currInversionStamp->setCenter(icent);
1545 gezelter 1979 #line 1546 "MDTreeParser.cpp"
1546 cli2 1275 break;
1547     }
1548 gezelter 1902 case SATELLITES:
1549     {
1550     ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1551 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1552 gezelter 1902 match(_t,SATELLITES);
1553     _t = _t->getFirstChild();
1554     ivec=inttuple(_t);
1555     _t = _retTree;
1556     _t = __t69;
1557     _t = _t->getNextSibling();
1558 gezelter 1979 #line 220 "MDTreeParser.g"
1559 gezelter 1902 currInversionStamp->setSatellites(ivec);
1560 gezelter 1979 #line 1561 "MDTreeParser.cpp"
1561 gezelter 1902 break;
1562     }
1563 cli2 1275 default:
1564     {
1565     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1566     }
1567     }
1568     }
1569     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1570     reportError(ex);
1571     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1572     _t = _t->getNextSibling();
1573     }
1574     _retTree = _t;
1575     }
1576    
1577 tim 770 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1578 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1579 gezelter 1979 #line 237 "MDTreeParser.g"
1580 tim 770
1581     vector<int> ivec;
1582     RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1583    
1584 gezelter 1979 #line 1585 "MDTreeParser.cpp"
1585 tim 770
1586     try { // for error handling
1587     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1588     _t = ASTNULL;
1589     switch ( _t->getType()) {
1590     case ASSIGNEQUAL:
1591     {
1592     assignment(_t);
1593     _t = _retTree;
1594     break;
1595     }
1596     case MEMBERS:
1597     {
1598 gezelter 1902 ANTLR_USE_NAMESPACE(antlr)RefAST __t75 = _t;
1599 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1600 tim 770 match(_t,MEMBERS);
1601     _t = _t->getFirstChild();
1602     ivec=inttuple(_t);
1603     _t = _retTree;
1604 gezelter 1902 _t = __t75;
1605 tim 770 _t = _t->getNextSibling();
1606 gezelter 1979 #line 243 "MDTreeParser.g"
1607 tim 770 currRigidBodyStamp->setMembers(ivec);
1608 gezelter 1979 #line 1609 "MDTreeParser.cpp"
1609 tim 770 break;
1610     }
1611     default:
1612     {
1613     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1614     }
1615     }
1616     }
1617     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1618     reportError(ex);
1619     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1620     _t = _t->getNextSibling();
1621     }
1622     _retTree = _t;
1623     }
1624    
1625     void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1626 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1627 gezelter 1979 #line 256 "MDTreeParser.g"
1628 tim 770
1629     vector<int> ivec;
1630     CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1631    
1632 gezelter 1979 #line 1633 "MDTreeParser.cpp"
1633 tim 770
1634     try { // for error handling
1635     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1636     _t = ASTNULL;
1637     switch ( _t->getType()) {
1638     case ASSIGNEQUAL:
1639     {
1640     assignment(_t);
1641     _t = _retTree;
1642     break;
1643     }
1644     case MEMBERS:
1645     {
1646 gezelter 1902 ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1647 gezelter 1979 ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1648 tim 770 match(_t,MEMBERS);
1649     _t = _t->getFirstChild();
1650     ivec=inttuple(_t);
1651     _t = _retTree;
1652 gezelter 1902 _t = __t81;
1653 tim 770 _t = _t->getNextSibling();
1654 gezelter 1979 #line 262 "MDTreeParser.g"
1655 tim 770 currCutoffGroupStamp->setMembers(ivec);
1656 gezelter 1979 #line 1657 "MDTreeParser.cpp"
1657 tim 770 break;
1658     }
1659     default:
1660     {
1661     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1662     }
1663     }
1664     }
1665     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1666     reportError(ex);
1667     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1668     _t = _t->getNextSibling();
1669     }
1670     _retTree = _t;
1671     }
1672    
1673     void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1674 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1675 tim 770
1676     try { // for error handling
1677     assignment(_t);
1678     _t = _retTree;
1679     }
1680     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1681     reportError(ex);
1682     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1683     _t = _t->getNextSibling();
1684     }
1685     _retTree = _t;
1686     }
1687    
1688 gezelter 1979 void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1689     ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1690     #line 288 "MDTreeParser.g"
1691    
1692     vector<int> ivec;
1693     ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
1694    
1695     #line 1696 "MDTreeParser.cpp"
1696    
1697     try { // for error handling
1698     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1699     _t = ASTNULL;
1700     switch ( _t->getType()) {
1701     case ASSIGNEQUAL:
1702     {
1703     assignment(_t);
1704     _t = _retTree;
1705     break;
1706     }
1707     case MEMBERS:
1708     {
1709     ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1710     ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1711     match(_t,MEMBERS);
1712     _t = _t->getFirstChild();
1713     ivec=inttuple(_t);
1714     _t = _retTree;
1715     _t = __t92;
1716     _t = _t->getNextSibling();
1717     #line 294 "MDTreeParser.g"
1718     currConstraintStamp->setMembers(ivec);
1719     #line 1720 "MDTreeParser.cpp"
1720     break;
1721     }
1722     default:
1723     {
1724     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1725     }
1726     }
1727     }
1728     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1729     reportError(ex);
1730     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1731     _t = _t->getNextSibling();
1732     }
1733     _retTree = _t;
1734     }
1735    
1736 tim 770 void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1737     {
1738     }
1739     const char* MDTreeParser::tokenNames[] = {
1740     "<0>",
1741     "EOF",
1742     "<2>",
1743     "NULL_TREE_LOOKAHEAD",
1744     "\"component\"",
1745     "\"molecule\"",
1746     "\"zconstraint\"",
1747 cli2 1360 "\"restraint\"",
1748 tim 770 "\"atom\"",
1749     "\"bond\"",
1750     "\"bend\"",
1751     "\"torsion\"",
1752 cli2 1275 "\"inversion\"",
1753 tim 770 "\"rigidBody\"",
1754     "\"cutoffGroup\"",
1755 gezelter 1979 "\"constraint\"",
1756     "\"distance\"",
1757 tim 770 "\"fragment\"",
1758     "\"members\"",
1759 cli2 1275 "\"center\"",
1760 gezelter 1902 "\"satellites\"",
1761 tim 770 "\"position\"",
1762     "\"orientation\"",
1763 gezelter 1782 "\"flucQ\"",
1764     "\"RNEMD\"",
1765     "\"minimizer\"",
1766 tim 770 "ENDBLOCK",
1767     "ID",
1768     "ASSIGNEQUAL",
1769     "SEMICOLON",
1770     "StringLiteral",
1771     "LCURLY",
1772     "RCURLY",
1773     "LBRACKET",
1774     "RBRACKET",
1775     "LPAREN",
1776     "RPAREN",
1777     "COMMA",
1778 tim 814 "NUM_INT",
1779     "NUM_LONG",
1780     "NUM_FLOAT",
1781     "NUM_DOUBLE",
1782 tim 770 "DOT",
1783     "COLON",
1784     "QUESTIONMARK",
1785     "Whitespace",
1786     "Comment",
1787     "CPPComment",
1788     "a line directive",
1789     "LineDirective",
1790     "Space",
1791     "CharLiteral",
1792     "EndOfLine",
1793     "Escape",
1794 tim 814 "Vocabulary",
1795 tim 770 "Digit",
1796     "Decimal",
1797 tim 814 "HEX_DIGIT",
1798     "EXPONENT",
1799     "FLOAT_SUFFIX",
1800 tim 770 0
1801     };
1802    
1803 gezelter 1979 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 327155952UL, 0UL, 0UL, 0UL };
1804 gezelter 1782 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
1805     // ASSIGNEQUAL
1806 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1807 gezelter 1979 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 268631808UL, 0UL, 0UL, 0UL };
1808 cli2 1275 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1809 gezelter 1979 // "constraint" "fragment" ASSIGNEQUAL
1810 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1811    
1812    

Properties

Name Value
svn:keywords Author Id Revision Date