ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDTreeParser.cpp
Revision: 2509
Committed: Wed Dec 14 18:02:28 2005 UTC (19 years, 10 months ago) by tim
File size: 37896 byte(s)
Log Message: 
fix a nasty negative integer parsing problem by refining the grammar

File Contents

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