ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.cpp
Revision: 1442
Committed: Mon May 10 17:28:26 2010 UTC (14 years, 11 months ago) by gezelter
File size: 39878 byte(s)
Log Message: 
Adding property set to svn entries

File Contents

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

Properties

Name Value
svn:keywords Author Id Revision Date