ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/mdParser/MDTreeParser.cpp
Revision: 3520
Committed: Mon Sep 7 16:31:51 2009 UTC (15 years, 8 months ago) by cli2
File size: 39878 byte(s)
Log Message: 
Added new restraint infrastructure
Added MolecularRestraints
Added ObjectRestraints
Added RestraintStamp
Updated thermodynamic integration to use ObjectRestraints
Added Quaternion mathematics for twist swing decompositions
Significantly updated RestWriter and RestReader to use dump-like files
Added selections for x, y, and z coordinates of atoms
Removed monolithic Restraints class
Fixed a few bugs in gradients of Euler angles in DirectionalAtom and RigidBody
Added some rotational capabilities to prinicpalAxisCalculator

File Contents

# User Rev Content
1 cli2 3520 /* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */
2 tim 2469 #include "MDTreeParser.hpp"
3     #include <antlr/Token.hpp>
4     #include <antlr/AST.hpp>
5     #include <antlr/NoViableAltException.hpp>
6     #include <antlr/MismatchedTokenException.hpp>
7     #include <antlr/SemanticException.hpp>
8     #include <antlr/BitSet.hpp>
9     #line 1 "MDTreeParser.g"
10     #line 11 "MDTreeParser.cpp"
11     MDTreeParser::MDTreeParser()
12     : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
13     }
14    
15     void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
16 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
17 tim 2469
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
48 tim 2469
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 3520 case RESTRAINT:
78     {
79     restraintblock(_t);
80     _t = _retTree;
81     break;
82     }
83 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
99 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
124 tim 2469
125     try { // for error handling
126 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t;
127 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t;
128     match(_t,COMPONENT);
129     _t = _t->getFirstChild();
130 cli2 3520 #line 63 "MDTreeParser.g"
131 tim 2469 Component* currComponet = new Component(); blockStack.push(currComponet);
132 cli2 3520 #line 133 "MDTreeParser.cpp"
133 tim 2469 { // ( ... )*
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 2513 goto _loop11;
143 tim 2469 }
144    
145     }
146 tim 2513 _loop11:;
147 tim 2469 } // ( ... )*
148     ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t;
149     match(_t,ENDBLOCK);
150     _t = _t->getNextSibling();
151 tim 2513 _t = __t9;
152 tim 2469 _t = _t->getNextSibling();
153 cli2 3520 #line 65 "MDTreeParser.g"
154 tim 2469 blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);
155 cli2 3520 #line 156 "MDTreeParser.cpp"
156 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
167 tim 2469
168     try { // for error handling
169 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t;
170 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t;
171     match(_t,MOLECULE);
172     _t = _t->getFirstChild();
173 cli2 3520 #line 78 "MDTreeParser.g"
174 tim 2469 MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);
175 cli2 3520 #line 176 "MDTreeParser.cpp"
176 tim 2469 { // ( ... )*
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 3520 goto _loop23;
186 tim 2469 }
187    
188     }
189 cli2 3520 _loop23:;
190 tim 2469 } // ( ... )*
191     ANTLR_USE_NAMESPACE(antlr)RefAST tmp5_AST_in = _t;
192     match(_t,ENDBLOCK);
193     _t = _t->getNextSibling();
194 cli2 3520 _t = __t21;
195 tim 2469 _t = _t->getNextSibling();
196 cli2 3520 #line 80 "MDTreeParser.g"
197 tim 2469 blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);
198 cli2 3520 #line 199 "MDTreeParser.cpp"
199 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
210 tim 2469
211     try { // for error handling
212 tim 2513 ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t;
213 tim 2469 ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t;
214     match(_t,ZCONSTRAINT);
215     _t = _t->getFirstChild();
216 cli2 3520 #line 68 "MDTreeParser.g"
217 tim 2469 ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);
218 cli2 3520 #line 219 "MDTreeParser.cpp"
219 tim 2469 { // ( ... )*
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 2513 goto _loop15;
229 tim 2469 }
230    
231     }
232 tim 2513 _loop15:;
233 tim 2469 } // ( ... )*
234     ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t;
235     match(_t,ENDBLOCK);
236     _t = _t->getNextSibling();
237 tim 2513 _t = __t13;
238 tim 2469 _t = _t->getNextSibling();
239 cli2 3520 #line 70 "MDTreeParser.g"
240 tim 2469 blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);
241 cli2 3520 #line 242 "MDTreeParser.cpp"
242 tim 2469 }
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 3520 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 2469 void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t,
295     ANTLR_USE_NAMESPACE(antlr)RefAST id
296     ) {
297 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
298 tim 2469 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 3520 #line 48 "MDTreeParser.g"
301 tim 2469
302 tim 2513 int ival;
303 tim 2759 RealType dval;
304 tim 2513
305 cli2 3520 #line 306 "MDTreeParser.cpp"
306 tim 2513
307 tim 2469 try { // for error handling
308     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
309     _t = ASTNULL;
310     switch ( _t->getType()) {
311 tim 2513 case NUM_INT:
312     case NUM_LONG:
313 tim 2469 {
314 tim 2513 ival=intConst(_t);
315 tim 2469 _t = _retTree;
316 cli2 3520 #line 53 "MDTreeParser.g"
317 tim 2513 blockStack.top()->assign(id->getText(), ival);
318 cli2 3520 #line 319 "MDTreeParser.cpp"
319 tim 2469 break;
320     }
321 tim 2513 case NUM_FLOAT:
322     case NUM_DOUBLE:
323     {
324     dval=floatConst(_t);
325     _t = _retTree;
326 cli2 3520 #line 54 "MDTreeParser.g"
327 tim 2513 blockStack.top()->assign(id->getText(), dval);
328 cli2 3520 #line 329 "MDTreeParser.cpp"
329 tim 2513 break;
330     }
331 tim 2469 case ID:
332     {
333     str1 = _t;
334     match(_t,ID);
335     _t = _t->getNextSibling();
336 cli2 3520 #line 55 "MDTreeParser.g"
337 tim 2469 blockStack.top()->assign(id->getText(), str1->getText());
338 cli2 3520 #line 339 "MDTreeParser.cpp"
339 tim 2469 break;
340     }
341     case StringLiteral:
342     {
343     str2 = _t;
344     match(_t,StringLiteral);
345     _t = _t->getNextSibling();
346 cli2 3520 #line 56 "MDTreeParser.g"
347 tim 2469 std::string s = str2->getText();
348     s = s.substr(1, s.length()-2);
349     blockStack.top()->assign(id->getText(),s);
350    
351 cli2 3520 #line 352 "MDTreeParser.cpp"
352 tim 2469 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 3520 #line 268 "MDTreeParser.g"
370 tim 2469 int ival;
371 cli2 3520 #line 372 "MDTreeParser.cpp"
372 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
373 tim 2513 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 2469
376     try { // for error handling
377     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
378     _t = ASTNULL;
379     switch ( _t->getType()) {
380 tim 2513 case NUM_INT:
381 tim 2469 {
382 tim 2513 i1 = _t;
383     match(_t,NUM_INT);
384 tim 2469 _t = _t->getNextSibling();
385 cli2 3520 #line 269 "MDTreeParser.g"
386 tim 2513 ival = lexi_cast<int>(i1->getText());
387 cli2 3520 #line 388 "MDTreeParser.cpp"
388 tim 2469 break;
389     }
390 tim 2513 case NUM_LONG:
391 tim 2469 {
392 tim 2513 i2 = _t;
393     match(_t,NUM_LONG);
394 tim 2469 _t = _t->getNextSibling();
395 cli2 3520 #line 270 "MDTreeParser.g"
396 tim 2513 ival = lexi_cast<int>(i2->getText());
397 cli2 3520 #line 398 "MDTreeParser.cpp"
398 tim 2469 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 2759 RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
416 cli2 3520 #line 282 "MDTreeParser.g"
417 tim 2759 RealType dval;
418 cli2 3520 #line 419 "MDTreeParser.cpp"
419 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
420 tim 2469 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 2513 case NUM_FLOAT:
428 tim 2469 {
429     d1 = _t;
430 tim 2513 match(_t,NUM_FLOAT);
431 tim 2469 _t = _t->getNextSibling();
432 cli2 3520 #line 283 "MDTreeParser.g"
433 tim 2759 dval = lexi_cast<RealType>(d1->getText());
434 cli2 3520 #line 435 "MDTreeParser.cpp"
435 tim 2469 break;
436     }
437 tim 2513 case NUM_DOUBLE:
438 tim 2469 {
439     d2 = _t;
440 tim 2513 match(_t,NUM_DOUBLE);
441 tim 2469 _t = _t->getNextSibling();
442 cli2 3520 #line 284 "MDTreeParser.g"
443 tim 2759 dval = lexi_cast<RealType>(d2->getText());
444 cli2 3520 #line 445 "MDTreeParser.cpp"
445 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
464 tim 2469
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 3430 case INVERSION:
500     {
501     inversionblock(_t);
502     _t = _retTree;
503     break;
504     }
505 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
539 cli2 3520 #line 94 "MDTreeParser.g"
540 tim 2469
541     int index;
542    
543 cli2 3520 #line 544 "MDTreeParser.cpp"
544 tim 2469
545     try { // for error handling
546 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t;
547     ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t;
548 tim 2469 match(_t,ATOM);
549     _t = _t->getFirstChild();
550     index=intConst(_t);
551     _t = _retTree;
552 cli2 3520 #line 98 "MDTreeParser.g"
553 tim 2469 AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);
554 cli2 3520 #line 555 "MDTreeParser.cpp"
555 tim 2469 { // ( ... )*
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 3520 goto _loop28;
565 tim 2469 }
566    
567     }
568 cli2 3520 _loop28:;
569 tim 2469 } // ( ... )*
570 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t;
571 tim 2469 match(_t,ENDBLOCK);
572     _t = _t->getNextSibling();
573 cli2 3520 _t = __t26;
574 tim 2469 _t = _t->getNextSibling();
575 cli2 3520 #line 100 "MDTreeParser.g"
576 tim 2469
577     blockStack.top()->validate();
578     blockStack.pop();
579     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
580     currMoleculeStamp->addAtomStamp(currAtomStamp);
581    
582 cli2 3520 #line 583 "MDTreeParser.cpp"
583 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
594 tim 2469
595     try { // for error handling
596 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t;
597     ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t;
598 tim 2469 match(_t,BOND);
599     _t = _t->getFirstChild();
600 cli2 3520 #line 120 "MDTreeParser.g"
601 tim 2469 BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);
602 cli2 3520 #line 603 "MDTreeParser.cpp"
603 tim 2469 { // ( ... )*
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 3520 goto _loop35;
613 tim 2469 }
614    
615     }
616 cli2 3520 _loop35:;
617 tim 2469 } // ( ... )*
618 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t;
619 tim 2469 match(_t,ENDBLOCK);
620     _t = _t->getNextSibling();
621 cli2 3520 _t = __t33;
622 tim 2469 _t = _t->getNextSibling();
623 cli2 3520 #line 122 "MDTreeParser.g"
624 tim 2469
625     blockStack.pop();
626     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
627     currMoleculeStamp->addBondStamp(currBondStamp);
628    
629 cli2 3520 #line 630 "MDTreeParser.cpp"
630 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
641 tim 2469
642     try { // for error handling
643 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t;
644     ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t;
645 tim 2469 match(_t,BEND);
646     _t = _t->getFirstChild();
647 cli2 3520 #line 138 "MDTreeParser.g"
648 tim 2469 BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);
649 cli2 3520 #line 650 "MDTreeParser.cpp"
650 tim 2469 { // ( ... )*
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 3520 goto _loop41;
660 tim 2469 }
661    
662     }
663 cli2 3520 _loop41:;
664 tim 2469 } // ( ... )*
665 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t;
666 tim 2469 match(_t,ENDBLOCK);
667     _t = _t->getNextSibling();
668 cli2 3520 _t = __t39;
669 tim 2469 _t = _t->getNextSibling();
670 cli2 3520 #line 140 "MDTreeParser.g"
671 tim 2469
672     blockStack.top()->validate();
673     blockStack.pop();
674     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
675     currMoleculeStamp->addBendStamp(currBendStamp);
676    
677 cli2 3520 #line 678 "MDTreeParser.cpp"
678 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
689 tim 2469
690     try { // for error handling
691 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t;
692     ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t;
693 tim 2469 match(_t,TORSION);
694     _t = _t->getFirstChild();
695 cli2 3520 #line 157 "MDTreeParser.g"
696 tim 2469 TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);
697 cli2 3520 #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     torsionstatement(_t);
704     _t = _retTree;
705     }
706     else {
707 cli2 3520 goto _loop47;
708 tim 2469 }
709    
710     }
711 cli2 3520 _loop47:;
712 tim 2469 } // ( ... )*
713 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t;
714 tim 2469 match(_t,ENDBLOCK);
715     _t = _t->getNextSibling();
716 cli2 3520 _t = __t45;
717 tim 2469 _t = _t->getNextSibling();
718 cli2 3520 #line 159 "MDTreeParser.g"
719 tim 2469
720     blockStack.top()->validate();
721     blockStack.pop();
722     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
723     currMoleculeStamp->addTorsionStamp(currTorsionStamp);
724    
725 cli2 3520 #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 cli2 3430 void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
736 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
737 cli2 3430
738     try { // for error handling
739 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t;
740     ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t;
741 cli2 3430 match(_t,INVERSION);
742     _t = _t->getFirstChild();
743 cli2 3520 #line 176 "MDTreeParser.g"
744 cli2 3430 InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);
745 cli2 3520 #line 746 "MDTreeParser.cpp"
746 cli2 3430 { // ( ... )*
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 3520 goto _loop53;
756 cli2 3430 }
757    
758     }
759 cli2 3520 _loop53:;
760 cli2 3430 } // ( ... )*
761 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t;
762 cli2 3430 match(_t,ENDBLOCK);
763     _t = _t->getNextSibling();
764 cli2 3520 _t = __t51;
765 cli2 3430 _t = _t->getNextSibling();
766 cli2 3520 #line 178 "MDTreeParser.g"
767 cli2 3430
768     blockStack.top()->validate();
769     blockStack.pop();
770     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
771     currMoleculeStamp->addInversionStamp(currInversionStamp);
772    
773 cli2 3520 #line 774 "MDTreeParser.cpp"
774 cli2 3430 }
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 2469 void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
784 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
785 cli2 3520 #line 195 "MDTreeParser.g"
786 tim 2469
787     int index;
788    
789 cli2 3520 #line 790 "MDTreeParser.cpp"
790 tim 2469
791     try { // for error handling
792 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t;
793     ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t;
794 tim 2469 match(_t,RIGIDBODY);
795     _t = _t->getFirstChild();
796     index=intConst(_t);
797     _t = _retTree;
798 cli2 3520 #line 199 "MDTreeParser.g"
799 tim 2469 RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);
800 cli2 3520 #line 801 "MDTreeParser.cpp"
801 tim 2469 { // ( ... )*
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 3520 goto _loop59;
811 tim 2469 }
812    
813     }
814 cli2 3520 _loop59:;
815 tim 2469 } // ( ... )*
816 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t;
817 tim 2469 match(_t,ENDBLOCK);
818     _t = _t->getNextSibling();
819 cli2 3520 _t = __t57;
820 tim 2469 _t = _t->getNextSibling();
821 cli2 3520 #line 201 "MDTreeParser.g"
822 tim 2469
823     blockStack.top()->validate();
824     blockStack.pop();
825     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
826     currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
827    
828 cli2 3520 #line 829 "MDTreeParser.cpp"
829 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
840 tim 2469
841     try { // for error handling
842 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t;
843     ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t;
844 tim 2469 match(_t,CUTOFFGROUP);
845     _t = _t->getFirstChild();
846 cli2 3520 #line 218 "MDTreeParser.g"
847 tim 2469 CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);
848 cli2 3520 #line 849 "MDTreeParser.cpp"
849 tim 2469 { // ( ... )*
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 3520 goto _loop65;
859 tim 2469 }
860    
861     }
862 cli2 3520 _loop65:;
863 tim 2469 } // ( ... )*
864 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t;
865 tim 2469 match(_t,ENDBLOCK);
866     _t = _t->getNextSibling();
867 cli2 3520 _t = __t63;
868 tim 2469 _t = _t->getNextSibling();
869 cli2 3520 #line 220 "MDTreeParser.g"
870 tim 2469
871     blockStack.top()->validate();
872     blockStack.pop();
873     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
874     currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
875    
876 cli2 3520 #line 877 "MDTreeParser.cpp"
877 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
888 cli2 3520 #line 237 "MDTreeParser.g"
889 tim 2469 int ival;
890 cli2 3520 #line 891 "MDTreeParser.cpp"
891 tim 2469
892     try { // for error handling
893 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t;
894     ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t;
895 tim 2469 match(_t,FRAGMENT);
896     _t = _t->getFirstChild();
897     ival=intConst(_t);
898     _t = _retTree;
899 cli2 3520 #line 238 "MDTreeParser.g"
900 tim 2469 FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);
901 cli2 3520 #line 902 "MDTreeParser.cpp"
902 tim 2469 { // ( ... )*
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 3520 goto _loop71;
912 tim 2469 }
913    
914     }
915 cli2 3520 _loop71:;
916 tim 2469 } // ( ... )*
917 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t;
918 tim 2469 match(_t,ENDBLOCK);
919     _t = _t->getNextSibling();
920 cli2 3520 _t = __t69;
921 tim 2469 _t = _t->getNextSibling();
922 cli2 3520 #line 240 "MDTreeParser.g"
923 tim 2469
924     blockStack.top()->validate();
925     blockStack.pop();
926     MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
927     currMoleculeStamp->addFragmentStamp(currFragmentStamp);
928    
929 cli2 3520 #line 930 "MDTreeParser.cpp"
930 tim 2469 }
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
941 cli2 3520 #line 108 "MDTreeParser.g"
942 tim 2469
943 tim 2759 vector<RealType> dvec;
944 tim 2469 AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
945    
946    
947 cli2 3520 #line 948 "MDTreeParser.cpp"
948 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t;
962     ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t;
963 tim 2469 match(_t,POSITION);
964     _t = _t->getFirstChild();
965 tim 2513 dvec=doubleNumberTuple(_t);
966 tim 2469 _t = _retTree;
967 cli2 3520 _t = __t30;
968 tim 2469 _t = _t->getNextSibling();
969 cli2 3520 #line 115 "MDTreeParser.g"
970 tim 2469 currAtomStamp->setPosition(dvec);
971 cli2 3520 #line 972 "MDTreeParser.cpp"
972 tim 2469 break;
973     }
974     case ORIENTATION:
975     {
976 cli2 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t;
977     ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t;
978 tim 2469 match(_t,ORIENTATION);
979     _t = _t->getFirstChild();
980 tim 2513 dvec=doubleNumberTuple(_t);
981 tim 2469 _t = _retTree;
982 cli2 3520 _t = __t31;
983 tim 2469 _t = _t->getNextSibling();
984 cli2 3520 #line 116 "MDTreeParser.g"
985 tim 2469 currAtomStamp->setOrientation(dvec);
986 cli2 3520 #line 987 "MDTreeParser.cpp"
987 tim 2469 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 2759 vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1004 cli2 3520 #line 253 "MDTreeParser.g"
1005 tim 2759 vector<RealType> dvec;
1006 cli2 3520 #line 1007 "MDTreeParser.cpp"
1007 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1008 cli2 3520 #line 253 "MDTreeParser.g"
1009 tim 2469
1010 tim 2759 RealType dval;
1011 tim 2469
1012 cli2 3520 #line 1013 "MDTreeParser.cpp"
1013 tim 2469
1014     try { // for error handling
1015     { // ( ... )+
1016 cli2 3520 int _cnt75=0;
1017 tim 2469 for (;;) {
1018     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1019     _t = ASTNULL;
1020 tim 2513 if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) {
1021     dval=doubleNumber(_t);
1022 tim 2469 _t = _retTree;
1023 cli2 3520 #line 257 "MDTreeParser.g"
1024 tim 2469 dvec.push_back(dval);
1025 cli2 3520 #line 1026 "MDTreeParser.cpp"
1026 tim 2469 }
1027     else {
1028 cli2 3520 if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1029 tim 2469 }
1030    
1031 cli2 3520 _cnt75++;
1032 tim 2469 }
1033 cli2 3520 _loop75:;
1034 tim 2469 } // ( ... )+
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1047 cli2 3520 #line 129 "MDTreeParser.g"
1048 tim 2469
1049     vector<int> ivec;
1050     BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
1051    
1052 cli2 3520 #line 1053 "MDTreeParser.cpp"
1053 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t;
1067     ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t;
1068 tim 2469 match(_t,MEMBERS);
1069     _t = _t->getFirstChild();
1070     ivec=inttuple(_t);
1071     _t = _retTree;
1072 cli2 3520 _t = __t37;
1073 tim 2469 _t = _t->getNextSibling();
1074 cli2 3520 #line 135 "MDTreeParser.g"
1075 tim 2469 currBondStamp->setMembers(ivec);
1076 cli2 3520 #line 1077 "MDTreeParser.cpp"
1077 tim 2469 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 3520 #line 260 "MDTreeParser.g"
1095 tim 2469 vector<int> ivec;
1096 cli2 3520 #line 1097 "MDTreeParser.cpp"
1097 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1098 cli2 3520 #line 260 "MDTreeParser.g"
1099 tim 2469
1100     int ival;
1101    
1102 cli2 3520 #line 1103 "MDTreeParser.cpp"
1103 tim 2469
1104     try { // for error handling
1105     { // ( ... )+
1106 cli2 3520 int _cnt78=0;
1107 tim 2469 for (;;) {
1108     if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST )
1109     _t = ASTNULL;
1110 tim 2513 if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) {
1111 tim 2469 ival=intConst(_t);
1112     _t = _retTree;
1113 cli2 3520 #line 264 "MDTreeParser.g"
1114 tim 2469 ivec.push_back(ival);
1115 cli2 3520 #line 1116 "MDTreeParser.cpp"
1116 tim 2469 }
1117     else {
1118 cli2 3520 if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);}
1119 tim 2469 }
1120    
1121 cli2 3520 _cnt78++;
1122 tim 2469 }
1123 cli2 3520 _loop78:;
1124 tim 2469 } // ( ... )+
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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1137 cli2 3520 #line 148 "MDTreeParser.g"
1138 tim 2469
1139     vector<int> ivec;
1140     BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
1141    
1142 cli2 3520 #line 1143 "MDTreeParser.cpp"
1143 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t;
1157     ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t;
1158 tim 2469 match(_t,MEMBERS);
1159     _t = _t->getFirstChild();
1160     ivec=inttuple(_t);
1161     _t = _retTree;
1162 cli2 3520 _t = __t43;
1163 tim 2469 _t = _t->getNextSibling();
1164 cli2 3520 #line 154 "MDTreeParser.g"
1165 tim 2469 currBendStamp->setMembers(ivec);
1166 cli2 3520 #line 1167 "MDTreeParser.cpp"
1167 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1185 cli2 3520 #line 167 "MDTreeParser.g"
1186 tim 2469
1187     vector<int> ivec;
1188     TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
1189    
1190 cli2 3520 #line 1191 "MDTreeParser.cpp"
1191 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t;
1205     ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t;
1206 tim 2469 match(_t,MEMBERS);
1207     _t = _t->getFirstChild();
1208     ivec=inttuple(_t);
1209     _t = _retTree;
1210 cli2 3520 _t = __t49;
1211 tim 2469 _t = _t->getNextSibling();
1212 cli2 3520 #line 173 "MDTreeParser.g"
1213 tim 2469 currTorsionStamp->setMembers(ivec);
1214 cli2 3520 #line 1215 "MDTreeParser.cpp"
1215 tim 2469 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 3430 void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1232 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1233 cli2 3520 #line 186 "MDTreeParser.g"
1234 cli2 3430
1235     int icent;
1236     InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
1237    
1238 cli2 3520 #line 1239 "MDTreeParser.cpp"
1239 cli2 3430
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t;
1253     ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t;
1254 cli2 3430 match(_t,CENTER);
1255     _t = _t->getFirstChild();
1256     icent=intConst(_t);
1257     _t = _retTree;
1258 cli2 3520 _t = __t55;
1259 cli2 3430 _t = _t->getNextSibling();
1260 cli2 3520 #line 192 "MDTreeParser.g"
1261 cli2 3430 currInversionStamp->setCenter(icent);
1262 cli2 3520 #line 1263 "MDTreeParser.cpp"
1263 cli2 3430 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 2469 void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1280 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1281 cli2 3520 #line 209 "MDTreeParser.g"
1282 tim 2469
1283     vector<int> ivec;
1284     RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
1285    
1286 cli2 3520 #line 1287 "MDTreeParser.cpp"
1287 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t;
1301     ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t;
1302 tim 2469 match(_t,MEMBERS);
1303     _t = _t->getFirstChild();
1304     ivec=inttuple(_t);
1305     _t = _retTree;
1306 cli2 3520 _t = __t61;
1307 tim 2469 _t = _t->getNextSibling();
1308 cli2 3520 #line 215 "MDTreeParser.g"
1309 tim 2469 currRigidBodyStamp->setMembers(ivec);
1310 cli2 3520 #line 1311 "MDTreeParser.cpp"
1311 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1329 cli2 3520 #line 228 "MDTreeParser.g"
1330 tim 2469
1331     vector<int> ivec;
1332     CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
1333    
1334 cli2 3520 #line 1335 "MDTreeParser.cpp"
1335 tim 2469
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 3520 ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t;
1349     ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t;
1350 tim 2469 match(_t,MEMBERS);
1351     _t = _t->getFirstChild();
1352     ivec=inttuple(_t);
1353     _t = _retTree;
1354 cli2 3520 _t = __t67;
1355 tim 2469 _t = _t->getNextSibling();
1356 cli2 3520 #line 234 "MDTreeParser.g"
1357 tim 2469 currCutoffGroupStamp->setMembers(ivec);
1358 cli2 3520 #line 1359 "MDTreeParser.cpp"
1359 tim 2469 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 3432 ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1377 tim 2469
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 2759 RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) {
1391 cli2 3520 #line 274 "MDTreeParser.g"
1392 tim 2759 RealType dval;
1393 cli2 3520 #line 1394 "MDTreeParser.cpp"
1394 gezelter 3432 ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1395 tim 2469 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 2513 case NUM_INT:
1403     case NUM_LONG:
1404 tim 2469 {
1405 tim 2509 ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1406     intConst(_t);
1407     _t = _retTree;
1408 cli2 3520 #line 276 "MDTreeParser.g"
1409 tim 2759 dval = lexi_cast<RealType>(ic->getText());
1410 cli2 3520 #line 1411 "MDTreeParser.cpp"
1411 tim 2469 break;
1412     }
1413 tim 2513 case NUM_FLOAT:
1414     case NUM_DOUBLE:
1415 tim 2469 {
1416 tim 2509 fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t;
1417     floatConst(_t);
1418     _t = _retTree;
1419 cli2 3520 #line 277 "MDTreeParser.g"
1420 tim 2759 dval = lexi_cast<RealType>(fc->getText());
1421 cli2 3520 #line 1422 "MDTreeParser.cpp"
1422 tim 2469 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 3520 "\"restraint\"",
1451 tim 2469 "\"atom\"",
1452     "\"bond\"",
1453     "\"bend\"",
1454     "\"torsion\"",
1455 cli2 3430 "\"inversion\"",
1456 tim 2469 "\"rigidBody\"",
1457     "\"cutoffGroup\"",
1458     "\"fragment\"",
1459     "\"members\"",
1460 cli2 3430 "\"center\"",
1461 tim 2469 "\"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 2513 "NUM_INT",
1476     "NUM_LONG",
1477     "NUM_FLOAT",
1478     "NUM_DOUBLE",
1479 tim 2469 "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 2513 "Vocabulary",
1492 tim 2469 "Digit",
1493     "Decimal",
1494 tim 2513 "HEX_DIGIT",
1495     "EXPONENT",
1496     "FLOAT_SUFFIX",
1497 tim 2469 0
1498     };
1499    
1500 cli2 3520 const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL };
1501     // "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL
1502 tim 2469 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4);
1503 cli2 3520 const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL };
1504 cli2 3430 // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1505     // "fragment" ASSIGNEQUAL
1506 tim 2469 const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4);
1507    
1508