ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDTreeParser.cpp
Revision: 2513
Committed: Fri Dec 16 02:57:00 2005 UTC (18 years, 7 months ago) by tim
File size: 34720 byte(s)
Log Message: 
replace grammar for numerical parsing

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 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     double dval;
255    
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 tim 2513 #line 242 "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 tim 2513 #line 243 "MDTreeParser.g"
337     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 tim 2513 #line 244 "MDTreeParser.g"
347     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     double MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
367 tim 2513 #line 256 "MDTreeParser.g"
368 tim 2469 double 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 tim 2513 #line 257 "MDTreeParser.g"
384 tim 2469 dval = lexi_cast<double>(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 tim 2513 #line 258 "MDTreeParser.g"
394 tim 2469 dval = lexi_cast<double>(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     case RIGIDBODY:
451     {
452     rigidbodyblock(_t);
453     _t = _retTree;
454     break;
455     }
456     case CUTOFFGROUP:
457     {
458     cutoffgroupblock(_t);
459     _t = _retTree;
460     break;
461     }
462     case FRAGMENT:
463     {
464     fragmentblock(_t);
465     _t = _retTree;
466     break;
467     }
468     default:
469     {
470     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
471     }
472     }
473     }
474     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
475     reportError(ex);
476     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
477     _t = _t->getNextSibling();
478     }
479     _retTree = _t;
480     }
481    
482     void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
483     ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
484 tim 2513 #line 87 "MDTreeParser.g"
485 tim 2469
486     int index;
487    
488 tim 2513 #line 489 "MDTreeParser.cpp"
489 tim 2469
490     try { // for error handling
491 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t22 = _t;
492     ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t;
493 tim 2469 match(_t,ATOM);
494     _t = _t->getFirstChild();
495     index=intConst(_t);
496     _t = _retTree;
497 tim 2513 #line 91 "MDTreeParser.g"
498 tim 2469 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
499 tim 2513 #line 500 "MDTreeParser.cpp"
500 tim 2469 { // ( ... )*
501     for (;;) {
502     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
503     _t = ASTNULL;
504     if ((_t->getType() == POSITION || _t->getType() == ORIENTATION || _t->getType() == ASSIGNEQUAL)) {
505     atomstatement(_t);
506     _t = _retTree;
507     }
508     else {
509 tim 2513 goto _loop24;
510 tim 2469 }
511    
512     }
513 tim 2513 _loop24:;
514 tim 2469 } // ( ... )*
515 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t;
516 tim 2469 match(_t,ENDBLOCK);
517     _t = _t->getNextSibling();
518 tim 2513 _t = __t22;
519 tim 2469 _t = _t->getNextSibling();
520 tim 2513 #line 93 "MDTreeParser.g"
521 tim 2469
522     blockStack.top()->validate();
523     blockStack.pop();
524     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
525     currMoleculeStamp->addAtomStamp(currAtomStamp);
526    
527 tim 2513 #line 528 "MDTreeParser.cpp"
528 tim 2469 }
529     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
530     reportError(ex);
531     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
532     _t = _t->getNextSibling();
533     }
534     _retTree = _t;
535     }
536    
537     void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
538     ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539    
540     try { // for error handling
541 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t29 = _t;
542     ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
543 tim 2469 match(_t,BOND);
544     _t = _t->getFirstChild();
545 tim 2513 #line 113 "MDTreeParser.g"
546 tim 2469 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
547 tim 2513 #line 548 "MDTreeParser.cpp"
548 tim 2469 { // ( ... )*
549     for (;;) {
550     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
551     _t = ASTNULL;
552     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
553     bondstatement(_t);
554     _t = _retTree;
555     }
556     else {
557 tim 2513 goto _loop31;
558 tim 2469 }
559    
560     }
561 tim 2513 _loop31:;
562 tim 2469 } // ( ... )*
563 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
564 tim 2469 match(_t,ENDBLOCK);
565     _t = _t->getNextSibling();
566 tim 2513 _t = __t29;
567 tim 2469 _t = _t->getNextSibling();
568 tim 2513 #line 115 "MDTreeParser.g"
569 tim 2469
570     blockStack.pop();
571     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
572     currMoleculeStamp->addBondStamp(currBondStamp);
573    
574 tim 2513 #line 575 "MDTreeParser.cpp"
575 tim 2469 }
576     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
577     reportError(ex);
578     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
579     _t = _t->getNextSibling();
580     }
581     _retTree = _t;
582     }
583    
584     void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
585     ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
586    
587     try { // for error handling
588 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t35 = _t;
589     ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
590 tim 2469 match(_t,BEND);
591     _t = _t->getFirstChild();
592 tim 2513 #line 131 "MDTreeParser.g"
593 tim 2469 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
594 tim 2513 #line 595 "MDTreeParser.cpp"
595 tim 2469 { // ( ... )*
596     for (;;) {
597     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
598     _t = ASTNULL;
599     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
600     bendstatement(_t);
601     _t = _retTree;
602     }
603     else {
604 tim 2513 goto _loop37;
605 tim 2469 }
606    
607     }
608 tim 2513 _loop37:;
609 tim 2469 } // ( ... )*
610 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
611 tim 2469 match(_t,ENDBLOCK);
612     _t = _t->getNextSibling();
613 tim 2513 _t = __t35;
614 tim 2469 _t = _t->getNextSibling();
615 tim 2513 #line 133 "MDTreeParser.g"
616 tim 2469
617     blockStack.top()->validate();
618     blockStack.pop();
619     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
620     currMoleculeStamp->addBendStamp(currBendStamp);
621    
622 tim 2513 #line 623 "MDTreeParser.cpp"
623 tim 2469 }
624     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
625     reportError(ex);
626     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
627     _t = _t->getNextSibling();
628     }
629     _retTree = _t;
630     }
631    
632     void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
633     ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
634    
635     try { // for error handling
636 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t41 = _t;
637     ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
638 tim 2469 match(_t,TORSION);
639     _t = _t->getFirstChild();
640 tim 2513 #line 150 "MDTreeParser.g"
641 tim 2469 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
642 tim 2513 #line 643 "MDTreeParser.cpp"
643 tim 2469 { // ( ... )*
644     for (;;) {
645     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
646     _t = ASTNULL;
647     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
648     torsionstatement(_t);
649     _t = _retTree;
650     }
651     else {
652 tim 2513 goto _loop43;
653 tim 2469 }
654    
655     }
656 tim 2513 _loop43:;
657 tim 2469 } // ( ... )*
658 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
659 tim 2469 match(_t,ENDBLOCK);
660     _t = _t->getNextSibling();
661 tim 2513 _t = __t41;
662 tim 2469 _t = _t->getNextSibling();
663 tim 2513 #line 152 "MDTreeParser.g"
664 tim 2469
665     blockStack.top()->validate();
666     blockStack.pop();
667     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
668     currMoleculeStamp->addTorsionStamp(currTorsionStamp);
669    
670 tim 2513 #line 671 "MDTreeParser.cpp"
671 tim 2469 }
672     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
673     reportError(ex);
674     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
675     _t = _t->getNextSibling();
676     }
677     _retTree = _t;
678     }
679    
680     void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
681     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
682 tim 2513 #line 169 "MDTreeParser.g"
683 tim 2469
684     int index;
685    
686 tim 2513 #line 687 "MDTreeParser.cpp"
687 tim 2469
688     try { // for error handling
689 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t47 = _t;
690     ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
691 tim 2469 match(_t,RIGIDBODY);
692     _t = _t->getFirstChild();
693     index=intConst(_t);
694     _t = _retTree;
695 tim 2513 #line 173 "MDTreeParser.g"
696 tim 2469 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
697 tim 2513 #line 698 "MDTreeParser.cpp"
698 tim 2469 { // ( ... )*
699     for (;;) {
700     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
701     _t = ASTNULL;
702     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
703     rigidbodystatement(_t);
704     _t = _retTree;
705     }
706     else {
707 tim 2513 goto _loop49;
708 tim 2469 }
709    
710     }
711 tim 2513 _loop49:;
712 tim 2469 } // ( ... )*
713 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714 tim 2469 match(_t,ENDBLOCK);
715     _t = _t->getNextSibling();
716 tim 2513 _t = __t47;
717 tim 2469 _t = _t->getNextSibling();
718 tim 2513 #line 175 "MDTreeParser.g"
719 tim 2469
720     blockStack.top()->validate();
721     blockStack.pop();
722     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723     currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
724    
725 tim 2513 #line 726 "MDTreeParser.cpp"
726 tim 2469 }
727     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
728     reportError(ex);
729     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
730     _t = _t->getNextSibling();
731     }
732     _retTree = _t;
733     }
734    
735     void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
736     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
737    
738     try { // for error handling
739 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t53 = _t;
740     ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741 tim 2469 match(_t,CUTOFFGROUP);
742     _t = _t->getFirstChild();
743 tim 2513 #line 192 "MDTreeParser.g"
744 tim 2469 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
745 tim 2513 #line 746 "MDTreeParser.cpp"
746 tim 2469 { // ( ... )*
747     for (;;) {
748     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
749     _t = ASTNULL;
750     if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) {
751     cutoffgroupstatement(_t);
752     _t = _retTree;
753     }
754     else {
755 tim 2513 goto _loop55;
756 tim 2469 }
757    
758     }
759 tim 2513 _loop55:;
760 tim 2469 } // ( ... )*
761 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
762 tim 2469 match(_t,ENDBLOCK);
763     _t = _t->getNextSibling();
764 tim 2513 _t = __t53;
765 tim 2469 _t = _t->getNextSibling();
766 tim 2513 #line 194 "MDTreeParser.g"
767 tim 2469
768     blockStack.top()->validate();
769     blockStack.pop();
770     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771     currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
772    
773 tim 2513 #line 774 "MDTreeParser.cpp"
774 tim 2469 }
775     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
776     reportError(ex);
777     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
778     _t = _t->getNextSibling();
779     }
780     _retTree = _t;
781     }
782    
783     void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785 tim 2513 #line 211 "MDTreeParser.g"
786 tim 2469 int ival;
787 tim 2513 #line 788 "MDTreeParser.cpp"
788 tim 2469
789     try { // for error handling
790 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t59 = _t;
791     ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
792 tim 2469 match(_t,FRAGMENT);
793     _t = _t->getFirstChild();
794     ival=intConst(_t);
795     _t = _retTree;
796 tim 2513 #line 212 "MDTreeParser.g"
797 tim 2469 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
798 tim 2513 #line 799 "MDTreeParser.cpp"
799 tim 2469 { // ( ... )*
800     for (;;) {
801     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
802     _t = ASTNULL;
803     if ((_t->getType() == ASSIGNEQUAL)) {
804     fragmentstatement(_t);
805     _t = _retTree;
806     }
807     else {
808 tim 2513 goto _loop61;
809 tim 2469 }
810    
811     }
812 tim 2513 _loop61:;
813 tim 2469 } // ( ... )*
814 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
815 tim 2469 match(_t,ENDBLOCK);
816     _t = _t->getNextSibling();
817 tim 2513 _t = __t59;
818 tim 2469 _t = _t->getNextSibling();
819 tim 2513 #line 214 "MDTreeParser.g"
820 tim 2469
821     blockStack.top()->validate();
822     blockStack.pop();
823     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
824     currMoleculeStamp->addFragmentStamp(currFragmentStamp);
825    
826 tim 2513 #line 827 "MDTreeParser.cpp"
827 tim 2469 }
828     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
829     reportError(ex);
830     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
831     _t = _t->getNextSibling();
832     }
833     _retTree = _t;
834     }
835    
836     void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
837     ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
838 tim 2513 #line 101 "MDTreeParser.g"
839 tim 2469
840     vector<double> dvec;
841     AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
842    
843    
844 tim 2513 #line 845 "MDTreeParser.cpp"
845 tim 2469
846     try { // for error handling
847     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
848     _t = ASTNULL;
849     switch ( _t->getType()) {
850     case ASSIGNEQUAL:
851     {
852     assignment(_t);
853     _t = _retTree;
854     break;
855     }
856     case POSITION:
857     {
858 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
859     ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
860 tim 2469 match(_t,POSITION);
861     _t = _t->getFirstChild();
862 tim 2513 dvec=doubleNumberTuple(_t);
863 tim 2469 _t = _retTree;
864 tim 2513 _t = __t26;
865 tim 2469 _t = _t->getNextSibling();
866 tim 2513 #line 108 "MDTreeParser.g"
867 tim 2469 currAtomStamp->setPosition(dvec);
868 tim 2513 #line 869 "MDTreeParser.cpp"
869 tim 2469 break;
870     }
871     case ORIENTATION:
872     {
873 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t27 = _t;
874     ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
875 tim 2469 match(_t,ORIENTATION);
876     _t = _t->getFirstChild();
877 tim 2513 dvec=doubleNumberTuple(_t);
878 tim 2469 _t = _retTree;
879 tim 2513 _t = __t27;
880 tim 2469 _t = _t->getNextSibling();
881 tim 2513 #line 109 "MDTreeParser.g"
882 tim 2469 currAtomStamp->setOrientation(dvec);
883 tim 2513 #line 884 "MDTreeParser.cpp"
884 tim 2469 break;
885     }
886     default:
887     {
888     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
889     }
890     }
891     }
892     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
893     reportError(ex);
894     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
895     _t = _t->getNextSibling();
896     }
897     _retTree = _t;
898     }
899    
900 tim 2513 vector<double> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
901     #line 227 "MDTreeParser.g"
902 tim 2469 vector<double> dvec;
903 tim 2513 #line 904 "MDTreeParser.cpp"
904     ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
905     #line 227 "MDTreeParser.g"
906 tim 2469
907     double dval;
908    
909 tim 2513 #line 910 "MDTreeParser.cpp"
910 tim 2469
911     try { // for error handling
912     { // ( ... )+
913 tim 2513 int _cnt65=0;
914 tim 2469 for (;;) {
915     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
916     _t = ASTNULL;
917 tim 2513 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
918     dval=doubleNumber(_t);
919 tim 2469 _t = _retTree;
920 tim 2513 #line 231 "MDTreeParser.g"
921 tim 2469 dvec.push_back(dval);
922 tim 2513 #line 923 "MDTreeParser.cpp"
923 tim 2469 }
924     else {
925 tim 2513 if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
926 tim 2469 }
927    
928 tim 2513 _cnt65++;
929 tim 2469 }
930 tim 2513 _loop65:;
931 tim 2469 } // ( ... )+
932     }
933     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
934     reportError(ex);
935     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
936     _t = _t->getNextSibling();
937     }
938     _retTree = _t;
939     return dvec;
940     }
941    
942     void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
943     ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
944 tim 2513 #line 122 "MDTreeParser.g"
945 tim 2469
946     vector<int> ivec;
947     BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
948    
949 tim 2513 #line 950 "MDTreeParser.cpp"
950 tim 2469
951     try { // for error handling
952     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
953     _t = ASTNULL;
954     switch ( _t->getType()) {
955     case ASSIGNEQUAL:
956     {
957     assignment(_t);
958     _t = _retTree;
959     break;
960     }
961     case MEMBERS:
962     {
963 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
964     ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
965 tim 2469 match(_t,MEMBERS);
966     _t = _t->getFirstChild();
967     ivec=inttuple(_t);
968     _t = _retTree;
969 tim 2513 _t = __t33;
970 tim 2469 _t = _t->getNextSibling();
971 tim 2513 #line 128 "MDTreeParser.g"
972 tim 2469 currBondStamp->setMembers(ivec);
973 tim 2513 #line 974 "MDTreeParser.cpp"
974 tim 2469 break;
975     }
976     default:
977     {
978     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
979     }
980     }
981     }
982     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
983     reportError(ex);
984     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
985     _t = _t->getNextSibling();
986     }
987     _retTree = _t;
988     }
989    
990     vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
991 tim 2513 #line 234 "MDTreeParser.g"
992 tim 2469 vector<int> ivec;
993 tim 2513 #line 994 "MDTreeParser.cpp"
994 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
995 tim 2513 #line 234 "MDTreeParser.g"
996 tim 2469
997     int ival;
998    
999 tim 2513 #line 1000 "MDTreeParser.cpp"
1000 tim 2469
1001     try { // for error handling
1002     { // ( ... )+
1003 tim 2513 int _cnt68=0;
1004 tim 2469 for (;;) {
1005     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1006     _t = ASTNULL;
1007 tim 2513 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1008 tim 2469 ival=intConst(_t);
1009     _t = _retTree;
1010 tim 2513 #line 238 "MDTreeParser.g"
1011 tim 2469 ivec.push_back(ival);
1012 tim 2513 #line 1013 "MDTreeParser.cpp"
1013 tim 2469 }
1014     else {
1015 tim 2513 if ( _cnt68>=1 ) { goto _loop68; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1016 tim 2469 }
1017    
1018 tim 2513 _cnt68++;
1019 tim 2469 }
1020 tim 2513 _loop68:;
1021 tim 2469 } // ( ... )+
1022     }
1023     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1024     reportError(ex);
1025     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1026     _t = _t->getNextSibling();
1027     }
1028     _retTree = _t;
1029     return ivec;
1030     }
1031    
1032     void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1033     ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1034 tim 2513 #line 141 "MDTreeParser.g"
1035 tim 2469
1036     vector<int> ivec;
1037     BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1038    
1039 tim 2513 #line 1040 "MDTreeParser.cpp"
1040 tim 2469
1041     try { // for error handling
1042     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1043     _t = ASTNULL;
1044     switch ( _t->getType()) {
1045     case ASSIGNEQUAL:
1046     {
1047     assignment(_t);
1048     _t = _retTree;
1049     break;
1050     }
1051     case MEMBERS:
1052     {
1053 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
1054     ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
1055 tim 2469 match(_t,MEMBERS);
1056     _t = _t->getFirstChild();
1057     ivec=inttuple(_t);
1058     _t = _retTree;
1059 tim 2513 _t = __t39;
1060 tim 2469 _t = _t->getNextSibling();
1061 tim 2513 #line 147 "MDTreeParser.g"
1062 tim 2469 currBendStamp->setMembers(ivec);
1063 tim 2513 #line 1064 "MDTreeParser.cpp"
1064 tim 2469 break;
1065     }
1066     default:
1067     {
1068     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1069     }
1070     }
1071     }
1072     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1073     reportError(ex);
1074     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1075     _t = _t->getNextSibling();
1076     }
1077     _retTree = _t;
1078     }
1079    
1080     void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1081     ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1082 tim 2513 #line 160 "MDTreeParser.g"
1083 tim 2469
1084     vector<int> ivec;
1085     TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1086    
1087 tim 2513 #line 1088 "MDTreeParser.cpp"
1088 tim 2469
1089     try { // for error handling
1090     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1091     _t = ASTNULL;
1092     switch ( _t->getType()) {
1093     case ASSIGNEQUAL:
1094     {
1095     assignment(_t);
1096     _t = _retTree;
1097     break;
1098     }
1099     case MEMBERS:
1100     {
1101 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
1102     ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
1103 tim 2469 match(_t,MEMBERS);
1104     _t = _t->getFirstChild();
1105     ivec=inttuple(_t);
1106     _t = _retTree;
1107 tim 2513 _t = __t45;
1108 tim 2469 _t = _t->getNextSibling();
1109 tim 2513 #line 166 "MDTreeParser.g"
1110 tim 2469 currTorsionStamp->setMembers(ivec);
1111 tim 2513 #line 1112 "MDTreeParser.cpp"
1112 tim 2469 break;
1113     }
1114     default:
1115     {
1116     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1117     }
1118     }
1119     }
1120     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1121     reportError(ex);
1122     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1123     _t = _t->getNextSibling();
1124     }
1125     _retTree = _t;
1126     }
1127    
1128     void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1129     ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1130 tim 2513 #line 183 "MDTreeParser.g"
1131 tim 2469
1132     vector<int> ivec;
1133     RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1134    
1135 tim 2513 #line 1136 "MDTreeParser.cpp"
1136 tim 2469
1137     try { // for error handling
1138     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1139     _t = ASTNULL;
1140     switch ( _t->getType()) {
1141     case ASSIGNEQUAL:
1142     {
1143     assignment(_t);
1144     _t = _retTree;
1145     break;
1146     }
1147     case MEMBERS:
1148     {
1149 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
1150     ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
1151 tim 2469 match(_t,MEMBERS);
1152     _t = _t->getFirstChild();
1153     ivec=inttuple(_t);
1154     _t = _retTree;
1155 tim 2513 _t = __t51;
1156 tim 2469 _t = _t->getNextSibling();
1157 tim 2513 #line 189 "MDTreeParser.g"
1158 tim 2469 currRigidBodyStamp->setMembers(ivec);
1159 tim 2513 #line 1160 "MDTreeParser.cpp"
1160 tim 2469 break;
1161     }
1162     default:
1163     {
1164     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1165     }
1166     }
1167     }
1168     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1169     reportError(ex);
1170     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1171     _t = _t->getNextSibling();
1172     }
1173     _retTree = _t;
1174     }
1175    
1176     void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1177     ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1178 tim 2513 #line 202 "MDTreeParser.g"
1179 tim 2469
1180     vector<int> ivec;
1181     CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1182    
1183 tim 2513 #line 1184 "MDTreeParser.cpp"
1184 tim 2469
1185     try { // for error handling
1186     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1187     _t = ASTNULL;
1188     switch ( _t->getType()) {
1189     case ASSIGNEQUAL:
1190     {
1191     assignment(_t);
1192     _t = _retTree;
1193     break;
1194     }
1195     case MEMBERS:
1196     {
1197 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
1198     ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1199 tim 2469 match(_t,MEMBERS);
1200     _t = _t->getFirstChild();
1201     ivec=inttuple(_t);
1202     _t = _retTree;
1203 tim 2513 _t = __t57;
1204 tim 2469 _t = _t->getNextSibling();
1205 tim 2513 #line 208 "MDTreeParser.g"
1206 tim 2469 currCutoffGroupStamp->setMembers(ivec);
1207 tim 2513 #line 1208 "MDTreeParser.cpp"
1208 tim 2469 break;
1209     }
1210     default:
1211     {
1212     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1213     }
1214     }
1215     }
1216     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1217     reportError(ex);
1218     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1219     _t = _t->getNextSibling();
1220     }
1221     _retTree = _t;
1222     }
1223    
1224     void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1225     ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1226    
1227     try { // for error handling
1228     assignment(_t);
1229     _t = _retTree;
1230     }
1231     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1232     reportError(ex);
1233     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1234     _t = _t->getNextSibling();
1235     }
1236     _retTree = _t;
1237     }
1238    
1239 tim 2513 double MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1240     #line 248 "MDTreeParser.g"
1241 tim 2469 double dval;
1242 tim 2513 #line 1243 "MDTreeParser.cpp"
1243     ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1244 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST;
1245     ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST;
1246    
1247     try { // for error handling
1248     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1249     _t = ASTNULL;
1250     switch ( _t->getType()) {
1251 tim 2513 case NUM_INT:
1252     case NUM_LONG:
1253 tim 2469 {
1254 tim 2509 ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1255     intConst(_t);
1256     _t = _retTree;
1257 tim 2513 #line 250 "MDTreeParser.g"
1258 tim 2509 dval = lexi_cast<double>(ic->getText());
1259 tim 2513 #line 1260 "MDTreeParser.cpp"
1260 tim 2469 break;
1261     }
1262 tim 2513 case NUM_FLOAT:
1263     case NUM_DOUBLE:
1264 tim 2469 {
1265 tim 2509 fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1266     floatConst(_t);
1267     _t = _retTree;
1268 tim 2513 #line 251 "MDTreeParser.g"
1269 tim 2509 dval = lexi_cast<double>(fc->getText());
1270 tim 2513 #line 1271 "MDTreeParser.cpp"
1271 tim 2469 break;
1272     }
1273     default:
1274     {
1275     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);
1276     }
1277     }
1278     }
1279     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
1280     reportError(ex);
1281     if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST )
1282     _t = _t->getNextSibling();
1283     }
1284     _retTree = _t;
1285     return dval;
1286     }
1287    
1288     void MDTreeParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
1289     {
1290     }
1291     const char* MDTreeParser::tokenNames[] = {
1292     "<0>",
1293     "EOF",
1294     "<2>",
1295     "NULL_TREE_LOOKAHEAD",
1296     "\"component\"",
1297     "\"molecule\"",
1298     "\"zconstraint\"",
1299     "\"atom\"",
1300     "\"bond\"",
1301     "\"bend\"",
1302     "\"torsion\"",
1303     "\"rigidBody\"",
1304     "\"cutoffGroup\"",
1305     "\"fragment\"",
1306     "\"members\"",
1307     "\"position\"",
1308     "\"orientation\"",
1309     "ENDBLOCK",
1310     "ID",
1311     "ASSIGNEQUAL",
1312     "SEMICOLON",
1313     "StringLiteral",
1314     "LCURLY",
1315     "RCURLY",
1316     "LBRACKET",
1317     "RBRACKET",
1318     "LPAREN",
1319     "RPAREN",
1320     "COMMA",
1321 tim 2513 "NUM_INT",
1322     "NUM_LONG",
1323     "NUM_FLOAT",
1324     "NUM_DOUBLE",
1325 tim 2469 "DOT",
1326     "COLON",
1327     "QUESTIONMARK",
1328     "Whitespace",
1329     "Comment",
1330     "CPPComment",
1331     "a line directive",
1332     "LineDirective",
1333     "Space",
1334     "CharLiteral",
1335     "EndOfLine",
1336     "Escape",
1337 tim 2513 "Vocabulary",
1338 tim 2469 "Digit",
1339     "Decimal",
1340 tim 2513 "HEX_DIGIT",
1341     "EXPONENT",
1342     "FLOAT_SUFFIX",
1343 tim 2469 0
1344     };
1345    
1346     const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL };
1347     // "component" "molecule" "zconstraint" ASSIGNEQUAL
1348     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1349     const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL };
1350     // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment"
1351     // ASSIGNEQUAL
1352     const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1353    
1354