ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDTreeParser.cpp
Revision: 3430
Committed: Fri Jul 4 20:54:29 2008 UTC (16 years, 10 months ago) by cli2
File size: 37470 byte(s)
Log Message: 
Changes required for Inversions and Base Atom types.  This will
break OOPSE badly for a few days or so...

File Contents

# User Rev Content
1 cli2 3430 /* $ANTLR 2.7.4: "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2 tim 2469 #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     ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
17    
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     ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
48    
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     ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
93     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     ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
118    
119     try { // for error handling
120 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
121 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
122     match(_t,COMPONENT);
123     _t = _t->getFirstChild();
124 tim 2513 #line 62 "MDTreeParser.g"
125 tim 2469 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 2513 goto _loop11;
137 tim 2469 }
138    
139     }
140 tim 2513 _loop11:;
141 tim 2469 } // ( ... )*
142     ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
143     match(_t,ENDBLOCK);
144     _t = _t->getNextSibling();
145 tim 2513 _t = __t9;
146 tim 2469 _t = _t->getNextSibling();
147 tim 2513 #line 64 "MDTreeParser.g"
148 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
161    
162     try { // for error handling
163 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t;
164 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
165     match(_t,MOLECULE);
166     _t = _t->getFirstChild();
167 tim 2513 #line 72 "MDTreeParser.g"
168 tim 2469 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 2513 goto _loop19;
180 tim 2469 }
181    
182     }
183 tim 2513 _loop19:;
184 tim 2469 } // ( ... )*
185     ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
186     match(_t,ENDBLOCK);
187     _t = _t->getNextSibling();
188 tim 2513 _t = __t17;
189 tim 2469 _t = _t->getNextSibling();
190 tim 2513 #line 74 "MDTreeParser.g"
191 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
204    
205     try { // for error handling
206 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
207 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
208     match(_t,ZCONSTRAINT);
209     _t = _t->getFirstChild();
210 tim 2513 #line 67 "MDTreeParser.g"
211 tim 2469 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 2513 goto _loop15;
223 tim 2469 }
224    
225     }
226 tim 2513 _loop15:;
227 tim 2469 } // ( ... )*
228     ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
229     match(_t,ENDBLOCK);
230     _t = _t->getNextSibling();
231 tim 2513 _t = __t13;
232 tim 2469 _t = _t->getNextSibling();
233 tim 2513 #line 69 "MDTreeParser.g"
234 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
249     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 2513 #line 47 "MDTreeParser.g"
252 tim 2469
253 tim 2513 int ival;
254 tim 2759 RealType dval;
255 tim 2513
256     #line 257 "MDTreeParser.cpp"
257    
258 tim 2469 try { // for error handling
259     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
260     _t = ASTNULL;
261     switch ( _t->getType()) {
262 tim 2513 case NUM_INT:
263     case NUM_LONG:
264 tim 2469 {
265 tim 2513 ival=intConst(_t);
266 tim 2469 _t = _retTree;
267 tim 2513 #line 52 "MDTreeParser.g"
268     blockStack.top()->assign(id->getText(), ival);
269     #line 270 "MDTreeParser.cpp"
270 tim 2469 break;
271     }
272 tim 2513 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 2469 case ID:
283     {
284     str1 = _t;
285     match(_t,ID);
286     _t = _t->getNextSibling();
287 tim 2513 #line 54 "MDTreeParser.g"
288 tim 2469 blockStack.top()->assign(id->getText(), str1->getText());
289 tim 2513 #line 290 "MDTreeParser.cpp"
290 tim 2469 break;
291     }
292     case StringLiteral:
293     {
294     str2 = _t;
295     match(_t,StringLiteral);
296     _t = _t->getNextSibling();
297 tim 2513 #line 55 "MDTreeParser.g"
298 tim 2469 std::string s = str2->getText();
299     s = s.substr(1, s.length()-2);
300     blockStack.top()->assign(id->getText(),s);
301    
302 tim 2513 #line 303 "MDTreeParser.cpp"
303 tim 2469 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 3430 #line 262 "MDTreeParser.g"
321 tim 2469 int ival;
322 tim 2513 #line 323 "MDTreeParser.cpp"
323 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
324 tim 2513 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 2469
327     try { // for error handling
328     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
329     _t = ASTNULL;
330     switch ( _t->getType()) {
331 tim 2513 case NUM_INT:
332 tim 2469 {
333 tim 2513 i1 = _t;
334     match(_t,NUM_INT);
335 tim 2469 _t = _t->getNextSibling();
336 cli2 3430 #line 263 "MDTreeParser.g"
337 tim 2513 ival = lexi_cast<int>(i1->getText());
338     #line 339 "MDTreeParser.cpp"
339 tim 2469 break;
340     }
341 tim 2513 case NUM_LONG:
342 tim 2469 {
343 tim 2513 i2 = _t;
344     match(_t,NUM_LONG);
345 tim 2469 _t = _t->getNextSibling();
346 cli2 3430 #line 264 "MDTreeParser.g"
347 tim 2513 ival = lexi_cast<int>(i2->getText());
348     #line 349 "MDTreeParser.cpp"
349 tim 2469 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 2759 RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 cli2 3430 #line 276 "MDTreeParser.g"
368 tim 2759 RealType dval;
369 tim 2513 #line 370 "MDTreeParser.cpp"
370 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
371     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 2513 case NUM_FLOAT:
379 tim 2469 {
380     d1 = _t;
381 tim 2513 match(_t,NUM_FLOAT);
382 tim 2469 _t = _t->getNextSibling();
383 cli2 3430 #line 277 "MDTreeParser.g"
384 tim 2759 dval = lexi_cast<RealType>(d1->getText());
385 tim 2513 #line 386 "MDTreeParser.cpp"
386 tim 2469 break;
387     }
388 tim 2513 case NUM_DOUBLE:
389 tim 2469 {
390     d2 = _t;
391 tim 2513 match(_t,NUM_DOUBLE);
392 tim 2469 _t = _t->getNextSibling();
393 cli2 3430 #line 278 "MDTreeParser.g"
394 tim 2759 dval = lexi_cast<RealType>(d2->getText());
395 tim 2513 #line 396 "MDTreeParser.cpp"
396 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
415    
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 3430 case INVERSION:
451     {
452     inversionblock(_t);
453     _t = _retTree;
454     break;
455     }
456 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
490 cli2 3430 #line 88 "MDTreeParser.g"
491 tim 2469
492     int index;
493    
494 cli2 3430 #line 495 "MDTreeParser.cpp"
495 tim 2469
496     try { // for error handling
497 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
498     ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
499 tim 2469 match(_t,ATOM);
500     _t = _t->getFirstChild();
501     index=intConst(_t);
502     _t = _retTree;
503 cli2 3430 #line 92 "MDTreeParser.g"
504 tim 2469 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
505 cli2 3430 #line 506 "MDTreeParser.cpp"
506 tim 2469 { // ( ... )*
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 2513 goto _loop24;
516 tim 2469 }
517    
518     }
519 tim 2513 _loop24:;
520 tim 2469 } // ( ... )*
521 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
522 tim 2469 match(_t,ENDBLOCK);
523     _t = _t->getNextSibling();
524 tim 2513 _t = __t22;
525 tim 2469 _t = _t->getNextSibling();
526 cli2 3430 #line 94 "MDTreeParser.g"
527 tim 2469
528     blockStack.top()->validate();
529     blockStack.pop();
530     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
531     currMoleculeStamp->addAtomStamp(currAtomStamp);
532    
533 cli2 3430 #line 534 "MDTreeParser.cpp"
534 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
545    
546     try { // for error handling
547 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
548     ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
549 tim 2469 match(_t,BOND);
550     _t = _t->getFirstChild();
551 cli2 3430 #line 114 "MDTreeParser.g"
552 tim 2469 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
553 cli2 3430 #line 554 "MDTreeParser.cpp"
554 tim 2469 { // ( ... )*
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 2513 goto _loop31;
564 tim 2469 }
565    
566     }
567 tim 2513 _loop31:;
568 tim 2469 } // ( ... )*
569 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
570 tim 2469 match(_t,ENDBLOCK);
571     _t = _t->getNextSibling();
572 tim 2513 _t = __t29;
573 tim 2469 _t = _t->getNextSibling();
574 cli2 3430 #line 116 "MDTreeParser.g"
575 tim 2469
576     blockStack.pop();
577     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
578     currMoleculeStamp->addBondStamp(currBondStamp);
579    
580 cli2 3430 #line 581 "MDTreeParser.cpp"
581 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
592    
593     try { // for error handling
594 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
595     ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
596 tim 2469 match(_t,BEND);
597     _t = _t->getFirstChild();
598 cli2 3430 #line 132 "MDTreeParser.g"
599 tim 2469 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
600 cli2 3430 #line 601 "MDTreeParser.cpp"
601 tim 2469 { // ( ... )*
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 2513 goto _loop37;
611 tim 2469 }
612    
613     }
614 tim 2513 _loop37:;
615 tim 2469 } // ( ... )*
616 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
617 tim 2469 match(_t,ENDBLOCK);
618     _t = _t->getNextSibling();
619 tim 2513 _t = __t35;
620 tim 2469 _t = _t->getNextSibling();
621 cli2 3430 #line 134 "MDTreeParser.g"
622 tim 2469
623     blockStack.top()->validate();
624     blockStack.pop();
625     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
626     currMoleculeStamp->addBendStamp(currBendStamp);
627    
628 cli2 3430 #line 629 "MDTreeParser.cpp"
629 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
640    
641     try { // for error handling
642 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
643     ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
644 tim 2469 match(_t,TORSION);
645     _t = _t->getFirstChild();
646 cli2 3430 #line 151 "MDTreeParser.g"
647 tim 2469 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
648 cli2 3430 #line 649 "MDTreeParser.cpp"
649 tim 2469 { // ( ... )*
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 2513 goto _loop43;
659 tim 2469 }
660    
661     }
662 tim 2513 _loop43:;
663 tim 2469 } // ( ... )*
664 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
665 tim 2469 match(_t,ENDBLOCK);
666     _t = _t->getNextSibling();
667 tim 2513 _t = __t41;
668 tim 2469 _t = _t->getNextSibling();
669 cli2 3430 #line 153 "MDTreeParser.g"
670 tim 2469
671     blockStack.top()->validate();
672     blockStack.pop();
673     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
674     currMoleculeStamp->addTorsionStamp(currTorsionStamp);
675    
676 cli2 3430 #line 677 "MDTreeParser.cpp"
677 tim 2469 }
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 3430 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
687     ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
688    
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 2469 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
735     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
736 cli2 3430 #line 189 "MDTreeParser.g"
737 tim 2469
738     int index;
739    
740 cli2 3430 #line 741 "MDTreeParser.cpp"
741 tim 2469
742     try { // for error handling
743 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
744     ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
745 tim 2469 match(_t,RIGIDBODY);
746     _t = _t->getFirstChild();
747     index=intConst(_t);
748     _t = _retTree;
749 cli2 3430 #line 193 "MDTreeParser.g"
750 tim 2469 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
751 cli2 3430 #line 752 "MDTreeParser.cpp"
752 tim 2469 { // ( ... )*
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 3430 goto _loop55;
762 tim 2469 }
763    
764     }
765 cli2 3430 _loop55:;
766 tim 2469 } // ( ... )*
767 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
768 tim 2469 match(_t,ENDBLOCK);
769     _t = _t->getNextSibling();
770 cli2 3430 _t = __t53;
771 tim 2469 _t = _t->getNextSibling();
772 cli2 3430 #line 195 "MDTreeParser.g"
773 tim 2469
774     blockStack.top()->validate();
775     blockStack.pop();
776     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
777     currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
778    
779 cli2 3430 #line 780 "MDTreeParser.cpp"
780 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
791    
792     try { // for error handling
793 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
794     ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
795 tim 2469 match(_t,CUTOFFGROUP);
796     _t = _t->getFirstChild();
797 cli2 3430 #line 212 "MDTreeParser.g"
798 tim 2469 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
799 cli2 3430 #line 800 "MDTreeParser.cpp"
800 tim 2469 { // ( ... )*
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 3430 goto _loop61;
810 tim 2469 }
811    
812     }
813 cli2 3430 _loop61:;
814 tim 2469 } // ( ... )*
815 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
816 tim 2469 match(_t,ENDBLOCK);
817     _t = _t->getNextSibling();
818 cli2 3430 _t = __t59;
819 tim 2469 _t = _t->getNextSibling();
820 cli2 3430 #line 214 "MDTreeParser.g"
821 tim 2469
822     blockStack.top()->validate();
823     blockStack.pop();
824     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
825     currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
826    
827 cli2 3430 #line 828 "MDTreeParser.cpp"
828 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
839 cli2 3430 #line 231 "MDTreeParser.g"
840 tim 2469 int ival;
841 cli2 3430 #line 842 "MDTreeParser.cpp"
842 tim 2469
843     try { // for error handling
844 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST __t65 = _t;
845     ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
846 tim 2469 match(_t,FRAGMENT);
847     _t = _t->getFirstChild();
848     ival=intConst(_t);
849     _t = _retTree;
850 cli2 3430 #line 232 "MDTreeParser.g"
851 tim 2469 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
852 cli2 3430 #line 853 "MDTreeParser.cpp"
853 tim 2469 { // ( ... )*
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 3430 goto _loop67;
863 tim 2469 }
864    
865     }
866 cli2 3430 _loop67:;
867 tim 2469 } // ( ... )*
868 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
869 tim 2469 match(_t,ENDBLOCK);
870     _t = _t->getNextSibling();
871 cli2 3430 _t = __t65;
872 tim 2469 _t = _t->getNextSibling();
873 cli2 3430 #line 234 "MDTreeParser.g"
874 tim 2469
875     blockStack.top()->validate();
876     blockStack.pop();
877     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
878     currMoleculeStamp->addFragmentStamp(currFragmentStamp);
879    
880 cli2 3430 #line 881 "MDTreeParser.cpp"
881 tim 2469 }
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     ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
892 cli2 3430 #line 102 "MDTreeParser.g"
893 tim 2469
894 tim 2759 vector<RealType> dvec;
895 tim 2469 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
896    
897    
898 cli2 3430 #line 899 "MDTreeParser.cpp"
899 tim 2469
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 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
913 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
914 tim 2469 match(_t,POSITION);
915     _t = _t->getFirstChild();
916 tim 2513 dvec=doubleNumberTuple(_t);
917 tim 2469 _t = _retTree;
918 tim 2513 _t = __t26;
919 tim 2469 _t = _t->getNextSibling();
920 cli2 3430 #line 109 "MDTreeParser.g"
921 tim 2469 currAtomStamp->setPosition(dvec);
922 cli2 3430 #line 923 "MDTreeParser.cpp"
923 tim 2469 break;
924     }
925     case ORIENTATION:
926     {
927 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
928 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
929 tim 2469 match(_t,ORIENTATION);
930     _t = _t->getFirstChild();
931 tim 2513 dvec=doubleNumberTuple(_t);
932 tim 2469 _t = _retTree;
933 tim 2513 _t = __t27;
934 tim 2469 _t = _t->getNextSibling();
935 cli2 3430 #line 110 "MDTreeParser.g"
936 tim 2469 currAtomStamp->setOrientation(dvec);
937 cli2 3430 #line 938 "MDTreeParser.cpp"
938 tim 2469 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 2759 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
955 cli2 3430 #line 247 "MDTreeParser.g"
956 tim 2759 vector<RealType> dvec;
957 cli2 3430 #line 958 "MDTreeParser.cpp"
958 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
959 cli2 3430 #line 247 "MDTreeParser.g"
960 tim 2469
961 tim 2759 RealType dval;
962 tim 2469
963 cli2 3430 #line 964 "MDTreeParser.cpp"
964 tim 2469
965     try { // for error handling
966     { // ( ... )+
967 cli2 3430 int _cnt71=0;
968 tim 2469 for (;;) {
969     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
970     _t = ASTNULL;
971 tim 2513 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
972     dval=doubleNumber(_t);
973 tim 2469 _t = _retTree;
974 cli2 3430 #line 251 "MDTreeParser.g"
975 tim 2469 dvec.push_back(dval);
976 cli2 3430 #line 977 "MDTreeParser.cpp"
977 tim 2469 }
978     else {
979 cli2 3430 if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
980 tim 2469 }
981    
982 cli2 3430 _cnt71++;
983 tim 2469 }
984 cli2 3430 _loop71:;
985 tim 2469 } // ( ... )+
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     ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
998 cli2 3430 #line 123 "MDTreeParser.g"
999 tim 2469
1000     vector<int> ivec;
1001     BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1002    
1003 cli2 3430 #line 1004 "MDTreeParser.cpp"
1004 tim 2469
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 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
1018 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1019 tim 2469 match(_t,MEMBERS);
1020     _t = _t->getFirstChild();
1021     ivec=inttuple(_t);
1022     _t = _retTree;
1023 tim 2513 _t = __t33;
1024 tim 2469 _t = _t->getNextSibling();
1025 cli2 3430 #line 129 "MDTreeParser.g"
1026 tim 2469 currBondStamp->setMembers(ivec);
1027 cli2 3430 #line 1028 "MDTreeParser.cpp"
1028 tim 2469 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 3430 #line 254 "MDTreeParser.g"
1046 tim 2469 vector<int> ivec;
1047 cli2 3430 #line 1048 "MDTreeParser.cpp"
1048 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1049 cli2 3430 #line 254 "MDTreeParser.g"
1050 tim 2469
1051     int ival;
1052    
1053 cli2 3430 #line 1054 "MDTreeParser.cpp"
1054 tim 2469
1055     try { // for error handling
1056     { // ( ... )+
1057 cli2 3430 int _cnt74=0;
1058 tim 2469 for (;;) {
1059     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1060     _t = ASTNULL;
1061 tim 2513 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1062 tim 2469 ival=intConst(_t);
1063     _t = _retTree;
1064 cli2 3430 #line 258 "MDTreeParser.g"
1065 tim 2469 ivec.push_back(ival);
1066 cli2 3430 #line 1067 "MDTreeParser.cpp"
1067 tim 2469 }
1068     else {
1069 cli2 3430 if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1070 tim 2469 }
1071    
1072 cli2 3430 _cnt74++;
1073 tim 2469 }
1074 cli2 3430 _loop74:;
1075 tim 2469 } // ( ... )+
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     ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1088 cli2 3430 #line 142 "MDTreeParser.g"
1089 tim 2469
1090     vector<int> ivec;
1091     BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1092    
1093 cli2 3430 #line 1094 "MDTreeParser.cpp"
1094 tim 2469
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 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1108 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1109 tim 2469 match(_t,MEMBERS);
1110     _t = _t->getFirstChild();
1111     ivec=inttuple(_t);
1112     _t = _retTree;
1113 tim 2513 _t = __t39;
1114 tim 2469 _t = _t->getNextSibling();
1115 cli2 3430 #line 148 "MDTreeParser.g"
1116 tim 2469 currBendStamp->setMembers(ivec);
1117 cli2 3430 #line 1118 "MDTreeParser.cpp"
1118 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1136 cli2 3430 #line 161 "MDTreeParser.g"
1137 tim 2469
1138     vector<int> ivec;
1139     TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1140    
1141 cli2 3430 #line 1142 "MDTreeParser.cpp"
1142 tim 2469
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 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1156 cli2 3430 ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1157 tim 2469 match(_t,MEMBERS);
1158     _t = _t->getFirstChild();
1159     ivec=inttuple(_t);
1160     _t = _retTree;
1161 tim 2513 _t = __t45;
1162 tim 2469 _t = _t->getNextSibling();
1163 cli2 3430 #line 167 "MDTreeParser.g"
1164 tim 2469 currTorsionStamp->setMembers(ivec);
1165 cli2 3430 #line 1166 "MDTreeParser.cpp"
1166 tim 2469 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 3430 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1183     ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1184     #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 2469 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1231     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1232 cli2 3430 #line 203 "MDTreeParser.g"
1233 tim 2469
1234     vector<int> ivec;
1235     RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1236    
1237 cli2 3430 #line 1238 "MDTreeParser.cpp"
1238 tim 2469
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 3430 ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1252     ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1253 tim 2469 match(_t,MEMBERS);
1254     _t = _t->getFirstChild();
1255     ivec=inttuple(_t);
1256     _t = _retTree;
1257 cli2 3430 _t = __t57;
1258 tim 2469 _t = _t->getNextSibling();
1259 cli2 3430 #line 209 "MDTreeParser.g"
1260 tim 2469 currRigidBodyStamp->setMembers(ivec);
1261 cli2 3430 #line 1262 "MDTreeParser.cpp"
1262 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1280 cli2 3430 #line 222 "MDTreeParser.g"
1281 tim 2469
1282     vector<int> ivec;
1283     CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1284    
1285 cli2 3430 #line 1286 "MDTreeParser.cpp"
1286 tim 2469
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 3430 ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
1300     ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1301 tim 2469 match(_t,MEMBERS);
1302     _t = _t->getFirstChild();
1303     ivec=inttuple(_t);
1304     _t = _retTree;
1305 cli2 3430 _t = __t63;
1306 tim 2469 _t = _t->getNextSibling();
1307 cli2 3430 #line 228 "MDTreeParser.g"
1308 tim 2469 currCutoffGroupStamp->setMembers(ivec);
1309 cli2 3430 #line 1310 "MDTreeParser.cpp"
1310 tim 2469 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     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1328    
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 2759 RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1342 cli2 3430 #line 268 "MDTreeParser.g"
1343 tim 2759 RealType dval;
1344 cli2 3430 #line 1345 "MDTreeParser.cpp"
1345 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1346 tim 2469 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 2513 case NUM_INT:
1354     case NUM_LONG:
1355 tim 2469 {
1356 tim 2509 ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1357     intConst(_t);
1358     _t = _retTree;
1359 cli2 3430 #line 270 "MDTreeParser.g"
1360 tim 2759 dval = lexi_cast<RealType>(ic->getText());
1361 cli2 3430 #line 1362 "MDTreeParser.cpp"
1362 tim 2469 break;
1363     }
1364 tim 2513 case NUM_FLOAT:
1365     case NUM_DOUBLE:
1366 tim 2469 {
1367 tim 2509 fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1368     floatConst(_t);
1369     _t = _retTree;
1370 cli2 3430 #line 271 "MDTreeParser.g"
1371 tim 2759 dval = lexi_cast<RealType>(fc->getText());
1372 cli2 3430 #line 1373 "MDTreeParser.cpp"
1373 tim 2469 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 3430 "\"inversion\"",
1406 tim 2469 "\"rigidBody\"",
1407     "\"cutoffGroup\"",
1408     "\"fragment\"",
1409     "\"members\"",
1410 cli2 3430 "\"center\"",
1411 tim 2469 "\"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 2513 "NUM_INT",
1426     "NUM_LONG",
1427     "NUM_FLOAT",
1428     "NUM_DOUBLE",
1429 tim 2469 "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 2513 "Vocabulary",
1442 tim 2469 "Digit",
1443     "Decimal",
1444 tim 2513 "HEX_DIGIT",
1445     "EXPONENT",
1446     "FLOAT_SUFFIX",
1447 tim 2469 0
1448     };
1449    
1450 cli2 3430 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 2097264UL, 0UL, 0UL, 0UL };
1451 tim 2469 // "component" "molecule" "zconstraint" ASSIGNEQUAL
1452     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1453 cli2 3430 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 2129792UL, 0UL, 0UL, 0UL };
1454     // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1455     // "fragment" ASSIGNEQUAL
1456 tim 2469 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1457    
1458