ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 2026
Committed: Wed Oct 22 12:23:59 2014 UTC (10 years, 6 months ago) by gezelter
File size: 47836 byte(s)
Log Message: 
Starting to add support for UniformGradient. 
Changed Vector3d input type to a more general std::vector<RealType> input.  This change alters RNEMD and UniformField inputs.

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date