ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 1277
Committed: Mon Jul 14 12:35:58 2008 UTC (16 years, 9 months ago) by gezelter
File size: 38467 byte(s)
Log Message: 
Changes for implementing Amber force field:  Added Inversions and
worked on BaseAtomTypes so that they'd function with the fortran side.

File Contents

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