# | Line 1 | Line 1 | |
---|---|---|
1 | < | /* $ANTLR 2.7.5 (20050406): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */ |
1 | > | /* $ANTLR 2.7.7 (20090623): "MDTreeParser.g" -> "MDTreeParser.cpp"$ */ |
2 | #include "MDTreeParser.hpp" | |
3 | #include <antlr/Token.hpp> | |
4 | #include <antlr/AST.hpp> | |
# | Line 13 | Line 13 | void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)Re | |
13 | } | |
14 | ||
15 | void MDTreeParser::mdfile(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
16 | < | ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
16 | > | ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
17 | ||
18 | try { // for error handling | |
19 | { // ( ... )* | |
# | Line 44 | Line 44 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr | |
44 | } | |
45 | ||
46 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
47 | < | ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
47 | > | ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
48 | ||
49 | try { // for error handling | |
50 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 74 | Line 74 | void MDTreeParser::statement(ANTLR_USE_NAMESPACE(antlr | |
74 | _t = _retTree; | |
75 | break; | |
76 | } | |
77 | + | case RESTRAINT: |
78 | + | { |
79 | + | restraintblock(_t); |
80 | + | _t = _retTree; |
81 | + | break; |
82 | + | } |
83 | default: | |
84 | { | |
85 | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); | |
# | Line 89 | Line 95 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antl | |
95 | } | |
96 | ||
97 | void MDTreeParser::assignment(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
98 | < | ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
98 | > | ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
99 | ANTLR_USE_NAMESPACE(antlr)RefAST id = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
100 | ||
101 | try { // for error handling | |
# | Line 114 | Line 120 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE( | |
120 | } | |
121 | ||
122 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
123 | < | ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
123 | > | ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
124 | ||
125 | try { // for error handling | |
126 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t; |
126 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t; |
127 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST_in = _t; | |
128 | match(_t,COMPONENT); | |
129 | _t = _t->getFirstChild(); | |
130 | < | #line 69 "MDTreeParser.g" |
130 | > | #line 63 "MDTreeParser.g" |
131 | Component* currComponet = new Component(); blockStack.push(currComponet); | |
132 | < | #line 127 "MDTreeParser.cpp" |
132 | > | #line 133 "MDTreeParser.cpp" |
133 | { // ( ... )* | |
134 | for (;;) { | |
135 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 133 | Line 139 | void MDTreeParser::componentblock(ANTLR_USE_NAMESPACE( | |
139 | _t = _retTree; | |
140 | } | |
141 | else { | |
142 | < | goto _loop15; |
142 | > | goto _loop11; |
143 | } | |
144 | ||
145 | } | |
146 | < | _loop15:; |
146 | > | _loop11:; |
147 | } // ( ... )* | |
148 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp3_AST_in = _t; | |
149 | match(_t,ENDBLOCK); | |
150 | _t = _t->getNextSibling(); | |
151 | < | _t = __t13; |
151 | > | _t = __t9; |
152 | _t = _t->getNextSibling(); | |
153 | < | #line 71 "MDTreeParser.g" |
153 | > | #line 65 "MDTreeParser.g" |
154 | blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet); | |
155 | < | #line 150 "MDTreeParser.cpp" |
155 | > | #line 156 "MDTreeParser.cpp" |
156 | } | |
157 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
158 | reportError(ex); | |
# | Line 157 | Line 163 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a | |
163 | } | |
164 | ||
165 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
166 | < | ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
166 | > | ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
167 | ||
168 | try { // for error handling | |
169 | ANTLR_USE_NAMESPACE(antlr)RefAST __t21 = _t; | |
170 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST_in = _t; | |
171 | match(_t,MOLECULE); | |
172 | _t = _t->getFirstChild(); | |
173 | < | #line 79 "MDTreeParser.g" |
173 | > | #line 78 "MDTreeParser.g" |
174 | MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp); | |
175 | < | #line 170 "MDTreeParser.cpp" |
175 | > | #line 176 "MDTreeParser.cpp" |
176 | { // ( ... )* | |
177 | for (;;) { | |
178 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 187 | Line 193 | void MDTreeParser::moleculeblock(ANTLR_USE_NAMESPACE(a | |
193 | _t = _t->getNextSibling(); | |
194 | _t = __t21; | |
195 | _t = _t->getNextSibling(); | |
196 | < | #line 81 "MDTreeParser.g" |
196 | > | #line 80 "MDTreeParser.g" |
197 | blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp); | |
198 | < | #line 193 "MDTreeParser.cpp" |
198 | > | #line 199 "MDTreeParser.cpp" |
199 | } | |
200 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
201 | reportError(ex); | |
# | Line 200 | Line 206 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC | |
206 | } | |
207 | ||
208 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
209 | < | ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
209 | > | ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
210 | ||
211 | try { // for error handling | |
212 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t17 = _t; |
212 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t13 = _t; |
213 | ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST_in = _t; | |
214 | match(_t,ZCONSTRAINT); | |
215 | _t = _t->getFirstChild(); | |
216 | < | #line 74 "MDTreeParser.g" |
216 | > | #line 68 "MDTreeParser.g" |
217 | ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp); | |
218 | < | #line 213 "MDTreeParser.cpp" |
218 | > | #line 219 "MDTreeParser.cpp" |
219 | > | { // ( ... )* |
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 | > | goto _loop15; |
229 | > | } |
230 | > | |
231 | > | } |
232 | > | _loop15:; |
233 | > | } // ( ... )* |
234 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t; |
235 | > | match(_t,ENDBLOCK); |
236 | > | _t = _t->getNextSibling(); |
237 | > | _t = __t13; |
238 | > | _t = _t->getNextSibling(); |
239 | > | #line 70 "MDTreeParser.g" |
240 | > | blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp); |
241 | > | #line 242 "MDTreeParser.cpp" |
242 | > | } |
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 | > | 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 ) | |
# | Line 225 | Line 274 | void MDTreeParser::zconstraintblock(ANTLR_USE_NAMESPAC | |
274 | } | |
275 | _loop19:; | |
276 | } // ( ... )* | |
277 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST_in = _t; |
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 76 "MDTreeParser.g" |
283 | < | blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp); |
284 | < | #line 236 "MDTreeParser.cpp" |
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); | |
# | Line 245 | Line 294 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
294 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr)RefAST _t, | |
295 | ANTLR_USE_NAMESPACE(antlr)RefAST id | |
296 | ) { | |
297 | < | ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
297 | > | ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
298 | ANTLR_USE_NAMESPACE(antlr)RefAST str1 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
299 | ANTLR_USE_NAMESPACE(antlr)RefAST str2 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
300 | + | #line 48 "MDTreeParser.g" |
301 | + | |
302 | + | int ival; |
303 | + | RealType dval; |
304 | + | |
305 | + | #line 306 "MDTreeParser.cpp" |
306 | ||
307 | try { // for error handling | |
308 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
309 | _t = ASTNULL; | |
310 | switch ( _t->getType()) { | |
311 | < | case OCTALINT: |
312 | < | case DECIMALINT: |
258 | < | case HEXADECIMALINT: |
259 | < | case FLOATONE: |
260 | < | case FLOATTWO: |
261 | < | case MINUS: |
311 | > | case NUM_INT: |
312 | > | case NUM_LONG: |
313 | { | |
314 | < | signedIntOrFloat(_t,id); |
314 | > | ival=intConst(_t); |
315 | _t = _retTree; | |
316 | + | #line 53 "MDTreeParser.g" |
317 | + | blockStack.top()->assign(id->getText(), ival); |
318 | + | #line 319 "MDTreeParser.cpp" |
319 | break; | |
320 | } | |
321 | + | case NUM_FLOAT: |
322 | + | case NUM_DOUBLE: |
323 | + | { |
324 | + | dval=floatConst(_t); |
325 | + | _t = _retTree; |
326 | + | #line 54 "MDTreeParser.g" |
327 | + | blockStack.top()->assign(id->getText(), dval); |
328 | + | #line 329 "MDTreeParser.cpp" |
329 | + | break; |
330 | + | } |
331 | case ID: | |
332 | { | |
333 | str1 = _t; | |
334 | match(_t,ID); | |
335 | _t = _t->getNextSibling(); | |
336 | < | #line 49 "MDTreeParser.g" |
336 | > | #line 55 "MDTreeParser.g" |
337 | blockStack.top()->assign(id->getText(), str1->getText()); | |
338 | < | #line 275 "MDTreeParser.cpp" |
338 | > | #line 339 "MDTreeParser.cpp" |
339 | break; | |
340 | } | |
341 | case StringLiteral: | |
# | Line 279 | Line 343 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
343 | str2 = _t; | |
344 | match(_t,StringLiteral); | |
345 | _t = _t->getNextSibling(); | |
346 | < | #line 50 "MDTreeParser.g" |
346 | > | #line 56 "MDTreeParser.g" |
347 | std::string s = str2->getText(); | |
348 | s = s.substr(1, s.length()-2); | |
349 | blockStack.top()->assign(id->getText(),s); | |
350 | ||
351 | < | #line 288 "MDTreeParser.cpp" |
351 | > | #line 352 "MDTreeParser.cpp" |
352 | break; | |
353 | } | |
354 | default: | |
# | Line 301 | Line 365 | void MDTreeParser::constant(ANTLR_USE_NAMESPACE(antlr) | |
365 | _retTree = _t; | |
366 | } | |
367 | ||
368 | < | void MDTreeParser::signedIntOrFloat(ANTLR_USE_NAMESPACE(antlr)RefAST _t, |
369 | < | ANTLR_USE_NAMESPACE(antlr)RefAST id |
306 | < | ) { |
307 | < | ANTLR_USE_NAMESPACE(antlr)RefAST signedIntOrFloat_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
308 | < | ANTLR_USE_NAMESPACE(antlr)RefAST icMinus = ANTLR_USE_NAMESPACE(antlr)nullAST; |
309 | < | ANTLR_USE_NAMESPACE(antlr)RefAST fcMinus = ANTLR_USE_NAMESPACE(antlr)nullAST; |
310 | < | ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST; |
311 | < | ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST; |
312 | < | #line 56 "MDTreeParser.g" |
313 | < | |
368 | > | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
369 | > | #line 268 "MDTreeParser.g" |
370 | int ival; | |
371 | < | double dval; |
371 | > | #line 372 "MDTreeParser.cpp" |
372 | > | ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
373 | > | ANTLR_USE_NAMESPACE(antlr)RefAST i1 = ANTLR_USE_NAMESPACE(antlr)nullAST; |
374 | > | ANTLR_USE_NAMESPACE(antlr)RefAST i2 = ANTLR_USE_NAMESPACE(antlr)nullAST; |
375 | ||
317 | – | #line 318 "MDTreeParser.cpp" |
318 | – | |
376 | try { // for error handling | |
377 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
378 | _t = ASTNULL; | |
379 | switch ( _t->getType()) { | |
380 | < | case MINUS: |
380 | > | case NUM_INT: |
381 | { | |
382 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t9 = _t; |
383 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp8_AST_in = _t; |
327 | < | match(_t,MINUS); |
328 | < | _t = _t->getFirstChild(); |
329 | < | { |
330 | < | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
331 | < | _t = ASTNULL; |
332 | < | switch ( _t->getType()) { |
333 | < | case OCTALINT: |
334 | < | case DECIMALINT: |
335 | < | case HEXADECIMALINT: |
336 | < | { |
337 | < | icMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
338 | < | intConst(_t); |
339 | < | _t = _retTree; |
340 | < | #line 61 "MDTreeParser.g" |
341 | < | ival = lexi_cast<int>(icMinus->getText()); ival = -ival; blockStack.top()->assign(id->getText(), ival); |
342 | < | #line 343 "MDTreeParser.cpp" |
343 | < | break; |
344 | < | } |
345 | < | case FLOATONE: |
346 | < | case FLOATTWO: |
347 | < | { |
348 | < | fcMinus = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
349 | < | floatConst(_t); |
350 | < | _t = _retTree; |
351 | < | break; |
352 | < | } |
353 | < | default: |
354 | < | { |
355 | < | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); |
356 | < | } |
357 | < | } |
358 | < | } |
359 | < | #line 62 "MDTreeParser.g" |
360 | < | dval = lexi_cast<double>(fcMinus->getText());dval = -dval; blockStack.top()->assign(id->getText(), dval); |
361 | < | #line 362 "MDTreeParser.cpp" |
362 | < | _t = __t9; |
382 | > | i1 = _t; |
383 | > | match(_t,NUM_INT); |
384 | _t = _t->getNextSibling(); | |
385 | + | #line 269 "MDTreeParser.g" |
386 | + | ival = lexi_cast<int>(i1->getText()); |
387 | + | #line 388 "MDTreeParser.cpp" |
388 | break; | |
389 | } | |
390 | < | case OCTALINT: |
367 | < | case DECIMALINT: |
368 | < | case HEXADECIMALINT: |
369 | < | case FLOATONE: |
370 | < | case FLOATTWO: |
390 | > | case NUM_LONG: |
391 | { | |
392 | < | { |
393 | < | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
374 | < | _t = ASTNULL; |
375 | < | switch ( _t->getType()) { |
376 | < | case OCTALINT: |
377 | < | case DECIMALINT: |
378 | < | case HEXADECIMALINT: |
379 | < | { |
380 | < | ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
381 | < | intConst(_t); |
382 | < | _t = _retTree; |
383 | < | #line 64 "MDTreeParser.g" |
384 | < | ival = lexi_cast<int>(ic->getText()); blockStack.top()->assign(id->getText(), ival); |
385 | < | #line 386 "MDTreeParser.cpp" |
386 | < | break; |
387 | < | } |
388 | < | case FLOATONE: |
389 | < | case FLOATTWO: |
390 | < | { |
391 | < | fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
392 | < | floatConst(_t); |
393 | < | _t = _retTree; |
394 | < | #line 65 "MDTreeParser.g" |
395 | < | dval = lexi_cast<double>(fc->getText()); blockStack.top()->assign(id->getText(), dval); |
396 | < | #line 397 "MDTreeParser.cpp" |
397 | < | break; |
398 | < | } |
399 | < | default: |
400 | < | { |
401 | < | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); |
402 | < | } |
403 | < | } |
404 | < | } |
405 | < | break; |
406 | < | } |
407 | < | default: |
408 | < | { |
409 | < | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); |
410 | < | } |
411 | < | } |
412 | < | } |
413 | < | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
414 | < | reportError(ex); |
415 | < | if ( _t != ANTLR_USE_NAMESPACE(antlr)nullAST ) |
392 | > | i2 = _t; |
393 | > | match(_t,NUM_LONG); |
394 | _t = _t->getNextSibling(); | |
395 | < | } |
396 | < | _retTree = _t; |
397 | < | } |
420 | < | |
421 | < | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
422 | < | #line 249 "MDTreeParser.g" |
423 | < | int ival; |
424 | < | #line 425 "MDTreeParser.cpp" |
425 | < | ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
426 | < | ANTLR_USE_NAMESPACE(antlr)RefAST oival = ANTLR_USE_NAMESPACE(antlr)nullAST; |
427 | < | ANTLR_USE_NAMESPACE(antlr)RefAST dival = ANTLR_USE_NAMESPACE(antlr)nullAST; |
428 | < | ANTLR_USE_NAMESPACE(antlr)RefAST hival = ANTLR_USE_NAMESPACE(antlr)nullAST; |
429 | < | |
430 | < | try { // for error handling |
431 | < | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) |
432 | < | _t = ASTNULL; |
433 | < | switch ( _t->getType()) { |
434 | < | case OCTALINT: |
435 | < | { |
436 | < | oival = _t; |
437 | < | match(_t,OCTALINT); |
438 | < | _t = _t->getNextSibling(); |
439 | < | #line 250 "MDTreeParser.g" |
440 | < | ival = lexi_cast<int>(oival->getText()); |
441 | < | #line 442 "MDTreeParser.cpp" |
395 | > | #line 270 "MDTreeParser.g" |
396 | > | ival = lexi_cast<int>(i2->getText()); |
397 | > | #line 398 "MDTreeParser.cpp" |
398 | break; | |
399 | } | |
444 | – | case DECIMALINT: |
445 | – | { |
446 | – | dival = _t; |
447 | – | match(_t,DECIMALINT); |
448 | – | _t = _t->getNextSibling(); |
449 | – | #line 251 "MDTreeParser.g" |
450 | – | ival = lexi_cast<int>(dival->getText()); |
451 | – | #line 452 "MDTreeParser.cpp" |
452 | – | break; |
453 | – | } |
454 | – | case HEXADECIMALINT: |
455 | – | { |
456 | – | hival = _t; |
457 | – | match(_t,HEXADECIMALINT); |
458 | – | _t = _t->getNextSibling(); |
459 | – | #line 252 "MDTreeParser.g" |
460 | – | ival = lexi_cast<int>(hival->getText()); |
461 | – | #line 462 "MDTreeParser.cpp" |
462 | – | break; |
463 | – | } |
400 | default: | |
401 | { | |
402 | throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t); | |
# | Line 476 | Line 412 | int MDTreeParser::intConst(ANTLR_USE_NAMESPACE(antlr) | |
412 | return ival; | |
413 | } | |
414 | ||
415 | < | double MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
416 | < | #line 264 "MDTreeParser.g" |
417 | < | double dval; |
418 | < | #line 483 "MDTreeParser.cpp" |
419 | < | ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
415 | > | RealType MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
416 | > | #line 282 "MDTreeParser.g" |
417 | > | RealType dval; |
418 | > | #line 419 "MDTreeParser.cpp" |
419 | > | ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
420 | ANTLR_USE_NAMESPACE(antlr)RefAST d1 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
421 | ANTLR_USE_NAMESPACE(antlr)RefAST d2 = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
422 | ||
# | Line 488 | Line 424 | double MDTreeParser::floatConst(ANTLR_USE_NAMESPACE(a | |
424 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
425 | _t = ASTNULL; | |
426 | switch ( _t->getType()) { | |
427 | < | case FLOATONE: |
427 | > | case NUM_FLOAT: |
428 | { | |
429 | d1 = _t; | |
430 | < | match(_t,FLOATONE); |
430 | > | match(_t,NUM_FLOAT); |
431 | _t = _t->getNextSibling(); | |
432 | < | #line 265 "MDTreeParser.g" |
433 | < | dval = lexi_cast<double>(d1->getText()); |
434 | < | #line 499 "MDTreeParser.cpp" |
432 | > | #line 283 "MDTreeParser.g" |
433 | > | dval = lexi_cast<RealType>(d1->getText()); |
434 | > | #line 435 "MDTreeParser.cpp" |
435 | break; | |
436 | } | |
437 | < | case FLOATTWO: |
437 | > | case NUM_DOUBLE: |
438 | { | |
439 | d2 = _t; | |
440 | < | match(_t,FLOATTWO); |
440 | > | match(_t,NUM_DOUBLE); |
441 | _t = _t->getNextSibling(); | |
442 | < | #line 266 "MDTreeParser.g" |
443 | < | dval = lexi_cast<double>(d2->getText()); |
444 | < | #line 509 "MDTreeParser.cpp" |
442 | > | #line 284 "MDTreeParser.g" |
443 | > | dval = lexi_cast<RealType>(d2->getText()); |
444 | > | #line 445 "MDTreeParser.cpp" |
445 | break; | |
446 | } | |
447 | default: | |
# | Line 524 | Line 460 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA | |
460 | } | |
461 | ||
462 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
463 | < | ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
463 | > | ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
464 | ||
465 | try { // for error handling | |
466 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 560 | Line 496 | void MDTreeParser::moleculestatement(ANTLR_USE_NAMESPA | |
496 | _t = _retTree; | |
497 | break; | |
498 | } | |
499 | + | case INVERSION: |
500 | + | { |
501 | + | inversionblock(_t); |
502 | + | _t = _retTree; |
503 | + | break; |
504 | + | } |
505 | case RIGIDBODY: | |
506 | { | |
507 | rigidbodyblock(_t); | |
# | Line 593 | Line 535 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr | |
535 | } | |
536 | ||
537 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
538 | < | ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
538 | > | ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
539 | #line 94 "MDTreeParser.g" | |
540 | ||
541 | int index; | |
542 | ||
543 | < | #line 602 "MDTreeParser.cpp" |
543 | > | #line 544 "MDTreeParser.cpp" |
544 | ||
545 | try { // for error handling | |
546 | ANTLR_USE_NAMESPACE(antlr)RefAST __t26 = _t; | |
547 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST_in = _t; |
547 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t; |
548 | match(_t,ATOM); | |
549 | _t = _t->getFirstChild(); | |
550 | index=intConst(_t); | |
551 | _t = _retTree; | |
552 | #line 98 "MDTreeParser.g" | |
553 | AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp); | |
554 | < | #line 613 "MDTreeParser.cpp" |
554 | > | #line 555 "MDTreeParser.cpp" |
555 | { // ( ... )* | |
556 | for (;;) { | |
557 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 625 | Line 567 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr | |
567 | } | |
568 | _loop28:; | |
569 | } // ( ... )* | |
570 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST_in = _t; |
570 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t; |
571 | match(_t,ENDBLOCK); | |
572 | _t = _t->getNextSibling(); | |
573 | _t = __t26; | |
# | Line 637 | Line 579 | void MDTreeParser::atomblock(ANTLR_USE_NAMESPACE(antlr | |
579 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
580 | currMoleculeStamp->addAtomStamp(currAtomStamp); | |
581 | ||
582 | < | #line 641 "MDTreeParser.cpp" |
582 | > | #line 583 "MDTreeParser.cpp" |
583 | } | |
584 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
585 | reportError(ex); | |
# | Line 648 | Line 590 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr | |
590 | } | |
591 | ||
592 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
593 | < | ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
593 | > | ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
594 | ||
595 | try { // for error handling | |
596 | ANTLR_USE_NAMESPACE(antlr)RefAST __t33 = _t; | |
597 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp11_AST_in = _t; |
597 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t; |
598 | match(_t,BOND); | |
599 | _t = _t->getFirstChild(); | |
600 | #line 120 "MDTreeParser.g" | |
601 | BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp); | |
602 | < | #line 661 "MDTreeParser.cpp" |
602 | > | #line 603 "MDTreeParser.cpp" |
603 | { // ( ... )* | |
604 | for (;;) { | |
605 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 673 | Line 615 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr | |
615 | } | |
616 | _loop35:; | |
617 | } // ( ... )* | |
618 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST_in = _t; |
618 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t; |
619 | match(_t,ENDBLOCK); | |
620 | _t = _t->getNextSibling(); | |
621 | _t = __t33; | |
# | Line 684 | Line 626 | void MDTreeParser::bondblock(ANTLR_USE_NAMESPACE(antlr | |
626 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
627 | currMoleculeStamp->addBondStamp(currBondStamp); | |
628 | ||
629 | < | #line 688 "MDTreeParser.cpp" |
629 | > | #line 630 "MDTreeParser.cpp" |
630 | } | |
631 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
632 | reportError(ex); | |
# | Line 695 | Line 637 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr | |
637 | } | |
638 | ||
639 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
640 | < | ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
640 | > | ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
641 | ||
642 | try { // for error handling | |
643 | ANTLR_USE_NAMESPACE(antlr)RefAST __t39 = _t; | |
644 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST_in = _t; |
644 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t; |
645 | match(_t,BEND); | |
646 | _t = _t->getFirstChild(); | |
647 | #line 138 "MDTreeParser.g" | |
648 | BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp); | |
649 | < | #line 708 "MDTreeParser.cpp" |
649 | > | #line 650 "MDTreeParser.cpp" |
650 | { // ( ... )* | |
651 | for (;;) { | |
652 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 720 | Line 662 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr | |
662 | } | |
663 | _loop41:; | |
664 | } // ( ... )* | |
665 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST_in = _t; |
665 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t; |
666 | match(_t,ENDBLOCK); | |
667 | _t = _t->getNextSibling(); | |
668 | _t = __t39; | |
# | Line 732 | Line 674 | void MDTreeParser::bendblock(ANTLR_USE_NAMESPACE(antlr | |
674 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
675 | currMoleculeStamp->addBendStamp(currBendStamp); | |
676 | ||
677 | < | #line 736 "MDTreeParser.cpp" |
677 | > | #line 678 "MDTreeParser.cpp" |
678 | } | |
679 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
680 | reportError(ex); | |
# | Line 743 | Line 685 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
685 | } | |
686 | ||
687 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
688 | < | ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
688 | > | ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
689 | ||
690 | try { // for error handling | |
691 | ANTLR_USE_NAMESPACE(antlr)RefAST __t45 = _t; | |
692 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST_in = _t; |
692 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t; |
693 | match(_t,TORSION); | |
694 | _t = _t->getFirstChild(); | |
695 | #line 157 "MDTreeParser.g" | |
696 | TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp); | |
697 | < | #line 756 "MDTreeParser.cpp" |
697 | > | #line 698 "MDTreeParser.cpp" |
698 | { // ( ... )* | |
699 | for (;;) { | |
700 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 768 | Line 710 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
710 | } | |
711 | _loop47:; | |
712 | } // ( ... )* | |
713 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST_in = _t; |
713 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t; |
714 | match(_t,ENDBLOCK); | |
715 | _t = _t->getNextSibling(); | |
716 | _t = __t45; | |
# | Line 780 | Line 722 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
722 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
723 | currMoleculeStamp->addTorsionStamp(currTorsionStamp); | |
724 | ||
725 | < | #line 784 "MDTreeParser.cpp" |
725 | > | #line 726 "MDTreeParser.cpp" |
726 | } | |
727 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
728 | reportError(ex); | |
# | Line 790 | Line 732 | void MDTreeParser::torsionblock(ANTLR_USE_NAMESPACE(an | |
732 | _retTree = _t; | |
733 | } | |
734 | ||
735 | < | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
736 | < | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
795 | < | #line 176 "MDTreeParser.g" |
735 | > | void MDTreeParser::inversionblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
736 | > | ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
737 | ||
797 | – | int index; |
798 | – | |
799 | – | #line 800 "MDTreeParser.cpp" |
800 | – | |
738 | try { // for error handling | |
739 | ANTLR_USE_NAMESPACE(antlr)RefAST __t51 = _t; | |
740 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST_in = _t; |
741 | < | match(_t,RIGIDBODY); |
740 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t; |
741 | > | match(_t,INVERSION); |
742 | _t = _t->getFirstChild(); | |
743 | < | index=intConst(_t); |
744 | < | _t = _retTree; |
745 | < | #line 180 "MDTreeParser.g" |
809 | < | RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp); |
810 | < | #line 811 "MDTreeParser.cpp" |
743 | > | #line 176 "MDTreeParser.g" |
744 | > | InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp); |
745 | > | #line 746 "MDTreeParser.cpp" |
746 | { // ( ... )* | |
747 | for (;;) { | |
748 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
749 | _t = ASTNULL; | |
750 | < | if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) { |
751 | < | rigidbodystatement(_t); |
750 | > | if ((_t->getType() == CENTER || _t->getType() == ASSIGNEQUAL)) { |
751 | > | inversionstatement(_t); |
752 | _t = _retTree; | |
753 | } | |
754 | else { | |
# | Line 823 | Line 758 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE( | |
758 | } | |
759 | _loop53:; | |
760 | } // ( ... )* | |
761 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST_in = _t; |
761 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t; |
762 | match(_t,ENDBLOCK); | |
763 | _t = _t->getNextSibling(); | |
764 | _t = __t51; | |
765 | _t = _t->getNextSibling(); | |
766 | < | #line 182 "MDTreeParser.g" |
766 | > | #line 178 "MDTreeParser.g" |
767 | ||
768 | blockStack.top()->validate(); | |
769 | blockStack.pop(); | |
770 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
771 | < | currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); |
771 | > | currMoleculeStamp->addInversionStamp(currInversionStamp); |
772 | ||
773 | < | #line 839 "MDTreeParser.cpp" |
773 | > | #line 774 "MDTreeParser.cpp" |
774 | } | |
775 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
776 | reportError(ex); | |
# | Line 845 | Line 780 | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE( | |
780 | _retTree = _t; | |
781 | } | |
782 | ||
783 | < | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
784 | < | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
783 | > | void MDTreeParser::rigidbodyblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
784 | > | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
785 | > | #line 195 "MDTreeParser.g" |
786 | ||
787 | + | int index; |
788 | + | |
789 | + | #line 790 "MDTreeParser.cpp" |
790 | + | |
791 | try { // for error handling | |
792 | ANTLR_USE_NAMESPACE(antlr)RefAST __t57 = _t; | |
793 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST_in = _t; |
794 | < | match(_t,CUTOFFGROUP); |
793 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t; |
794 | > | match(_t,RIGIDBODY); |
795 | _t = _t->getFirstChild(); | |
796 | + | index=intConst(_t); |
797 | + | _t = _retTree; |
798 | #line 199 "MDTreeParser.g" | |
799 | < | CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp); |
800 | < | #line 859 "MDTreeParser.cpp" |
799 | > | RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp); |
800 | > | #line 801 "MDTreeParser.cpp" |
801 | { // ( ... )* | |
802 | for (;;) { | |
803 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
804 | _t = ASTNULL; | |
805 | if ((_t->getType() == MEMBERS || _t->getType() == ASSIGNEQUAL)) { | |
806 | < | cutoffgroupstatement(_t); |
806 | > | rigidbodystatement(_t); |
807 | _t = _retTree; | |
808 | } | |
809 | else { | |
# | Line 871 | Line 813 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC | |
813 | } | |
814 | _loop59:; | |
815 | } // ( ... )* | |
816 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST_in = _t; |
816 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t; |
817 | match(_t,ENDBLOCK); | |
818 | _t = _t->getNextSibling(); | |
819 | _t = __t57; | |
# | Line 881 | Line 823 | void MDTreeParser::cutoffgroupblock(ANTLR_USE_NAMESPAC | |
823 | blockStack.top()->validate(); | |
824 | blockStack.pop(); | |
825 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
826 | + | currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); |
827 | + | |
828 | + | #line 829 "MDTreeParser.cpp" |
829 | + | } |
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 | + | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
840 | + | |
841 | + | try { // for error handling |
842 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t; |
843 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t; |
844 | + | match(_t,CUTOFFGROUP); |
845 | + | _t = _t->getFirstChild(); |
846 | + | #line 218 "MDTreeParser.g" |
847 | + | CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp); |
848 | + | #line 849 "MDTreeParser.cpp" |
849 | + | { // ( ... )* |
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 | + | goto _loop65; |
859 | + | } |
860 | + | |
861 | + | } |
862 | + | _loop65:; |
863 | + | } // ( ... )* |
864 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t; |
865 | + | match(_t,ENDBLOCK); |
866 | + | _t = _t->getNextSibling(); |
867 | + | _t = __t63; |
868 | + | _t = _t->getNextSibling(); |
869 | + | #line 220 "MDTreeParser.g" |
870 | + | |
871 | + | blockStack.top()->validate(); |
872 | + | blockStack.pop(); |
873 | + | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); |
874 | currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); | |
875 | ||
876 | < | #line 887 "MDTreeParser.cpp" |
876 | > | #line 877 "MDTreeParser.cpp" |
877 | } | |
878 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
879 | reportError(ex); | |
# | Line 894 | Line 884 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a | |
884 | } | |
885 | ||
886 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
887 | < | ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
888 | < | #line 218 "MDTreeParser.g" |
887 | > | ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
888 | > | #line 237 "MDTreeParser.g" |
889 | int ival; | |
890 | < | #line 901 "MDTreeParser.cpp" |
890 | > | #line 891 "MDTreeParser.cpp" |
891 | ||
892 | try { // for error handling | |
893 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t63 = _t; |
894 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST_in = _t; |
893 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t69 = _t; |
894 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t; |
895 | match(_t,FRAGMENT); | |
896 | _t = _t->getFirstChild(); | |
897 | ival=intConst(_t); | |
898 | _t = _retTree; | |
899 | < | #line 219 "MDTreeParser.g" |
899 | > | #line 238 "MDTreeParser.g" |
900 | FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp); | |
901 | < | #line 912 "MDTreeParser.cpp" |
901 | > | #line 902 "MDTreeParser.cpp" |
902 | { // ( ... )* | |
903 | for (;;) { | |
904 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 918 | Line 908 | void MDTreeParser::fragmentblock(ANTLR_USE_NAMESPACE(a | |
908 | _t = _retTree; | |
909 | } | |
910 | else { | |
911 | < | goto _loop65; |
911 | > | goto _loop71; |
912 | } | |
913 | ||
914 | } | |
915 | < | _loop65:; |
915 | > | _loop71:; |
916 | } // ( ... )* | |
917 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST_in = _t; |
917 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t; |
918 | match(_t,ENDBLOCK); | |
919 | _t = _t->getNextSibling(); | |
920 | < | _t = __t63; |
920 | > | _t = __t69; |
921 | _t = _t->getNextSibling(); | |
922 | < | #line 221 "MDTreeParser.g" |
922 | > | #line 240 "MDTreeParser.g" |
923 | ||
924 | blockStack.top()->validate(); | |
925 | blockStack.pop(); | |
926 | MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top()); | |
927 | currMoleculeStamp->addFragmentStamp(currFragmentStamp); | |
928 | ||
929 | < | #line 940 "MDTreeParser.cpp" |
929 | > | #line 930 "MDTreeParser.cpp" |
930 | } | |
931 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
932 | reportError(ex); | |
# | Line 947 | Line 937 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a | |
937 | } | |
938 | ||
939 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
940 | < | ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
940 | > | ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
941 | #line 108 "MDTreeParser.g" | |
942 | ||
943 | < | vector<double> dvec; |
943 | > | vector<RealType> dvec; |
944 | AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top()); | |
945 | ||
946 | ||
947 | < | #line 958 "MDTreeParser.cpp" |
947 | > | #line 948 "MDTreeParser.cpp" |
948 | ||
949 | try { // for error handling | |
950 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 969 | Line 959 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a | |
959 | case POSITION: | |
960 | { | |
961 | ANTLR_USE_NAMESPACE(antlr)RefAST __t30 = _t; | |
962 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST_in = _t; |
962 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t; |
963 | match(_t,POSITION); | |
964 | _t = _t->getFirstChild(); | |
965 | < | dvec=signedNumberTuple(_t); |
965 | > | dvec=doubleNumberTuple(_t); |
966 | _t = _retTree; | |
967 | _t = __t30; | |
968 | _t = _t->getNextSibling(); | |
969 | #line 115 "MDTreeParser.g" | |
970 | currAtomStamp->setPosition(dvec); | |
971 | < | #line 982 "MDTreeParser.cpp" |
971 | > | #line 972 "MDTreeParser.cpp" |
972 | break; | |
973 | } | |
974 | case ORIENTATION: | |
975 | { | |
976 | ANTLR_USE_NAMESPACE(antlr)RefAST __t31 = _t; | |
977 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST_in = _t; |
977 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t; |
978 | match(_t,ORIENTATION); | |
979 | _t = _t->getFirstChild(); | |
980 | < | dvec=signedNumberTuple(_t); |
980 | > | dvec=doubleNumberTuple(_t); |
981 | _t = _retTree; | |
982 | _t = __t31; | |
983 | _t = _t->getNextSibling(); | |
984 | #line 116 "MDTreeParser.g" | |
985 | currAtomStamp->setOrientation(dvec); | |
986 | < | #line 997 "MDTreeParser.cpp" |
986 | > | #line 987 "MDTreeParser.cpp" |
987 | break; | |
988 | } | |
989 | default: | |
# | Line 1010 | Line 1000 | void MDTreeParser::atomstatement(ANTLR_USE_NAMESPACE(a | |
1000 | _retTree = _t; | |
1001 | } | |
1002 | ||
1003 | < | vector<double> MDTreeParser::signedNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1004 | < | #line 234 "MDTreeParser.g" |
1005 | < | vector<double> dvec; |
1006 | < | #line 1017 "MDTreeParser.cpp" |
1007 | < | ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1008 | < | #line 234 "MDTreeParser.g" |
1003 | > | vector<RealType> MDTreeParser::doubleNumberTuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1004 | > | #line 253 "MDTreeParser.g" |
1005 | > | vector<RealType> dvec; |
1006 | > | #line 1007 "MDTreeParser.cpp" |
1007 | > | ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumberTuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1008 | > | #line 253 "MDTreeParser.g" |
1009 | ||
1010 | < | double dval; |
1010 | > | RealType dval; |
1011 | ||
1012 | < | #line 1023 "MDTreeParser.cpp" |
1012 | > | #line 1013 "MDTreeParser.cpp" |
1013 | ||
1014 | try { // for error handling | |
1015 | { // ( ... )+ | |
1016 | < | int _cnt69=0; |
1016 | > | int _cnt75=0; |
1017 | for (;;) { | |
1018 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1019 | _t = ASTNULL; | |
1020 | < | if (((_t->getType() >= OCTALINT && _t->getType() <= FLOATTWO))) { |
1021 | < | dval=signedNumber(_t); |
1020 | > | if (((_t->getType() >= NUM_INT && _t->getType() <= NUM_DOUBLE))) { |
1021 | > | dval=doubleNumber(_t); |
1022 | _t = _retTree; | |
1023 | < | #line 238 "MDTreeParser.g" |
1023 | > | #line 257 "MDTreeParser.g" |
1024 | dvec.push_back(dval); | |
1025 | < | #line 1036 "MDTreeParser.cpp" |
1025 | > | #line 1026 "MDTreeParser.cpp" |
1026 | } | |
1027 | else { | |
1028 | < | if ( _cnt69>=1 ) { goto _loop69; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1028 | > | if ( _cnt75>=1 ) { goto _loop75; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1029 | } | |
1030 | ||
1031 | < | _cnt69++; |
1031 | > | _cnt75++; |
1032 | } | |
1033 | < | _loop69:; |
1033 | > | _loop75:; |
1034 | } // ( ... )+ | |
1035 | } | |
1036 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
# | Line 1053 | Line 1043 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a | |
1043 | } | |
1044 | ||
1045 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1046 | < | ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1046 | > | ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1047 | #line 129 "MDTreeParser.g" | |
1048 | ||
1049 | vector<int> ivec; | |
1050 | BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top()); | |
1051 | ||
1052 | < | #line 1063 "MDTreeParser.cpp" |
1052 | > | #line 1053 "MDTreeParser.cpp" |
1053 | ||
1054 | try { // for error handling | |
1055 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1074 | Line 1064 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a | |
1064 | case MEMBERS: | |
1065 | { | |
1066 | ANTLR_USE_NAMESPACE(antlr)RefAST __t37 = _t; | |
1067 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST_in = _t; |
1067 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t; |
1068 | match(_t,MEMBERS); | |
1069 | _t = _t->getFirstChild(); | |
1070 | ivec=inttuple(_t); | |
# | Line 1083 | Line 1073 | void MDTreeParser::bondstatement(ANTLR_USE_NAMESPACE(a | |
1073 | _t = _t->getNextSibling(); | |
1074 | #line 135 "MDTreeParser.g" | |
1075 | currBondStamp->setMembers(ivec); | |
1076 | < | #line 1087 "MDTreeParser.cpp" |
1076 | > | #line 1077 "MDTreeParser.cpp" |
1077 | break; | |
1078 | } | |
1079 | default: | |
# | Line 1101 | Line 1091 | vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPAC | |
1091 | } | |
1092 | ||
1093 | vector<int> MDTreeParser::inttuple(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1094 | < | #line 241 "MDTreeParser.g" |
1094 | > | #line 260 "MDTreeParser.g" |
1095 | vector<int> ivec; | |
1096 | < | #line 1107 "MDTreeParser.cpp" |
1097 | < | ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1098 | < | #line 241 "MDTreeParser.g" |
1096 | > | #line 1097 "MDTreeParser.cpp" |
1097 | > | ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1098 | > | #line 260 "MDTreeParser.g" |
1099 | ||
1100 | int ival; | |
1101 | ||
1102 | < | #line 1113 "MDTreeParser.cpp" |
1102 | > | #line 1103 "MDTreeParser.cpp" |
1103 | ||
1104 | try { // for error handling | |
1105 | { // ( ... )+ | |
1106 | < | int _cnt72=0; |
1106 | > | int _cnt78=0; |
1107 | for (;;) { | |
1108 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1109 | _t = ASTNULL; | |
1110 | < | if (((_t->getType() >= OCTALINT && _t->getType() <= HEXADECIMALINT))) { |
1110 | > | if ((_t->getType() == NUM_INT || _t->getType() == NUM_LONG)) { |
1111 | ival=intConst(_t); | |
1112 | _t = _retTree; | |
1113 | < | #line 245 "MDTreeParser.g" |
1113 | > | #line 264 "MDTreeParser.g" |
1114 | ivec.push_back(ival); | |
1115 | < | #line 1126 "MDTreeParser.cpp" |
1115 | > | #line 1116 "MDTreeParser.cpp" |
1116 | } | |
1117 | else { | |
1118 | < | if ( _cnt72>=1 ) { goto _loop72; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1118 | > | if ( _cnt78>=1 ) { goto _loop78; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(_t);} |
1119 | } | |
1120 | ||
1121 | < | _cnt72++; |
1121 | > | _cnt78++; |
1122 | } | |
1123 | < | _loop72:; |
1123 | > | _loop78:; |
1124 | } // ( ... )+ | |
1125 | } | |
1126 | catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { | |
# | Line 1143 | Line 1133 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a | |
1133 | } | |
1134 | ||
1135 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1136 | < | ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1136 | > | ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1137 | #line 148 "MDTreeParser.g" | |
1138 | ||
1139 | vector<int> ivec; | |
1140 | BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top()); | |
1141 | ||
1142 | < | #line 1153 "MDTreeParser.cpp" |
1142 | > | #line 1143 "MDTreeParser.cpp" |
1143 | ||
1144 | try { // for error handling | |
1145 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1164 | Line 1154 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a | |
1154 | case MEMBERS: | |
1155 | { | |
1156 | ANTLR_USE_NAMESPACE(antlr)RefAST __t43 = _t; | |
1157 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST_in = _t; |
1157 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t; |
1158 | match(_t,MEMBERS); | |
1159 | _t = _t->getFirstChild(); | |
1160 | ivec=inttuple(_t); | |
# | Line 1173 | Line 1163 | void MDTreeParser::bendstatement(ANTLR_USE_NAMESPACE(a | |
1163 | _t = _t->getNextSibling(); | |
1164 | #line 154 "MDTreeParser.g" | |
1165 | currBendStamp->setMembers(ivec); | |
1166 | < | #line 1177 "MDTreeParser.cpp" |
1166 | > | #line 1167 "MDTreeParser.cpp" |
1167 | break; | |
1168 | } | |
1169 | default: | |
# | Line 1191 | Line 1181 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1181 | } | |
1182 | ||
1183 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1184 | < | ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1184 | > | ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1185 | #line 167 "MDTreeParser.g" | |
1186 | ||
1187 | vector<int> ivec; | |
1188 | TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top()); | |
1189 | ||
1190 | < | #line 1201 "MDTreeParser.cpp" |
1190 | > | #line 1191 "MDTreeParser.cpp" |
1191 | ||
1192 | try { // for error handling | |
1193 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1212 | Line 1202 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1202 | case MEMBERS: | |
1203 | { | |
1204 | ANTLR_USE_NAMESPACE(antlr)RefAST __t49 = _t; | |
1205 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST_in = _t; |
1205 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST_in = _t; |
1206 | match(_t,MEMBERS); | |
1207 | _t = _t->getFirstChild(); | |
1208 | ivec=inttuple(_t); | |
# | Line 1221 | Line 1211 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1211 | _t = _t->getNextSibling(); | |
1212 | #line 173 "MDTreeParser.g" | |
1213 | currTorsionStamp->setMembers(ivec); | |
1214 | < | #line 1225 "MDTreeParser.cpp" |
1214 | > | #line 1215 "MDTreeParser.cpp" |
1215 | break; | |
1216 | } | |
1217 | default: | |
# | Line 1238 | Line 1228 | void MDTreeParser::torsionstatement(ANTLR_USE_NAMESPAC | |
1228 | _retTree = _t; | |
1229 | } | |
1230 | ||
1231 | + | void MDTreeParser::inversionstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1232 | + | ANTLR_USE_NAMESPACE(antlr)RefAST inversionstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1233 | + | #line 186 "MDTreeParser.g" |
1234 | + | |
1235 | + | int icent; |
1236 | + | InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top()); |
1237 | + | |
1238 | + | #line 1239 "MDTreeParser.cpp" |
1239 | + | |
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 | + | ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t; |
1253 | + | ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST_in = _t; |
1254 | + | match(_t,CENTER); |
1255 | + | _t = _t->getFirstChild(); |
1256 | + | icent=intConst(_t); |
1257 | + | _t = _retTree; |
1258 | + | _t = __t55; |
1259 | + | _t = _t->getNextSibling(); |
1260 | + | #line 192 "MDTreeParser.g" |
1261 | + | currInversionStamp->setCenter(icent); |
1262 | + | #line 1263 "MDTreeParser.cpp" |
1263 | + | 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 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1280 | < | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1281 | < | #line 190 "MDTreeParser.g" |
1280 | > | ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1281 | > | #line 209 "MDTreeParser.g" |
1282 | ||
1283 | vector<int> ivec; | |
1284 | RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top()); | |
1285 | ||
1286 | < | #line 1249 "MDTreeParser.cpp" |
1286 | > | #line 1287 "MDTreeParser.cpp" |
1287 | ||
1288 | try { // for error handling | |
1289 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1259 | Line 1297 | void MDTreeParser::rigidbodystatement(ANTLR_USE_NAMESP | |
1297 | } | |
1298 | case MEMBERS: | |
1299 | { | |
1300 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t55 = _t; |
1301 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST_in = _t; |
1300 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t; |
1301 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST_in = _t; |
1302 | match(_t,MEMBERS); | |
1303 | _t = _t->getFirstChild(); | |
1304 | ivec=inttuple(_t); | |
1305 | _t = _retTree; | |
1306 | < | _t = __t55; |
1306 | > | _t = __t61; |
1307 | _t = _t->getNextSibling(); | |
1308 | < | #line 196 "MDTreeParser.g" |
1308 | > | #line 215 "MDTreeParser.g" |
1309 | currRigidBodyStamp->setMembers(ivec); | |
1310 | < | #line 1273 "MDTreeParser.cpp" |
1310 | > | #line 1311 "MDTreeParser.cpp" |
1311 | break; | |
1312 | } | |
1313 | default: | |
# | Line 1287 | Line 1325 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME | |
1325 | } | |
1326 | ||
1327 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1328 | < | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1329 | < | #line 209 "MDTreeParser.g" |
1328 | > | ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1329 | > | #line 228 "MDTreeParser.g" |
1330 | ||
1331 | vector<int> ivec; | |
1332 | CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top()); | |
1333 | ||
1334 | < | #line 1297 "MDTreeParser.cpp" |
1334 | > | #line 1335 "MDTreeParser.cpp" |
1335 | ||
1336 | try { // for error handling | |
1337 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
# | Line 1307 | Line 1345 | void MDTreeParser::cutoffgroupstatement(ANTLR_USE_NAME | |
1345 | } | |
1346 | case MEMBERS: | |
1347 | { | |
1348 | < | ANTLR_USE_NAMESPACE(antlr)RefAST __t61 = _t; |
1349 | < | ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST_in = _t; |
1348 | > | ANTLR_USE_NAMESPACE(antlr)RefAST __t67 = _t; |
1349 | > | ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST_in = _t; |
1350 | match(_t,MEMBERS); | |
1351 | _t = _t->getFirstChild(); | |
1352 | ivec=inttuple(_t); | |
1353 | _t = _retTree; | |
1354 | < | _t = __t61; |
1354 | > | _t = __t67; |
1355 | _t = _t->getNextSibling(); | |
1356 | < | #line 215 "MDTreeParser.g" |
1356 | > | #line 234 "MDTreeParser.g" |
1357 | currCutoffGroupStamp->setMembers(ivec); | |
1358 | < | #line 1321 "MDTreeParser.cpp" |
1358 | > | #line 1359 "MDTreeParser.cpp" |
1359 | break; | |
1360 | } | |
1361 | default: | |
# | Line 1335 | Line 1373 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA | |
1373 | } | |
1374 | ||
1375 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { | |
1376 | < | ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1376 | > | ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1377 | ||
1378 | try { // for error handling | |
1379 | assignment(_t); | |
# | Line 1349 | Line 1387 | void MDTreeParser::fragmentstatement(ANTLR_USE_NAMESPA | |
1387 | _retTree = _t; | |
1388 | } | |
1389 | ||
1390 | < | double MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1391 | < | #line 256 "MDTreeParser.g" |
1392 | < | double dval; |
1393 | < | #line 1356 "MDTreeParser.cpp" |
1394 | < | ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST_in = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1390 | > | RealType MDTreeParser::doubleNumber(ANTLR_USE_NAMESPACE(antlr)RefAST _t) { |
1391 | > | #line 274 "MDTreeParser.g" |
1392 | > | RealType dval; |
1393 | > | #line 1394 "MDTreeParser.cpp" |
1394 | > | ANTLR_USE_NAMESPACE(antlr)RefAST doubleNumber_AST_in = (_t == ANTLR_USE_NAMESPACE(antlr)RefAST(ASTNULL)) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; |
1395 | ANTLR_USE_NAMESPACE(antlr)RefAST ic = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
1396 | ANTLR_USE_NAMESPACE(antlr)RefAST fc = ANTLR_USE_NAMESPACE(antlr)nullAST; | |
1397 | ||
# | Line 1361 | Line 1399 | double MDTreeParser::signedNumber(ANTLR_USE_NAMESPACE | |
1399 | if (_t == ANTLR_USE_NAMESPACE(antlr)nullAST ) | |
1400 | _t = ASTNULL; | |
1401 | switch ( _t->getType()) { | |
1402 | < | case OCTALINT: |
1403 | < | case DECIMALINT: |
1366 | < | case HEXADECIMALINT: |
1402 | > | case NUM_INT: |
1403 | > | case NUM_LONG: |
1404 | { | |
1405 | ic = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1406 | intConst(_t); | |
1407 | _t = _retTree; | |
1408 | < | #line 258 "MDTreeParser.g" |
1409 | < | dval = lexi_cast<double>(ic->getText()); |
1410 | < | #line 1374 "MDTreeParser.cpp" |
1408 | > | #line 276 "MDTreeParser.g" |
1409 | > | dval = lexi_cast<RealType>(ic->getText()); |
1410 | > | #line 1411 "MDTreeParser.cpp" |
1411 | break; | |
1412 | } | |
1413 | < | case FLOATONE: |
1414 | < | case FLOATTWO: |
1413 | > | case NUM_FLOAT: |
1414 | > | case NUM_DOUBLE: |
1415 | { | |
1416 | fc = (_t == ASTNULL) ? ANTLR_USE_NAMESPACE(antlr)nullAST : _t; | |
1417 | floatConst(_t); | |
1418 | _t = _retTree; | |
1419 | < | #line 259 "MDTreeParser.g" |
1420 | < | dval = lexi_cast<double>(fc->getText()); |
1421 | < | #line 1385 "MDTreeParser.cpp" |
1419 | > | #line 277 "MDTreeParser.g" |
1420 | > | dval = lexi_cast<RealType>(fc->getText()); |
1421 | > | #line 1422 "MDTreeParser.cpp" |
1422 | break; | |
1423 | } | |
1424 | default: | |
# | Line 1410 | Line 1447 | const char* MDTreeParser::tokenNames[] = { | |
1447 | "\"component\"", | |
1448 | "\"molecule\"", | |
1449 | "\"zconstraint\"", | |
1450 | + | "\"restraint\"", |
1451 | "\"atom\"", | |
1452 | "\"bond\"", | |
1453 | "\"bend\"", | |
1454 | "\"torsion\"", | |
1455 | + | "\"inversion\"", |
1456 | "\"rigidBody\"", | |
1457 | "\"cutoffGroup\"", | |
1458 | "\"fragment\"", | |
1459 | "\"members\"", | |
1460 | + | "\"center\"", |
1461 | "\"position\"", | |
1462 | "\"orientation\"", | |
1463 | "ENDBLOCK", | |
# | Line 1432 | Line 1472 | const char* MDTreeParser::tokenNames[] = { | |
1472 | "LPAREN", | |
1473 | "RPAREN", | |
1474 | "COMMA", | |
1475 | < | "OCTALINT", |
1476 | < | "DECIMALINT", |
1477 | < | "HEXADECIMALINT", |
1478 | < | "FLOATONE", |
1439 | < | "FLOATTWO", |
1475 | > | "NUM_INT", |
1476 | > | "NUM_LONG", |
1477 | > | "NUM_FLOAT", |
1478 | > | "NUM_DOUBLE", |
1479 | "DOT", | |
1480 | "COLON", | |
1481 | "QUESTIONMARK", | |
# | Line 1449 | Line 1488 | const char* MDTreeParser::tokenNames[] = { | |
1488 | "CharLiteral", | |
1489 | "EndOfLine", | |
1490 | "Escape", | |
1491 | + | "Vocabulary", |
1492 | "Digit", | |
1493 | "Decimal", | |
1494 | < | "LongSuffix", |
1495 | < | "UnsignedSuffix", |
1496 | < | "FloatSuffix", |
1457 | < | "Exponent", |
1458 | < | "Vocabulary", |
1459 | < | "Number", |
1460 | < | "MINUS", |
1494 | > | "HEX_DIGIT", |
1495 | > | "EXPONENT", |
1496 | > | "FLOAT_SUFFIX", |
1497 | 0 | |
1498 | }; | |
1499 | ||
1500 | < | const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 524400UL, 0UL, 0UL, 0UL }; |
1501 | < | // "component" "molecule" "zconstraint" ASSIGNEQUAL |
1500 | > | const unsigned long MDTreeParser::_tokenSet_0_data_[] = { 4194544UL, 0UL, 0UL, 0UL }; |
1501 | > | // "component" "molecule" "zconstraint" "restraint" ASSIGNEQUAL |
1502 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_0(_tokenSet_0_data_,4); | |
1503 | < | const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 540544UL, 0UL, 0UL, 0UL }; |
1504 | < | // "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" |
1505 | < | // ASSIGNEQUAL |
1503 | > | const unsigned long MDTreeParser::_tokenSet_1_data_[] = { 4259584UL, 0UL, 0UL, 0UL }; |
1504 | > | // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup" |
1505 | > | // "fragment" ASSIGNEQUAL |
1506 | const ANTLR_USE_NAMESPACE(antlr)BitSet MDTreeParser::_tokenSet_1(_tokenSet_1_data_,4); | |
1507 | ||
1508 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |