ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 2046
Committed: Tue Dec 2 22:11:04 2014 UTC (10 years, 4 months ago) by gezelter
File size: 60136 byte(s)
Log Message: 
Fixed some broken comments for use with Doxygen.
Made changes to allow topology-based force-field overrides in include files.
Fixed a calculation of box quadrupole moments for molecules with point dipoles.

File Contents

# User Rev Content
1 gezelter 2040 /* $ANTLR 2.7.7 (20141024): "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 2026 #line 70 "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 2026 #line 72 "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 2026 #line 101 "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 2026 #line 103 "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 2026 #line 75 "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 2026 #line 77 "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 2026 #line 80 "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 2026 #line 82 "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 gezelter 2026 #line 85 "MDTreeParser.g"
321 gezelter 1782 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 gezelter 2026 #line 87 "MDTreeParser.g"
344 gezelter 1782 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 gezelter 2026 #line 90 "MDTreeParser.g"
364 gezelter 1782 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 gezelter 2026 #line 92 "MDTreeParser.g"
387 gezelter 1782 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 gezelter 2026 #line 95 "MDTreeParser.g"
407 gezelter 1782 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 gezelter 2026 #line 97 "MDTreeParser.g"
430 gezelter 1782 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 gezelter 2026 std::vector<RealType> 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 tim 770 case ID:
480     {
481     str1 = _t;
482     match(_t,ID);
483     _t = _t->getNextSibling();
484 gezelter 2026 #line 58 "MDTreeParser.g"
485 tim 770 blockStack.top()->assign(id->getText(), str1->getText());
486 gezelter 2026 #line 487 "MDTreeParser.cpp"
487 tim 770 break;
488     }
489     case StringLiteral:
490     {
491     str2 = _t;
492     match(_t,StringLiteral);
493     _t = _t->getNextSibling();
494 gezelter 2026 #line 59 "MDTreeParser.g"
495 tim 770 std::string s = str2->getText();
496     s = s.substr(1, s.length()-2);
497     blockStack.top()->assign(id->getText(),s);
498    
499 gezelter 2026 #line 500 "MDTreeParser.cpp"
500 tim 770 break;
501     }
502 gezelter 2026 case LPAREN:
503     {
504     ANTLR_USE_NAMESPACE(antlr)RefAST __t8 = _t;
505     ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
506     match(_t,LPAREN);
507     _t = _t->getFirstChild();
508     dvec=doubleNumberTuple(_t);
509     _t = _retTree;
510     ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
511     match(_t,RPAREN);
512     _t = _t->getNextSibling();
513     _t = __t8;
514     _t = _t->getNextSibling();
515     #line 64 "MDTreeParser.g"
516    
517     blockStack.top()->assign(id->getText(), dvec);
518    
519     #line 520 "MDTreeParser.cpp"
520     break;
521     }
522 tim 770 default:
523     {
524     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
525     }
526     }
527     }
528     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
529     reportError(ex);
530     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
531     _t = _t->getNextSibling();
532     }
533     _retTree = _t;
534     }
535    
536     int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
537 gezelter 2046 #line 349 "MDTreeParser.g"
538 tim 770 int ival;
539 gezelter 2026 #line 540 "MDTreeParser.cpp"
540 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
541 tim 814 ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
542     ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
543 tim 770
544     try { // for error handling
545     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
546     _t = ASTNULL;
547     switch ( _t->getType()) {
548 tim 814 case NUM_INT:
549 tim 770 {
550 tim 814 i1 = _t;
551     match(_t,NUM_INT);
552 tim 770 _t = _t->getNextSibling();
553 gezelter 2046 #line 350 "MDTreeParser.g"
554 tim 814 ival = lexi_cast<int>(i1->getText());
555 gezelter 2026 #line 556 "MDTreeParser.cpp"
556 tim 770 break;
557     }
558 tim 814 case NUM_LONG:
559 tim 770 {
560 tim 814 i2 = _t;
561     match(_t,NUM_LONG);
562 tim 770 _t = _t->getNextSibling();
563 gezelter 2046 #line 351 "MDTreeParser.g"
564 tim 814 ival = lexi_cast<int>(i2->getText());
565 gezelter 2026 #line 566 "MDTreeParser.cpp"
566 tim 770 break;
567     }
568     default:
569     {
570     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
571     }
572     }
573     }
574     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
575     reportError(ex);
576     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
577     _t = _t->getNextSibling();
578     }
579     _retTree = _t;
580     return ival;
581     }
582    
583 tim 963 RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
584 gezelter 2046 #line 361 "MDTreeParser.g"
585 tim 963 RealType dval;
586 gezelter 2026 #line 587 "MDTreeParser.cpp"
587 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
588 tim 770 ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST;
589     ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST;
590    
591     try { // for error handling
592     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
593     _t = ASTNULL;
594     switch ( _t->getType()) {
595 tim 814 case NUM_FLOAT:
596 tim 770 {
597     d1 = _t;
598 tim 814 match(_t,NUM_FLOAT);
599 tim 770 _t = _t->getNextSibling();
600 gezelter 2046 #line 362 "MDTreeParser.g"
601 tim 963 dval = lexi_cast<RealType>(d1->getText());
602 gezelter 2026 #line 603 "MDTreeParser.cpp"
603 tim 770 break;
604     }
605 tim 814 case NUM_DOUBLE:
606 tim 770 {
607     d2 = _t;
608 tim 814 match(_t,NUM_DOUBLE);
609 tim 770 _t = _t->getNextSibling();
610 gezelter 2046 #line 363 "MDTreeParser.g"
611 tim 963 dval = lexi_cast<RealType>(d2->getText());
612 gezelter 2026 #line 613 "MDTreeParser.cpp"
613 tim 770 break;
614     }
615     default:
616     {
617     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
618     }
619     }
620     }
621     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
622     reportError(ex);
623     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
624     _t = _t->getNextSibling();
625     }
626     _retTree = _t;
627     return dval;
628     }
629    
630 gezelter 2026 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
631 gezelter 2046 #line 333 "MDTreeParser.g"
632 gezelter 2026 vector<RealType> dvec;
633     #line 634 "MDTreeParser.cpp"
634     ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
635 gezelter 2046 #line 333 "MDTreeParser.g"
636 gezelter 2026
637 gezelter 1782 RealType dval;
638    
639 gezelter 2026 #line 640 "MDTreeParser.cpp"
640    
641 gezelter 1782 try { // for error handling
642 gezelter 2026 { // ( ... )+
643 gezelter 2046 int _cnt122=0;
644 gezelter 2026 for (;;) {
645     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
646     _t = ASTNULL;
647     if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
648     dval=doubleNumber(_t);
649     _t = _retTree;
650 gezelter 2046 #line 337 "MDTreeParser.g"
651 gezelter 2026 dvec.push_back(dval);
652     #line 653 "MDTreeParser.cpp"
653     }
654     else {
655 gezelter 2046 if ( _cnt122>=1 ) { goto _loop122; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
656 gezelter 2026 }
657    
658 gezelter 2046 _cnt122++;
659 gezelter 1782 }
660 gezelter 2046 _loop122:;
661 gezelter 2026 } // ( ... )+
662 gezelter 1782 }
663     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
664     reportError(ex);
665     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
666     _t = _t->getNextSibling();
667     }
668     _retTree = _t;
669 gezelter 2026 return dvec;
670 gezelter 1782 }
671    
672 tim 770 void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
673 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
674 tim 770
675     try { // for error handling
676     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
677     _t = ASTNULL;
678     switch ( _t->getType()) {
679     case ASSIGNEQUAL:
680     {
681     assignment(_t);
682     _t = _retTree;
683     break;
684     }
685     case ATOM:
686     {
687     atomblock(_t);
688     _t = _retTree;
689     break;
690     }
691     case BOND:
692     {
693     bondblock(_t);
694     _t = _retTree;
695     break;
696     }
697     case BEND:
698     {
699     bendblock(_t);
700     _t = _retTree;
701     break;
702     }
703     case TORSION:
704     {
705     torsionblock(_t);
706     _t = _retTree;
707     break;
708     }
709 cli2 1275 case INVERSION:
710     {
711     inversionblock(_t);
712     _t = _retTree;
713     break;
714     }
715 tim 770 case RIGIDBODY:
716     {
717     rigidbodyblock(_t);
718     _t = _retTree;
719     break;
720     }
721     case CUTOFFGROUP:
722     {
723     cutoffgroupblock(_t);
724     _t = _retTree;
725     break;
726     }
727     case FRAGMENT:
728     {
729     fragmentblock(_t);
730     _t = _retTree;
731     break;
732     }
733 gezelter 1979 case CONSTRAINT:
734     {
735     constraintblock(_t);
736     _t = _retTree;
737     break;
738     }
739 tim 770 default:
740     {
741     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
742     }
743     }
744     }
745     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
746     reportError(ex);
747     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
748     _t = _t->getNextSibling();
749     }
750     _retTree = _t;
751     }
752    
753     void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
754 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
755 gezelter 2026 #line 118 "MDTreeParser.g"
756 tim 770
757     int index;
758    
759 gezelter 2026 #line 760 "MDTreeParser.cpp"
760 tim 770
761     try { // for error handling
762 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
763 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
764 tim 770 match(_t,ATOM);
765     _t = _t->getFirstChild();
766     index=intConst(_t);
767     _t = _retTree;
768 gezelter 2026 #line 122 "MDTreeParser.g"
769 tim 770 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
770 gezelter 2026 #line 771 "MDTreeParser.cpp"
771 tim 770 { // ( ... )*
772     for (;;) {
773     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
774     _t = ASTNULL;
775 gezelter 2046 if ((_tokenSet_2.member(_t->getType()))) {
776 tim 770 atomstatement(_t);
777     _t = _retTree;
778     }
779     else {
780 gezelter 1782 goto _loop41;
781 tim 770 }
782    
783     }
784 gezelter 1782 _loop41:;
785 tim 770 } // ( ... )*
786 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
787 tim 770 match(_t,ENDBLOCK);
788     _t = _t->getNextSibling();
789 gezelter 1782 _t = __t39;
790 tim 770 _t = _t->getNextSibling();
791 gezelter 2026 #line 124 "MDTreeParser.g"
792 tim 770
793     blockStack.top()->validate();
794     blockStack.pop();
795     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
796     currMoleculeStamp->addAtomStamp(currAtomStamp);
797    
798 gezelter 2026 #line 799 "MDTreeParser.cpp"
799 tim 770 }
800     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
801     reportError(ex);
802     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
803     _t = _t->getNextSibling();
804     }
805     _retTree = _t;
806     }
807    
808     void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
809 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
810 tim 770
811     try { // for error handling
812 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
813 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
814 tim 770 match(_t,BOND);
815     _t = _t->getFirstChild();
816 gezelter 2046 #line 147 "MDTreeParser.g"
817 tim 770 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
818 gezelter 2026 #line 819 "MDTreeParser.cpp"
819 tim 770 { // ( ... )*
820     for (;;) {
821     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
822     _t = ASTNULL;
823 gezelter 2046 if ((_tokenSet_3.member(_t->getType()))) {
824 tim 770 bondstatement(_t);
825     _t = _retTree;
826     }
827     else {
828 gezelter 2046 goto _loop49;
829 tim 770 }
830    
831     }
832 gezelter 2046 _loop49:;
833 tim 770 } // ( ... )*
834 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
835 tim 770 match(_t,ENDBLOCK);
836     _t = _t->getNextSibling();
837 gezelter 2046 _t = __t47;
838 tim 770 _t = _t->getNextSibling();
839 gezelter 2046 #line 149 "MDTreeParser.g"
840 tim 770
841 gezelter 2046 blockStack.top()->validate();
842 tim 770 blockStack.pop();
843     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
844     currMoleculeStamp->addBondStamp(currBondStamp);
845    
846 gezelter 2046 #line 847 "MDTreeParser.cpp"
847 tim 770 }
848     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
849     reportError(ex);
850     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
851     _t = _t->getNextSibling();
852     }
853     _retTree = _t;
854     }
855    
856     void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
857 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
858 tim 770
859     try { // for error handling
860 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
861 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
862 tim 770 match(_t,BEND);
863     _t = _t->getFirstChild();
864 gezelter 2046 #line 174 "MDTreeParser.g"
865 tim 770 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
866 gezelter 2046 #line 867 "MDTreeParser.cpp"
867 tim 770 { // ( ... )*
868     for (;;) {
869     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
870     _t = ASTNULL;
871 gezelter 2046 if ((_tokenSet_4.member(_t->getType()))) {
872 tim 770 bendstatement(_t);
873     _t = _retTree;
874     }
875     else {
876 gezelter 2046 goto _loop61;
877 tim 770 }
878    
879     }
880 gezelter 2046 _loop61:;
881 tim 770 } // ( ... )*
882 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
883 tim 770 match(_t,ENDBLOCK);
884     _t = _t->getNextSibling();
885 gezelter 2046 _t = __t59;
886 tim 770 _t = _t->getNextSibling();
887 gezelter 2046 #line 176 "MDTreeParser.g"
888 tim 770
889     blockStack.top()->validate();
890     blockStack.pop();
891     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
892     currMoleculeStamp->addBendStamp(currBendStamp);
893    
894 gezelter 2046 #line 895 "MDTreeParser.cpp"
895 tim 770 }
896     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
897     reportError(ex);
898     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
899     _t = _t->getNextSibling();
900     }
901     _retTree = _t;
902     }
903    
904     void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
905 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
906 tim 770
907     try { // for error handling
908 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t72 = _t;
909 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
910 tim 770 match(_t,TORSION);
911     _t = _t->getFirstChild();
912 gezelter 2046 #line 201 "MDTreeParser.g"
913 tim 770 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
914 gezelter 2046 #line 915 "MDTreeParser.cpp"
915 tim 770 { // ( ... )*
916     for (;;) {
917     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
918     _t = ASTNULL;
919 gezelter 2046 if ((_tokenSet_5.member(_t->getType()))) {
920 tim 770 torsionstatement(_t);
921     _t = _retTree;
922     }
923     else {
924 gezelter 2046 goto _loop74;
925 tim 770 }
926    
927     }
928 gezelter 2046 _loop74:;
929 tim 770 } // ( ... )*
930 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
931 tim 770 match(_t,ENDBLOCK);
932     _t = _t->getNextSibling();
933 gezelter 2046 _t = __t72;
934 tim 770 _t = _t->getNextSibling();
935 gezelter 2046 #line 203 "MDTreeParser.g"
936 tim 770
937     blockStack.top()->validate();
938     blockStack.pop();
939     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
940     currMoleculeStamp->addTorsionStamp(currTorsionStamp);
941    
942 gezelter 2046 #line 943 "MDTreeParser.cpp"
943 tim 770 }
944     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
945     reportError(ex);
946     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
947     _t = _t->getNextSibling();
948     }
949     _retTree = _t;
950     }
951    
952 cli2 1275 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
953 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
954 cli2 1275
955     try { // for error handling
956 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t86 = _t;
957 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
958 cli2 1275 match(_t,INVERSION);
959     _t = _t->getFirstChild();
960 gezelter 2046 #line 230 "MDTreeParser.g"
961 cli2 1275 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
962 gezelter 2046 #line 963 "MDTreeParser.cpp"
963 cli2 1275 { // ( ... )*
964     for (;;) {
965     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
966     _t = ASTNULL;
967 gezelter 2046 if ((_tokenSet_6.member(_t->getType()))) {
968 cli2 1275 inversionstatement(_t);
969     _t = _retTree;
970     }
971     else {
972 gezelter 2046 goto _loop88;
973 cli2 1275 }
974    
975     }
976 gezelter 2046 _loop88:;
977 cli2 1275 } // ( ... )*
978 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
979 cli2 1275 match(_t,ENDBLOCK);
980     _t = _t->getNextSibling();
981 gezelter 2046 _t = __t86;
982 cli2 1275 _t = _t->getNextSibling();
983 gezelter 2046 #line 232 "MDTreeParser.g"
984 cli2 1275
985     blockStack.top()->validate();
986     blockStack.pop();
987     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
988     currMoleculeStamp->addInversionStamp(currInversionStamp);
989    
990 gezelter 2046 #line 991 "MDTreeParser.cpp"
991 cli2 1275 }
992     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
993     reportError(ex);
994     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
995     _t = _t->getNextSibling();
996     }
997     _retTree = _t;
998     }
999    
1000 tim 770 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1001 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1002 gezelter 2046 #line 258 "MDTreeParser.g"
1003 tim 770
1004     int index;
1005    
1006 gezelter 2046 #line 1007 "MDTreeParser.cpp"
1007 tim 770
1008     try { // for error handling
1009 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t98 = _t;
1010 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1011 tim 770 match(_t,RIGIDBODY);
1012     _t = _t->getFirstChild();
1013     index=intConst(_t);
1014     _t = _retTree;
1015 gezelter 2046 #line 262 "MDTreeParser.g"
1016 tim 770 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
1017 gezelter 2046 #line 1018 "MDTreeParser.cpp"
1018 tim 770 { // ( ... )*
1019     for (;;) {
1020     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1021     _t = ASTNULL;
1022     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1023     rigidbodystatement(_t);
1024     _t = _retTree;
1025     }
1026     else {
1027 gezelter 2046 goto _loop100;
1028 tim 770 }
1029    
1030     }
1031 gezelter 2046 _loop100:;
1032 tim 770 } // ( ... )*
1033 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1034 tim 770 match(_t,ENDBLOCK);
1035     _t = _t->getNextSibling();
1036 gezelter 2046 _t = __t98;
1037 tim 770 _t = _t->getNextSibling();
1038 gezelter 2046 #line 264 "MDTreeParser.g"
1039 tim 770
1040     blockStack.top()->validate();
1041     blockStack.pop();
1042     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1043     currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
1044    
1045 gezelter 2046 #line 1046 "MDTreeParser.cpp"
1046 tim 770 }
1047     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1048     reportError(ex);
1049     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1050     _t = _t->getNextSibling();
1051     }
1052     _retTree = _t;
1053     }
1054    
1055     void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1056 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1057 tim 770
1058     try { // for error handling
1059 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t104 = _t;
1060 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1061 tim 770 match(_t,CUTOFFGROUP);
1062     _t = _t->getFirstChild();
1063 gezelter 2046 #line 281 "MDTreeParser.g"
1064 tim 770 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
1065 gezelter 2046 #line 1066 "MDTreeParser.cpp"
1066 tim 770 { // ( ... )*
1067     for (;;) {
1068     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1069     _t = ASTNULL;
1070     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1071     cutoffgroupstatement(_t);
1072     _t = _retTree;
1073     }
1074     else {
1075 gezelter 2046 goto _loop106;
1076 tim 770 }
1077    
1078     }
1079 gezelter 2046 _loop106:;
1080 tim 770 } // ( ... )*
1081 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1082 tim 770 match(_t,ENDBLOCK);
1083     _t = _t->getNextSibling();
1084 gezelter 2046 _t = __t104;
1085 tim 770 _t = _t->getNextSibling();
1086 gezelter 2046 #line 283 "MDTreeParser.g"
1087 tim 770
1088     blockStack.top()->validate();
1089     blockStack.pop();
1090     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1091     currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
1092    
1093 gezelter 2046 #line 1094 "MDTreeParser.cpp"
1094 tim 770 }
1095     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1096     reportError(ex);
1097     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1098     _t = _t->getNextSibling();
1099     }
1100     _retTree = _t;
1101     }
1102    
1103     void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1104 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1105 gezelter 2046 #line 300 "MDTreeParser.g"
1106 tim 770 int ival;
1107 gezelter 2046 #line 1108 "MDTreeParser.cpp"
1108 tim 770
1109     try { // for error handling
1110 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t110 = _t;
1111 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1112 tim 770 match(_t,FRAGMENT);
1113     _t = _t->getFirstChild();
1114     ival=intConst(_t);
1115     _t = _retTree;
1116 gezelter 2046 #line 301 "MDTreeParser.g"
1117 tim 770 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
1118 gezelter 2046 #line 1119 "MDTreeParser.cpp"
1119 tim 770 { // ( ... )*
1120     for (;;) {
1121     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1122     _t = ASTNULL;
1123     if ((_t->getType() == ASSIGNEQUAL)) {
1124     fragmentstatement(_t);
1125     _t = _retTree;
1126     }
1127     else {
1128 gezelter 2046 goto _loop112;
1129 tim 770 }
1130    
1131     }
1132 gezelter 2046 _loop112:;
1133 tim 770 } // ( ... )*
1134 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1135 tim 770 match(_t,ENDBLOCK);
1136     _t = _t->getNextSibling();
1137 gezelter 2046 _t = __t110;
1138 tim 770 _t = _t->getNextSibling();
1139 gezelter 2046 #line 303 "MDTreeParser.g"
1140 tim 770
1141     blockStack.top()->validate();
1142     blockStack.pop();
1143     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1144     currMoleculeStamp->addFragmentStamp(currFragmentStamp);
1145    
1146 gezelter 2046 #line 1147 "MDTreeParser.cpp"
1147 tim 770 }
1148     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1149     reportError(ex);
1150     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1151     _t = _t->getNextSibling();
1152     }
1153     _retTree = _t;
1154     }
1155    
1156 gezelter 1979 void MDTreeParser::constraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1157     ANTLR_USE_NAMESPACE(antlr)RefAST constraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1158    
1159     try { // for error handling
1160 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t115 = _t;
1161 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST_in = _t;
1162 gezelter 1979 match(_t,CONSTRAINT);
1163     _t = _t->getFirstChild();
1164 gezelter 2046 #line 314 "MDTreeParser.g"
1165 gezelter 1979 ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);
1166 gezelter 2046 #line 1167 "MDTreeParser.cpp"
1167 gezelter 1979 { // ( ... )*
1168     for (;;) {
1169     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1170     _t = ASTNULL;
1171     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
1172     constraintstatement(_t);
1173     _t = _retTree;
1174     }
1175     else {
1176 gezelter 2046 goto _loop117;
1177 gezelter 1979 }
1178    
1179     }
1180 gezelter 2046 _loop117:;
1181 gezelter 1979 } // ( ... )*
1182 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST_in = _t;
1183 gezelter 1979 match(_t,ENDBLOCK);
1184     _t = _t->getNextSibling();
1185 gezelter 2046 _t = __t115;
1186 gezelter 1979 _t = _t->getNextSibling();
1187 gezelter 2046 #line 316 "MDTreeParser.g"
1188 gezelter 1979
1189     blockStack.pop();
1190     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
1191     currMoleculeStamp->addConstraintStamp(currConstraintStamp);
1192    
1193 gezelter 2046 #line 1194 "MDTreeParser.cpp"
1194 gezelter 1979 }
1195     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1196     reportError(ex);
1197     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1198     _t = _t->getNextSibling();
1199     }
1200     _retTree = _t;
1201     }
1202    
1203 tim 770 void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1204 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1205 gezelter 2026 #line 132 "MDTreeParser.g"
1206 tim 770
1207 tim 963 vector<RealType> dvec;
1208 gezelter 2046 RealType rval;
1209 tim 770 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
1210    
1211    
1212 gezelter 2046 #line 1213 "MDTreeParser.cpp"
1213 tim 770
1214     try { // for error handling
1215     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1216     _t = ASTNULL;
1217     switch ( _t->getType()) {
1218     case ASSIGNEQUAL:
1219     {
1220     assignment(_t);
1221     _t = _retTree;
1222     break;
1223     }
1224     case POSITION:
1225     {
1226 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1227 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST_in = _t;
1228 tim 770 match(_t,POSITION);
1229     _t = _t->getFirstChild();
1230 tim 814 dvec=doubleNumberTuple(_t);
1231 tim 770 _t = _retTree;
1232 gezelter 1782 _t = __t43;
1233 tim 770 _t = _t->getNextSibling();
1234 gezelter 2046 #line 140 "MDTreeParser.g"
1235 tim 770 currAtomStamp->setPosition(dvec);
1236 gezelter 2046 #line 1237 "MDTreeParser.cpp"
1237 tim 770 break;
1238     }
1239     case ORIENTATION:
1240     {
1241 gezelter 1782 ANTLR_USE_NAMESPACE(antlr)RefAST __t44 = _t;
1242 gezelter 2026 ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST_in = _t;
1243 tim 770 match(_t,ORIENTATION);
1244     _t = _t->getFirstChild();
1245 tim 814 dvec=doubleNumberTuple(_t);
1246 tim 770 _t = _retTree;
1247 gezelter 1782 _t = __t44;
1248 tim 770 _t = _t->getNextSibling();
1249 gezelter 2046 #line 141 "MDTreeParser.g"
1250 tim 770 currAtomStamp->setOrientation(dvec);
1251 gezelter 2046 #line 1252 "MDTreeParser.cpp"
1252 tim 770 break;
1253     }
1254 gezelter 2046 case CHARGE:
1255     {
1256     ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1257     ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST_in = _t;
1258     match(_t,CHARGE);
1259     _t = _t->getFirstChild();
1260     rval=doubleNumber(_t);
1261     _t = _retTree;
1262     _t = __t45;
1263     _t = _t->getNextSibling();
1264     #line 142 "MDTreeParser.g"
1265     currAtomStamp->overrideCharge(rval);
1266     #line 1267 "MDTreeParser.cpp"
1267     break;
1268     }
1269 tim 770 default:
1270     {
1271     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1272     }
1273     }
1274     }
1275     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1276     reportError(ex);
1277     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1278     _t = _t->getNextSibling();
1279     }
1280     _retTree = _t;
1281     }
1282    
1283 gezelter 2046 RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1284     #line 355 "MDTreeParser.g"
1285     RealType dval;
1286     #line 1287 "MDTreeParser.cpp"
1287     ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1288     ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1289     ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1290    
1291     try { // for error handling
1292     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1293     _t = ASTNULL;
1294     switch ( _t->getType()) {
1295     case NUM_INT:
1296     case NUM_LONG:
1297     {
1298     ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1299     intConst(_t);
1300     _t = _retTree;
1301     #line 356 "MDTreeParser.g"
1302     dval = lexi_cast<RealType>(ic->getText());
1303     #line 1304 "MDTreeParser.cpp"
1304     break;
1305     }
1306     case NUM_FLOAT:
1307     case NUM_DOUBLE:
1308     {
1309     fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1310     floatConst(_t);
1311     _t = _retTree;
1312     #line 357 "MDTreeParser.g"
1313     dval = lexi_cast<RealType>(fc->getText());
1314     #line 1315 "MDTreeParser.cpp"
1315     break;
1316     }
1317     default:
1318     {
1319     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1320     }
1321     }
1322     }
1323     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1324     reportError(ex);
1325     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1326     _t = _t->getNextSibling();
1327     }
1328     _retTree = _t;
1329     return dval;
1330     }
1331    
1332 tim 770 void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1333 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1334 gezelter 2046 #line 157 "MDTreeParser.g"
1335 tim 770
1336     vector<int> ivec;
1337 gezelter 2046 RealType rval;
1338     vector<RealType> dvec;
1339 tim 770 BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1340    
1341 gezelter 2046 #line 1342 "MDTreeParser.cpp"
1342 tim 770
1343     try { // for error handling
1344     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1345     _t = ASTNULL;
1346     switch ( _t->getType()) {
1347     case ASSIGNEQUAL:
1348     {
1349     assignment(_t);
1350     _t = _retTree;
1351     break;
1352     }
1353     case MEMBERS:
1354     {
1355 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1356     ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST_in = _t;
1357 tim 770 match(_t,MEMBERS);
1358     _t = _t->getFirstChild();
1359     ivec=inttuple(_t);
1360     _t = _retTree;
1361 gezelter 2046 _t = __t51;
1362 tim 770 _t = _t->getNextSibling();
1363 gezelter 2046 #line 165 "MDTreeParser.g"
1364 tim 770 currBondStamp->setMembers(ivec);
1365 gezelter 2046 #line 1366 "MDTreeParser.cpp"
1366 tim 770 break;
1367     }
1368 gezelter 2046 case FIXED:
1369     {
1370     ANTLR_USE_NAMESPACE(antlr)RefAST __t52 = _t;
1371     ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST_in = _t;
1372     match(_t,FIXED);
1373     _t = _t->getFirstChild();
1374     rval=doubleNumber(_t);
1375     _t = _retTree;
1376     _t = __t52;
1377     _t = _t->getNextSibling();
1378     #line 166 "MDTreeParser.g"
1379     currBondStamp->overrideType("Fixed", rval);
1380     #line 1381 "MDTreeParser.cpp"
1381     break;
1382     }
1383     case HARMONIC:
1384     {
1385     ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
1386     ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST_in = _t;
1387     match(_t,HARMONIC);
1388     _t = _t->getFirstChild();
1389     dvec=doubleNumberTuple(_t);
1390     _t = _retTree;
1391     _t = __t53;
1392     _t = _t->getNextSibling();
1393     #line 167 "MDTreeParser.g"
1394     currBondStamp->overrideType("Harmonic", dvec);
1395     #line 1396 "MDTreeParser.cpp"
1396     break;
1397     }
1398     case CUBIC:
1399     {
1400     ANTLR_USE_NAMESPACE(antlr)RefAST __t54 = _t;
1401     ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST_in = _t;
1402     match(_t,CUBIC);
1403     _t = _t->getFirstChild();
1404     dvec=doubleNumberTuple(_t);
1405     _t = _retTree;
1406     _t = __t54;
1407     _t = _t->getNextSibling();
1408     #line 168 "MDTreeParser.g"
1409     currBondStamp->overrideType("Cubic", dvec);
1410     #line 1411 "MDTreeParser.cpp"
1411     break;
1412     }
1413     case QUARTIC:
1414     {
1415     ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1416     ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST_in = _t;
1417     match(_t,QUARTIC);
1418     _t = _t->getFirstChild();
1419     dvec=doubleNumberTuple(_t);
1420     _t = _retTree;
1421     _t = __t55;
1422     _t = _t->getNextSibling();
1423     #line 169 "MDTreeParser.g"
1424     currBondStamp->overrideType("Quartic", dvec);
1425     #line 1426 "MDTreeParser.cpp"
1426     break;
1427     }
1428     case POLYNOMIAL:
1429     {
1430     ANTLR_USE_NAMESPACE(antlr)RefAST __t56 = _t;
1431     ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST_in = _t;
1432     match(_t,POLYNOMIAL);
1433     _t = _t->getFirstChild();
1434     dvec=doubleNumberTuple(_t);
1435     _t = _retTree;
1436     _t = __t56;
1437     _t = _t->getNextSibling();
1438     #line 170 "MDTreeParser.g"
1439     currBondStamp->overrideType("Polynomial", dvec);
1440     #line 1441 "MDTreeParser.cpp"
1441     break;
1442     }
1443     case MORSE:
1444     {
1445     ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1446     ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST_in = _t;
1447     match(_t,MORSE);
1448     _t = _t->getFirstChild();
1449     dvec=doubleNumberTuple(_t);
1450     _t = _retTree;
1451     _t = __t57;
1452     _t = _t->getNextSibling();
1453     #line 171 "MDTreeParser.g"
1454     currBondStamp->overrideType("Morse", dvec);
1455     #line 1456 "MDTreeParser.cpp"
1456     break;
1457     }
1458 tim 770 default:
1459     {
1460     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1461     }
1462     }
1463     }
1464     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1465     reportError(ex);
1466     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1467     _t = _t->getNextSibling();
1468     }
1469     _retTree = _t;
1470     }
1471    
1472     vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1473 gezelter 2046 #line 341 "MDTreeParser.g"
1474 tim 770 vector<int> ivec;
1475 gezelter 2046 #line 1476 "MDTreeParser.cpp"
1476 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1477 gezelter 2046 #line 341 "MDTreeParser.g"
1478 tim 770
1479     int ival;
1480    
1481 gezelter 2046 #line 1482 "MDTreeParser.cpp"
1482 tim 770
1483     try { // for error handling
1484     { // ( ... )+
1485 gezelter 2046 int _cnt125=0;
1486 tim 770 for (;;) {
1487     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1488     _t = ASTNULL;
1489 tim 814 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1490 tim 770 ival=intConst(_t);
1491     _t = _retTree;
1492 gezelter 2046 #line 345 "MDTreeParser.g"
1493 tim 770 ivec.push_back(ival);
1494 gezelter 2046 #line 1495 "MDTreeParser.cpp"
1495 tim 770 }
1496     else {
1497 gezelter 2046 if ( _cnt125>=1 ) { goto _loop125; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1498 tim 770 }
1499    
1500 gezelter 2046 _cnt125++;
1501 tim 770 }
1502 gezelter 2046 _loop125:;
1503 tim 770 } // ( ... )+
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     return ivec;
1512     }
1513    
1514     void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1515 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1516 gezelter 2046 #line 184 "MDTreeParser.g"
1517 tim 770
1518     vector<int> ivec;
1519 gezelter 2046 vector<RealType> dvec;
1520 tim 770 BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1521    
1522 gezelter 2046 #line 1523 "MDTreeParser.cpp"
1523 tim 770
1524     try { // for error handling
1525     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1526     _t = ASTNULL;
1527     switch ( _t->getType()) {
1528     case ASSIGNEQUAL:
1529     {
1530     assignment(_t);
1531     _t = _retTree;
1532     break;
1533     }
1534     case MEMBERS:
1535     {
1536 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1537     ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST_in = _t;
1538 tim 770 match(_t,MEMBERS);
1539     _t = _t->getFirstChild();
1540     ivec=inttuple(_t);
1541     _t = _retTree;
1542 gezelter 2046 _t = __t63;
1543 tim 770 _t = _t->getNextSibling();
1544 gezelter 2046 #line 191 "MDTreeParser.g"
1545 tim 770 currBendStamp->setMembers(ivec);
1546 gezelter 2046 #line 1547 "MDTreeParser.cpp"
1547 tim 770 break;
1548     }
1549 gezelter 2046 case HARMONIC:
1550     {
1551     ANTLR_USE_NAMESPACE(antlr)RefAST __t64 = _t;
1552     ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST_in = _t;
1553     match(_t,HARMONIC);
1554     _t = _t->getFirstChild();
1555     dvec=doubleNumberTuple(_t);
1556     _t = _retTree;
1557     _t = __t64;
1558     _t = _t->getNextSibling();
1559     #line 192 "MDTreeParser.g"
1560     currBendStamp->overrideType("Harmonic", dvec);
1561     #line 1562 "MDTreeParser.cpp"
1562     break;
1563     }
1564     case GHOSTBEND:
1565     {
1566     ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
1567     ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST_in = _t;
1568     match(_t,GHOSTBEND);
1569     _t = _t->getFirstChild();
1570     dvec=doubleNumberTuple(_t);
1571     _t = _retTree;
1572     _t = __t65;
1573     _t = _t->getNextSibling();
1574     #line 193 "MDTreeParser.g"
1575     currBendStamp->overrideType("GhostBend", dvec);
1576     #line 1577 "MDTreeParser.cpp"
1577     break;
1578     }
1579     case UREYBRADLEY:
1580     {
1581     ANTLR_USE_NAMESPACE(antlr)RefAST __t66 = _t;
1582     ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST_in = _t;
1583     match(_t,UREYBRADLEY);
1584     _t = _t->getFirstChild();
1585     dvec=doubleNumberTuple(_t);
1586     _t = _retTree;
1587     _t = __t66;
1588     _t = _t->getNextSibling();
1589     #line 194 "MDTreeParser.g"
1590     currBendStamp->overrideType("UreyBradley", dvec);
1591     #line 1592 "MDTreeParser.cpp"
1592     break;
1593     }
1594     case CUBIC:
1595     {
1596     ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1597     ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST_in = _t;
1598     match(_t,CUBIC);
1599     _t = _t->getFirstChild();
1600     dvec=doubleNumberTuple(_t);
1601     _t = _retTree;
1602     _t = __t67;
1603     _t = _t->getNextSibling();
1604     #line 195 "MDTreeParser.g"
1605     currBendStamp->overrideType("Cubic", dvec);
1606     #line 1607 "MDTreeParser.cpp"
1607     break;
1608     }
1609     case QUARTIC:
1610     {
1611     ANTLR_USE_NAMESPACE(antlr)RefAST __t68 = _t;
1612     ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST_in = _t;
1613     match(_t,QUARTIC);
1614     _t = _t->getFirstChild();
1615     dvec=doubleNumberTuple(_t);
1616     _t = _retTree;
1617     _t = __t68;
1618     _t = _t->getNextSibling();
1619     #line 196 "MDTreeParser.g"
1620     currBendStamp->overrideType("Quartic", dvec);
1621     #line 1622 "MDTreeParser.cpp"
1622     break;
1623     }
1624     case POLYNOMIAL:
1625     {
1626     ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
1627     ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST_in = _t;
1628     match(_t,POLYNOMIAL);
1629     _t = _t->getFirstChild();
1630     dvec=doubleNumberTuple(_t);
1631     _t = _retTree;
1632     _t = __t69;
1633     _t = _t->getNextSibling();
1634     #line 197 "MDTreeParser.g"
1635     currBendStamp->overrideType("Polynomial", dvec);
1636     #line 1637 "MDTreeParser.cpp"
1637     break;
1638     }
1639     case COSINE:
1640     {
1641     ANTLR_USE_NAMESPACE(antlr)RefAST __t70 = _t;
1642     ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST_in = _t;
1643     match(_t,COSINE);
1644     _t = _t->getFirstChild();
1645     dvec=doubleNumberTuple(_t);
1646     _t = _retTree;
1647     _t = __t70;
1648     _t = _t->getNextSibling();
1649     #line 198 "MDTreeParser.g"
1650     currBendStamp->overrideType("Cosine", dvec);
1651     #line 1652 "MDTreeParser.cpp"
1652     break;
1653     }
1654 tim 770 default:
1655     {
1656     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1657     }
1658     }
1659     }
1660     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1661     reportError(ex);
1662     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1663     _t = _t->getNextSibling();
1664     }
1665     _retTree = _t;
1666     }
1667    
1668     void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1669 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1670 gezelter 2046 #line 211 "MDTreeParser.g"
1671 tim 770
1672     vector<int> ivec;
1673 gezelter 2046 vector<RealType> dvec;
1674 tim 770 TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1675    
1676 gezelter 2046 #line 1677 "MDTreeParser.cpp"
1677 tim 770
1678     try { // for error handling
1679     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1680     _t = ASTNULL;
1681     switch ( _t->getType()) {
1682     case ASSIGNEQUAL:
1683     {
1684     assignment(_t);
1685     _t = _retTree;
1686     break;
1687     }
1688     case MEMBERS:
1689     {
1690 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t76 = _t;
1691     ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST_in = _t;
1692 tim 770 match(_t,MEMBERS);
1693     _t = _t->getFirstChild();
1694     ivec=inttuple(_t);
1695     _t = _retTree;
1696 gezelter 2046 _t = __t76;
1697 tim 770 _t = _t->getNextSibling();
1698 gezelter 2046 #line 218 "MDTreeParser.g"
1699 tim 770 currTorsionStamp->setMembers(ivec);
1700 gezelter 2046 #line 1701 "MDTreeParser.cpp"
1701 tim 770 break;
1702     }
1703 gezelter 2046 case GHOSTTORSION:
1704     {
1705     ANTLR_USE_NAMESPACE(antlr)RefAST __t77 = _t;
1706     ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST_in = _t;
1707     match(_t,GHOSTTORSION);
1708     _t = _t->getFirstChild();
1709     dvec=doubleNumberTuple(_t);
1710     _t = _retTree;
1711     _t = __t77;
1712     _t = _t->getNextSibling();
1713     #line 219 "MDTreeParser.g"
1714     currTorsionStamp->overrideType("GhostTorsion", dvec);
1715     #line 1716 "MDTreeParser.cpp"
1716     break;
1717     }
1718     case CUBIC:
1719     {
1720     ANTLR_USE_NAMESPACE(antlr)RefAST __t78 = _t;
1721     ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST_in = _t;
1722     match(_t,CUBIC);
1723     _t = _t->getFirstChild();
1724     dvec=doubleNumberTuple(_t);
1725     _t = _retTree;
1726     _t = __t78;
1727     _t = _t->getNextSibling();
1728     #line 220 "MDTreeParser.g"
1729     currTorsionStamp->overrideType("Cubic", dvec);
1730     #line 1731 "MDTreeParser.cpp"
1731     break;
1732     }
1733     case QUARTIC:
1734     {
1735     ANTLR_USE_NAMESPACE(antlr)RefAST __t79 = _t;
1736     ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST_in = _t;
1737     match(_t,QUARTIC);
1738     _t = _t->getFirstChild();
1739     dvec=doubleNumberTuple(_t);
1740     _t = _retTree;
1741     _t = __t79;
1742     _t = _t->getNextSibling();
1743     #line 221 "MDTreeParser.g"
1744     currTorsionStamp->overrideType("Quartic", dvec);
1745     #line 1746 "MDTreeParser.cpp"
1746     break;
1747     }
1748     case POLYNOMIAL:
1749     {
1750     ANTLR_USE_NAMESPACE(antlr)RefAST __t80 = _t;
1751     ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST_in = _t;
1752     match(_t,POLYNOMIAL);
1753     _t = _t->getFirstChild();
1754     dvec=doubleNumberTuple(_t);
1755     _t = _retTree;
1756     _t = __t80;
1757     _t = _t->getNextSibling();
1758     #line 222 "MDTreeParser.g"
1759     currTorsionStamp->overrideType("Polynomial", dvec);
1760     #line 1761 "MDTreeParser.cpp"
1761     break;
1762     }
1763     case CHARMM:
1764     {
1765     ANTLR_USE_NAMESPACE(antlr)RefAST __t81 = _t;
1766     ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST_in = _t;
1767     match(_t,CHARMM);
1768     _t = _t->getFirstChild();
1769     dvec=doubleNumberTuple(_t);
1770     _t = _retTree;
1771     _t = __t81;
1772     _t = _t->getNextSibling();
1773     #line 223 "MDTreeParser.g"
1774     currTorsionStamp->overrideType("Charmm", dvec);
1775     #line 1776 "MDTreeParser.cpp"
1776     break;
1777     }
1778     case OPLS:
1779     {
1780     ANTLR_USE_NAMESPACE(antlr)RefAST __t82 = _t;
1781     ANTLR_USE_NAMESPACE(antlr)RefAST tmp60_AST_in = _t;
1782     match(_t,OPLS);
1783     _t = _t->getFirstChild();
1784     dvec=doubleNumberTuple(_t);
1785     _t = _retTree;
1786     _t = __t82;
1787     _t = _t->getNextSibling();
1788     #line 224 "MDTreeParser.g"
1789     currTorsionStamp->overrideType("Opls", dvec);
1790     #line 1791 "MDTreeParser.cpp"
1791     break;
1792     }
1793     case TRAPPE:
1794     {
1795     ANTLR_USE_NAMESPACE(antlr)RefAST __t83 = _t;
1796     ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST_in = _t;
1797     match(_t,TRAPPE);
1798     _t = _t->getFirstChild();
1799     dvec=doubleNumberTuple(_t);
1800     _t = _retTree;
1801     _t = __t83;
1802     _t = _t->getNextSibling();
1803     #line 225 "MDTreeParser.g"
1804     currTorsionStamp->overrideType("Trappe", dvec);
1805     #line 1806 "MDTreeParser.cpp"
1806     break;
1807     }
1808     case HARMONIC:
1809     {
1810     ANTLR_USE_NAMESPACE(antlr)RefAST __t84 = _t;
1811     ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST_in = _t;
1812     match(_t,HARMONIC);
1813     _t = _t->getFirstChild();
1814     dvec=doubleNumberTuple(_t);
1815     _t = _retTree;
1816     _t = __t84;
1817     _t = _t->getNextSibling();
1818     #line 226 "MDTreeParser.g"
1819     currTorsionStamp->overrideType("Harmonic", dvec);
1820     #line 1821 "MDTreeParser.cpp"
1821     break;
1822     }
1823 tim 770 default:
1824     {
1825     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1826     }
1827     }
1828     }
1829     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1830     reportError(ex);
1831     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1832     _t = _t->getNextSibling();
1833     }
1834     _retTree = _t;
1835     }
1836    
1837 cli2 1275 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1838 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1839 gezelter 2046 #line 240 "MDTreeParser.g"
1840 cli2 1275
1841     int icent;
1842 gezelter 1902 vector<int> ivec;
1843 gezelter 2046 vector<RealType> dvec;
1844 cli2 1275 InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1845    
1846 gezelter 2046 #line 1847 "MDTreeParser.cpp"
1847 cli2 1275
1848     try { // for error handling
1849     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1850     _t = ASTNULL;
1851     switch ( _t->getType()) {
1852     case ASSIGNEQUAL:
1853     {
1854     assignment(_t);
1855     _t = _retTree;
1856     break;
1857     }
1858     case CENTER:
1859     {
1860 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t90 = _t;
1861     ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST_in = _t;
1862 cli2 1275 match(_t,CENTER);
1863     _t = _t->getFirstChild();
1864     icent=intConst(_t);
1865     _t = _retTree;
1866 gezelter 2046 _t = __t90;
1867 cli2 1275 _t = _t->getNextSibling();
1868 gezelter 2046 #line 248 "MDTreeParser.g"
1869 cli2 1275 currInversionStamp->setCenter(icent);
1870 gezelter 2046 #line 1871 "MDTreeParser.cpp"
1871 cli2 1275 break;
1872     }
1873 gezelter 1902 case SATELLITES:
1874     {
1875 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t91 = _t;
1876     ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST_in = _t;
1877 gezelter 1902 match(_t,SATELLITES);
1878     _t = _t->getFirstChild();
1879     ivec=inttuple(_t);
1880     _t = _retTree;
1881 gezelter 2046 _t = __t91;
1882 gezelter 1902 _t = _t->getNextSibling();
1883 gezelter 2046 #line 249 "MDTreeParser.g"
1884 gezelter 1902 currInversionStamp->setSatellites(ivec);
1885 gezelter 2046 #line 1886 "MDTreeParser.cpp"
1886 gezelter 1902 break;
1887     }
1888 gezelter 2046 case AMBERIMPROPER:
1889     {
1890     ANTLR_USE_NAMESPACE(antlr)RefAST __t92 = _t;
1891     ANTLR_USE_NAMESPACE(antlr)RefAST tmp65_AST_in = _t;
1892     match(_t,AMBERIMPROPER);
1893     _t = _t->getFirstChild();
1894     dvec=doubleNumberTuple(_t);
1895     _t = _retTree;
1896     _t = __t92;
1897     _t = _t->getNextSibling();
1898     #line 250 "MDTreeParser.g"
1899     currInversionStamp->overrideType("AmberImproper", dvec);
1900     #line 1901 "MDTreeParser.cpp"
1901     break;
1902     }
1903     case IMPROPERCOSINE:
1904     {
1905     ANTLR_USE_NAMESPACE(antlr)RefAST __t93 = _t;
1906     ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST_in = _t;
1907     match(_t,IMPROPERCOSINE);
1908     _t = _t->getFirstChild();
1909     dvec=doubleNumberTuple(_t);
1910     _t = _retTree;
1911     _t = __t93;
1912     _t = _t->getNextSibling();
1913     #line 251 "MDTreeParser.g"
1914     currInversionStamp->overrideType("ImproperCosine", dvec);
1915     #line 1916 "MDTreeParser.cpp"
1916     break;
1917     }
1918     case HARMONIC:
1919     {
1920     ANTLR_USE_NAMESPACE(antlr)RefAST __t94 = _t;
1921     ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST_in = _t;
1922     match(_t,HARMONIC);
1923     _t = _t->getFirstChild();
1924     dvec=doubleNumberTuple(_t);
1925     _t = _retTree;
1926     _t = __t94;
1927     _t = _t->getNextSibling();
1928     #line 252 "MDTreeParser.g"
1929     currInversionStamp->overrideType("Harmonic", dvec);
1930     #line 1931 "MDTreeParser.cpp"
1931     break;
1932     }
1933     case CENTRALATOMHEIGHT:
1934     {
1935     ANTLR_USE_NAMESPACE(antlr)RefAST __t95 = _t;
1936     ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST_in = _t;
1937     match(_t,CENTRALATOMHEIGHT);
1938     _t = _t->getFirstChild();
1939     dvec=doubleNumberTuple(_t);
1940     _t = _retTree;
1941     _t = __t95;
1942     _t = _t->getNextSibling();
1943     #line 253 "MDTreeParser.g"
1944     currInversionStamp->overrideType("CentralAtomHeight", dvec);
1945     #line 1946 "MDTreeParser.cpp"
1946     break;
1947     }
1948     case DREIDING:
1949     {
1950     ANTLR_USE_NAMESPACE(antlr)RefAST __t96 = _t;
1951     ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST_in = _t;
1952     match(_t,DREIDING);
1953     _t = _t->getFirstChild();
1954     dvec=doubleNumberTuple(_t);
1955     _t = _retTree;
1956     _t = __t96;
1957     _t = _t->getNextSibling();
1958     #line 254 "MDTreeParser.g"
1959     currInversionStamp->overrideType("Dreiding", dvec);
1960     #line 1961 "MDTreeParser.cpp"
1961     break;
1962     }
1963 cli2 1275 default:
1964     {
1965     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1966     }
1967     }
1968     }
1969     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1970     reportError(ex);
1971     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1972     _t = _t->getNextSibling();
1973     }
1974     _retTree = _t;
1975     }
1976    
1977 tim 770 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1978 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1979 gezelter 2046 #line 272 "MDTreeParser.g"
1980 tim 770
1981     vector<int> ivec;
1982     RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1983    
1984 gezelter 2046 #line 1985 "MDTreeParser.cpp"
1985 tim 770
1986     try { // for error handling
1987     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1988     _t = ASTNULL;
1989     switch ( _t->getType()) {
1990     case ASSIGNEQUAL:
1991     {
1992     assignment(_t);
1993     _t = _retTree;
1994     break;
1995     }
1996     case MEMBERS:
1997     {
1998 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t102 = _t;
1999     ANTLR_USE_NAMESPACE(antlr)RefAST tmp70_AST_in = _t;
2000 tim 770 match(_t,MEMBERS);
2001     _t = _t->getFirstChild();
2002     ivec=inttuple(_t);
2003     _t = _retTree;
2004 gezelter 2046 _t = __t102;
2005 tim 770 _t = _t->getNextSibling();
2006 gezelter 2046 #line 278 "MDTreeParser.g"
2007 tim 770 currRigidBodyStamp->setMembers(ivec);
2008 gezelter 2046 #line 2009 "MDTreeParser.cpp"
2009 tim 770 break;
2010     }
2011     default:
2012     {
2013     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2014     }
2015     }
2016     }
2017     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2018     reportError(ex);
2019     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2020     _t = _t->getNextSibling();
2021     }
2022     _retTree = _t;
2023     }
2024    
2025     void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2026 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2027 gezelter 2046 #line 291 "MDTreeParser.g"
2028 tim 770
2029     vector<int> ivec;
2030     CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
2031    
2032 gezelter 2046 #line 2033 "MDTreeParser.cpp"
2033 tim 770
2034     try { // for error handling
2035     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2036     _t = ASTNULL;
2037     switch ( _t->getType()) {
2038     case ASSIGNEQUAL:
2039     {
2040     assignment(_t);
2041     _t = _retTree;
2042     break;
2043     }
2044     case MEMBERS:
2045     {
2046 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t108 = _t;
2047     ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST_in = _t;
2048 tim 770 match(_t,MEMBERS);
2049     _t = _t->getFirstChild();
2050     ivec=inttuple(_t);
2051     _t = _retTree;
2052 gezelter 2046 _t = __t108;
2053 tim 770 _t = _t->getNextSibling();
2054 gezelter 2046 #line 297 "MDTreeParser.g"
2055 tim 770 currCutoffGroupStamp->setMembers(ivec);
2056 gezelter 2046 #line 2057 "MDTreeParser.cpp"
2057 tim 770 break;
2058     }
2059     default:
2060     {
2061     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2062     }
2063     }
2064     }
2065     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2066     reportError(ex);
2067     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2068     _t = _t->getNextSibling();
2069     }
2070     _retTree = _t;
2071     }
2072    
2073     void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2074 gezelter 1277 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2075 tim 770
2076     try { // for error handling
2077     assignment(_t);
2078     _t = _retTree;
2079     }
2080     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2081     reportError(ex);
2082     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2083     _t = _t->getNextSibling();
2084     }
2085     _retTree = _t;
2086     }
2087    
2088 gezelter 1979 void MDTreeParser::constraintstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
2089     ANTLR_USE_NAMESPACE(antlr)RefAST constraintstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
2090 gezelter 2046 #line 323 "MDTreeParser.g"
2091 gezelter 1979
2092     vector<int> ivec;
2093     ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
2094    
2095 gezelter 2046 #line 2096 "MDTreeParser.cpp"
2096 gezelter 1979
2097     try { // for error handling
2098     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
2099     _t = ASTNULL;
2100     switch ( _t->getType()) {
2101     case ASSIGNEQUAL:
2102     {
2103     assignment(_t);
2104     _t = _retTree;
2105     break;
2106     }
2107     case MEMBERS:
2108     {
2109 gezelter 2046 ANTLR_USE_NAMESPACE(antlr)RefAST __t119 = _t;
2110     ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST_in = _t;
2111 gezelter 1979 match(_t,MEMBERS);
2112     _t = _t->getFirstChild();
2113     ivec=inttuple(_t);
2114     _t = _retTree;
2115 gezelter 2046 _t = __t119;
2116 gezelter 1979 _t = _t->getNextSibling();
2117 gezelter 2046 #line 329 "MDTreeParser.g"
2118 gezelter 1979 currConstraintStamp->setMembers(ivec);
2119 gezelter 2046 #line 2120 "MDTreeParser.cpp"
2120 gezelter 1979 break;
2121     }
2122     default:
2123     {
2124     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
2125     }
2126     }
2127     }
2128     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
2129     reportError(ex);
2130     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
2131     _t = _t->getNextSibling();
2132     }
2133     _retTree = _t;
2134     }
2135    
2136 tim 770 void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
2137     {
2138     }
2139     const char* MDTreeParser::tokenNames[] = {
2140     "<0>",
2141     "EOF",
2142     "<2>",
2143     "NULL_TREE_LOOKAHEAD",
2144     "\"component\"",
2145     "\"molecule\"",
2146     "\"zconstraint\"",
2147 cli2 1360 "\"restraint\"",
2148 tim 770 "\"atom\"",
2149     "\"bond\"",
2150     "\"bend\"",
2151     "\"torsion\"",
2152 cli2 1275 "\"inversion\"",
2153 tim 770 "\"rigidBody\"",
2154     "\"cutoffGroup\"",
2155 gezelter 1979 "\"constraint\"",
2156     "\"distance\"",
2157 tim 770 "\"fragment\"",
2158     "\"members\"",
2159 cli2 1275 "\"center\"",
2160 gezelter 1902 "\"satellites\"",
2161 tim 770 "\"position\"",
2162     "\"orientation\"",
2163 gezelter 1782 "\"flucQ\"",
2164     "\"RNEMD\"",
2165     "\"minimizer\"",
2166 gezelter 2046 "\"Fixed\"",
2167     "\"Harmonic\"",
2168     "\"Cubic\"",
2169     "\"Quartic\"",
2170     "\"Polynomial\"",
2171     "\"Morse\"",
2172     "\"GhostBend\"",
2173     "\"UreyBradley\"",
2174     "\"Cosine\"",
2175     "\"GhostTorsion\"",
2176     "\"Charmm\"",
2177     "\"Opls\"",
2178     "\"Trappe\"",
2179     "\"AmberImproper\"",
2180     "\"ImproperCosine\"",
2181     "\"CentralAtomHeight\"",
2182     "\"Dreiding\"",
2183     "\"charge\"",
2184 tim 770 "ENDBLOCK",
2185     "ID",
2186     "ASSIGNEQUAL",
2187     "SEMICOLON",
2188     "StringLiteral",
2189     "LCURLY",
2190     "RCURLY",
2191     "LBRACKET",
2192     "RBRACKET",
2193     "LPAREN",
2194     "RPAREN",
2195     "COMMA",
2196 tim 814 "NUM_INT",
2197     "NUM_LONG",
2198     "NUM_FLOAT",
2199     "NUM_DOUBLE",
2200 tim 770 "DOT",
2201     "COLON",
2202     "QUESTIONMARK",
2203     "Whitespace",
2204     "Comment",
2205     "CPPComment",
2206     "a line directive",
2207     "LineDirective",
2208     "Space",
2209     "CharLiteral",
2210     "EndOfLine",
2211     "Escape",
2212 tim 814 "Vocabulary",
2213 tim 770 "Digit",
2214     "Decimal",
2215 tim 814 "HEX_DIGIT",
2216     "EXPONENT",
2217     "FLOAT_SUFFIX",
2218 tim 770 0
2219     };
2220    
2221 gezelter 2046 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 58720496UL, 16384UL, 0UL, 0UL };
2222 gezelter 1782 // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" "minimizer"
2223     // ASSIGNEQUAL
2224 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
2225 gezelter 2046 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 196352UL, 16384UL, 0UL, 0UL };
2226 cli2 1275 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
2227 gezelter 1979 // "constraint" "fragment" ASSIGNEQUAL
2228 tim 770 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
2229 gezelter 2046 const unsigned long MDTreeParser::_tokenSet_2_data_[] = { 6291456UL, 18432UL, 0UL, 0UL };
2230     // "position" "orientation" "charge" ASSIGNEQUAL
2231     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_2(_tokenSet_2_data_,4);
2232     const unsigned long MDTreeParser::_tokenSet_3_data_[] = { 4228120576UL, 16384UL, 0UL, 0UL };
2233     // "members" "Fixed" "Harmonic" "Cubic" "Quartic" "Polynomial" "Morse"
2234     // ASSIGNEQUAL
2235     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_3(_tokenSet_3_data_,4);
2236     const unsigned long MDTreeParser::_tokenSet_4_data_[] = { 2013528064UL, 16391UL, 0UL, 0UL };
2237     // "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostBend" "UreyBradley"
2238     // "Cosine" ASSIGNEQUAL
2239     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_4(_tokenSet_4_data_,4);
2240     const unsigned long MDTreeParser::_tokenSet_5_data_[] = { 2013528064UL, 16504UL, 0UL, 0UL };
2241     // "members" "Harmonic" "Cubic" "Quartic" "Polynomial" "GhostTorsion" "Charmm"
2242     // "Opls" "Trappe" ASSIGNEQUAL
2243     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_5(_tokenSet_5_data_,4);
2244     const unsigned long MDTreeParser::_tokenSet_6_data_[] = { 135790592UL, 18304UL, 0UL, 0UL };
2245     // "center" "satellites" "Harmonic" "AmberImproper" "ImproperCosine" "CentralAtomHeight"
2246     // "Dreiding" ASSIGNEQUAL
2247     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_6(_tokenSet_6_data_,4);
2248 tim 770
2249    

Properties

Name Value
svn:keywords Author Id Revision Date