1 |
/* $ANTLR 2.7.5 (20050406): "MDParser.g" -> "MDParser.cpp"$ */ |
2 |
#include "MDParser.hpp" |
3 |
#include <antlr/NoViableAltException.hpp> |
4 |
#include <antlr/SemanticException.hpp> |
5 |
#include <antlr/ASTFactory.hpp> |
6 |
#line 1 "MDParser.g" |
7 |
#line 8 "MDParser.cpp" |
8 |
MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) |
9 |
: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) |
10 |
{ |
11 |
} |
12 |
|
13 |
MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) |
14 |
: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,3) |
15 |
{ |
16 |
} |
17 |
|
18 |
MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) |
19 |
: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) |
20 |
{ |
21 |
} |
22 |
|
23 |
MDParser::MDParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) |
24 |
: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,3) |
25 |
{ |
26 |
} |
27 |
|
28 |
MDParser::MDParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) |
29 |
: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,3) |
30 |
{ |
31 |
} |
32 |
|
33 |
void MDParser::mdfile() { |
34 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
35 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
36 |
ANTLR_USE_NAMESPACE(antlr)RefAST mdfile_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
37 |
|
38 |
try { // for error handling |
39 |
{ // ( ... )* |
40 |
for (;;) { |
41 |
if ((_tokenSet_0.member(LA(1)))) { |
42 |
statement(); |
43 |
astFactory->addASTChild( currentAST, returnAST ); |
44 |
} |
45 |
else { |
46 |
goto _loop3; |
47 |
} |
48 |
|
49 |
} |
50 |
_loop3:; |
51 |
} // ( ... )* |
52 |
mdfile_AST = currentAST.root; |
53 |
} |
54 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
55 |
reportError(ex); |
56 |
recover(ex,_tokenSet_1); |
57 |
} |
58 |
returnAST = mdfile_AST; |
59 |
} |
60 |
|
61 |
void MDParser::statement() { |
62 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
63 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
64 |
ANTLR_USE_NAMESPACE(antlr)RefAST statement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
65 |
|
66 |
try { // for error handling |
67 |
switch ( LA(1)) { |
68 |
case ID: |
69 |
{ |
70 |
assignment(); |
71 |
astFactory->addASTChild( currentAST, returnAST ); |
72 |
statement_AST = currentAST.root; |
73 |
break; |
74 |
} |
75 |
case COMPONENT: |
76 |
{ |
77 |
componentblock(); |
78 |
astFactory->addASTChild( currentAST, returnAST ); |
79 |
statement_AST = currentAST.root; |
80 |
break; |
81 |
} |
82 |
case MOLECULE: |
83 |
{ |
84 |
moleculeblock(); |
85 |
astFactory->addASTChild( currentAST, returnAST ); |
86 |
statement_AST = currentAST.root; |
87 |
break; |
88 |
} |
89 |
case ZCONSTRAINT: |
90 |
{ |
91 |
zconstraintblock(); |
92 |
astFactory->addASTChild( currentAST, returnAST ); |
93 |
statement_AST = currentAST.root; |
94 |
break; |
95 |
} |
96 |
default: |
97 |
{ |
98 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
99 |
} |
100 |
} |
101 |
} |
102 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
103 |
reportError(ex); |
104 |
recover(ex,_tokenSet_2); |
105 |
} |
106 |
returnAST = statement_AST; |
107 |
} |
108 |
|
109 |
void MDParser::assignment() { |
110 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
111 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
112 |
ANTLR_USE_NAMESPACE(antlr)RefAST assignment_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
113 |
|
114 |
try { // for error handling |
115 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp1_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
116 |
tmp1_AST = astFactory->create(LT(1)); |
117 |
astFactory->addASTChild(currentAST, tmp1_AST); |
118 |
match(ID); |
119 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp2_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
120 |
tmp2_AST = astFactory->create(LT(1)); |
121 |
astFactory->makeASTRoot(currentAST, tmp2_AST); |
122 |
match(ASSIGNEQUAL); |
123 |
constant(); |
124 |
astFactory->addASTChild( currentAST, returnAST ); |
125 |
match(SEMICOLON); |
126 |
assignment_AST = currentAST.root; |
127 |
} |
128 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
129 |
reportError(ex); |
130 |
recover(ex,_tokenSet_3); |
131 |
} |
132 |
returnAST = assignment_AST; |
133 |
} |
134 |
|
135 |
void MDParser::componentblock() { |
136 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
137 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
138 |
ANTLR_USE_NAMESPACE(antlr)RefAST componentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
139 |
|
140 |
try { // for error handling |
141 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp4_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
142 |
tmp4_AST = astFactory->create(LT(1)); |
143 |
astFactory->makeASTRoot(currentAST, tmp4_AST); |
144 |
match(COMPONENT); |
145 |
match(LCURLY); |
146 |
{ // ( ... )* |
147 |
for (;;) { |
148 |
if ((LA(1) == ID)) { |
149 |
assignment(); |
150 |
astFactory->addASTChild( currentAST, returnAST ); |
151 |
} |
152 |
else { |
153 |
goto _loop9; |
154 |
} |
155 |
|
156 |
} |
157 |
_loop9:; |
158 |
} // ( ... )* |
159 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp6_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
160 |
tmp6_AST = astFactory->create(LT(1)); |
161 |
astFactory->addASTChild(currentAST, tmp6_AST); |
162 |
match(RCURLY); |
163 |
#line 65 "MDParser.g" |
164 |
tmp6_AST->setType(ENDBLOCK); |
165 |
#line 166 "MDParser.cpp" |
166 |
componentblock_AST = currentAST.root; |
167 |
} |
168 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
169 |
reportError(ex); |
170 |
recover(ex,_tokenSet_2); |
171 |
} |
172 |
returnAST = componentblock_AST; |
173 |
} |
174 |
|
175 |
void MDParser::moleculeblock() { |
176 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
177 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
178 |
ANTLR_USE_NAMESPACE(antlr)RefAST moleculeblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
179 |
|
180 |
try { // for error handling |
181 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp7_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
182 |
tmp7_AST = astFactory->create(LT(1)); |
183 |
astFactory->makeASTRoot(currentAST, tmp7_AST); |
184 |
match(MOLECULE); |
185 |
match(LCURLY); |
186 |
{ // ( ... )* |
187 |
for (;;) { |
188 |
if ((_tokenSet_4.member(LA(1)))) { |
189 |
moleculestatement(); |
190 |
astFactory->addASTChild( currentAST, returnAST ); |
191 |
} |
192 |
else { |
193 |
goto _loop15; |
194 |
} |
195 |
|
196 |
} |
197 |
_loop15:; |
198 |
} // ( ... )* |
199 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
200 |
tmp9_AST = astFactory->create(LT(1)); |
201 |
astFactory->addASTChild(currentAST, tmp9_AST); |
202 |
match(RCURLY); |
203 |
#line 71 "MDParser.g" |
204 |
tmp9_AST->setType(ENDBLOCK); |
205 |
#line 206 "MDParser.cpp" |
206 |
moleculeblock_AST = currentAST.root; |
207 |
} |
208 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
209 |
reportError(ex); |
210 |
recover(ex,_tokenSet_2); |
211 |
} |
212 |
returnAST = moleculeblock_AST; |
213 |
} |
214 |
|
215 |
void MDParser::zconstraintblock() { |
216 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
217 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
218 |
ANTLR_USE_NAMESPACE(antlr)RefAST zconstraintblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
219 |
|
220 |
try { // for error handling |
221 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp10_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
222 |
tmp10_AST = astFactory->create(LT(1)); |
223 |
astFactory->makeASTRoot(currentAST, tmp10_AST); |
224 |
match(ZCONSTRAINT); |
225 |
match(LCURLY); |
226 |
{ // ( ... )* |
227 |
for (;;) { |
228 |
if ((LA(1) == ID)) { |
229 |
assignment(); |
230 |
astFactory->addASTChild( currentAST, returnAST ); |
231 |
} |
232 |
else { |
233 |
goto _loop12; |
234 |
} |
235 |
|
236 |
} |
237 |
_loop12:; |
238 |
} // ( ... )* |
239 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp12_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
240 |
tmp12_AST = astFactory->create(LT(1)); |
241 |
astFactory->addASTChild(currentAST, tmp12_AST); |
242 |
match(RCURLY); |
243 |
#line 68 "MDParser.g" |
244 |
tmp12_AST->setType(ENDBLOCK); |
245 |
#line 246 "MDParser.cpp" |
246 |
zconstraintblock_AST = currentAST.root; |
247 |
} |
248 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
249 |
reportError(ex); |
250 |
recover(ex,_tokenSet_2); |
251 |
} |
252 |
returnAST = zconstraintblock_AST; |
253 |
} |
254 |
|
255 |
void MDParser::constant() { |
256 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
257 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
258 |
ANTLR_USE_NAMESPACE(antlr)RefAST constant_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
259 |
|
260 |
try { // for error handling |
261 |
switch ( LA(1)) { |
262 |
case OCTALINT: |
263 |
case DECIMALINT: |
264 |
case HEXADECIMALINT: |
265 |
case PLUS: |
266 |
case MINUS: |
267 |
case FLOATONE: |
268 |
case FLOATTWO: |
269 |
{ |
270 |
signedNumber(); |
271 |
astFactory->addASTChild( currentAST, returnAST ); |
272 |
constant_AST = currentAST.root; |
273 |
break; |
274 |
} |
275 |
case ID: |
276 |
{ |
277 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
278 |
tmp13_AST = astFactory->create(LT(1)); |
279 |
astFactory->addASTChild(currentAST, tmp13_AST); |
280 |
match(ID); |
281 |
constant_AST = currentAST.root; |
282 |
break; |
283 |
} |
284 |
case StringLiteral: |
285 |
{ |
286 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
287 |
tmp14_AST = astFactory->create(LT(1)); |
288 |
astFactory->addASTChild(currentAST, tmp14_AST); |
289 |
match(StringLiteral); |
290 |
constant_AST = currentAST.root; |
291 |
break; |
292 |
} |
293 |
default: |
294 |
{ |
295 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
296 |
} |
297 |
} |
298 |
} |
299 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
300 |
reportError(ex); |
301 |
recover(ex,_tokenSet_5); |
302 |
} |
303 |
returnAST = constant_AST; |
304 |
} |
305 |
|
306 |
void MDParser::signedNumber() { |
307 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
308 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
309 |
ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
310 |
|
311 |
try { // for error handling |
312 |
{ |
313 |
switch ( LA(1)) { |
314 |
case PLUS: |
315 |
{ |
316 |
match(PLUS); |
317 |
break; |
318 |
} |
319 |
case MINUS: |
320 |
{ |
321 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
322 |
tmp16_AST = astFactory->create(LT(1)); |
323 |
astFactory->makeASTRoot(currentAST, tmp16_AST); |
324 |
match(MINUS); |
325 |
break; |
326 |
} |
327 |
case OCTALINT: |
328 |
case DECIMALINT: |
329 |
case HEXADECIMALINT: |
330 |
case FLOATONE: |
331 |
case FLOATTWO: |
332 |
{ |
333 |
break; |
334 |
} |
335 |
default: |
336 |
{ |
337 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
338 |
} |
339 |
} |
340 |
} |
341 |
{ |
342 |
switch ( LA(1)) { |
343 |
case OCTALINT: |
344 |
case DECIMALINT: |
345 |
case HEXADECIMALINT: |
346 |
{ |
347 |
intConst(); |
348 |
astFactory->addASTChild( currentAST, returnAST ); |
349 |
break; |
350 |
} |
351 |
case FLOATONE: |
352 |
case FLOATTWO: |
353 |
{ |
354 |
floatConst(); |
355 |
astFactory->addASTChild( currentAST, returnAST ); |
356 |
break; |
357 |
} |
358 |
default: |
359 |
{ |
360 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
361 |
} |
362 |
} |
363 |
} |
364 |
signedNumber_AST = currentAST.root; |
365 |
} |
366 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
367 |
reportError(ex); |
368 |
recover(ex,_tokenSet_6); |
369 |
} |
370 |
returnAST = signedNumber_AST; |
371 |
} |
372 |
|
373 |
void MDParser::moleculestatement() { |
374 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
375 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
376 |
ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
377 |
|
378 |
try { // for error handling |
379 |
switch ( LA(1)) { |
380 |
case ID: |
381 |
{ |
382 |
assignment(); |
383 |
astFactory->addASTChild( currentAST, returnAST ); |
384 |
moleculestatement_AST = currentAST.root; |
385 |
break; |
386 |
} |
387 |
case ATOM: |
388 |
{ |
389 |
atomblock(); |
390 |
astFactory->addASTChild( currentAST, returnAST ); |
391 |
moleculestatement_AST = currentAST.root; |
392 |
break; |
393 |
} |
394 |
case BOND: |
395 |
{ |
396 |
bondblock(); |
397 |
astFactory->addASTChild( currentAST, returnAST ); |
398 |
moleculestatement_AST = currentAST.root; |
399 |
break; |
400 |
} |
401 |
case BEND: |
402 |
{ |
403 |
bendblock(); |
404 |
astFactory->addASTChild( currentAST, returnAST ); |
405 |
moleculestatement_AST = currentAST.root; |
406 |
break; |
407 |
} |
408 |
case TORSION: |
409 |
{ |
410 |
torsionblock(); |
411 |
astFactory->addASTChild( currentAST, returnAST ); |
412 |
moleculestatement_AST = currentAST.root; |
413 |
break; |
414 |
} |
415 |
case RIGIDBODY: |
416 |
{ |
417 |
rigidbodyblock(); |
418 |
astFactory->addASTChild( currentAST, returnAST ); |
419 |
moleculestatement_AST = currentAST.root; |
420 |
break; |
421 |
} |
422 |
case CUTOFFGROUP: |
423 |
{ |
424 |
cutoffgroupblock(); |
425 |
astFactory->addASTChild( currentAST, returnAST ); |
426 |
moleculestatement_AST = currentAST.root; |
427 |
break; |
428 |
} |
429 |
case FRAGMENT: |
430 |
{ |
431 |
fragmentblock(); |
432 |
astFactory->addASTChild( currentAST, returnAST ); |
433 |
moleculestatement_AST = currentAST.root; |
434 |
break; |
435 |
} |
436 |
default: |
437 |
{ |
438 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
439 |
} |
440 |
} |
441 |
} |
442 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
443 |
reportError(ex); |
444 |
recover(ex,_tokenSet_7); |
445 |
} |
446 |
returnAST = moleculestatement_AST; |
447 |
} |
448 |
|
449 |
void MDParser::atomblock() { |
450 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
451 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
452 |
ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
453 |
|
454 |
try { // for error handling |
455 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
456 |
tmp17_AST = astFactory->create(LT(1)); |
457 |
astFactory->makeASTRoot(currentAST, tmp17_AST); |
458 |
match(ATOM); |
459 |
match(LBRACKET); |
460 |
intConst(); |
461 |
astFactory->addASTChild( currentAST, returnAST ); |
462 |
match(RBRACKET); |
463 |
match(LCURLY); |
464 |
{ // ( ... )* |
465 |
for (;;) { |
466 |
if ((_tokenSet_8.member(LA(1)))) { |
467 |
atomstatement(); |
468 |
astFactory->addASTChild( currentAST, returnAST ); |
469 |
} |
470 |
else { |
471 |
goto _loop19; |
472 |
} |
473 |
|
474 |
} |
475 |
_loop19:; |
476 |
} // ( ... )* |
477 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
478 |
tmp21_AST = astFactory->create(LT(1)); |
479 |
astFactory->addASTChild(currentAST, tmp21_AST); |
480 |
match(RCURLY); |
481 |
#line 84 "MDParser.g" |
482 |
tmp21_AST->setType(ENDBLOCK); |
483 |
#line 484 "MDParser.cpp" |
484 |
atomblock_AST = currentAST.root; |
485 |
} |
486 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
487 |
reportError(ex); |
488 |
recover(ex,_tokenSet_7); |
489 |
} |
490 |
returnAST = atomblock_AST; |
491 |
} |
492 |
|
493 |
void MDParser::bondblock() { |
494 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
495 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
496 |
ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
497 |
|
498 |
try { // for error handling |
499 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
500 |
tmp22_AST = astFactory->create(LT(1)); |
501 |
astFactory->makeASTRoot(currentAST, tmp22_AST); |
502 |
match(BOND); |
503 |
{ |
504 |
switch ( LA(1)) { |
505 |
case LBRACKET: |
506 |
{ |
507 |
match(LBRACKET); |
508 |
intConst(); |
509 |
match(RBRACKET); |
510 |
break; |
511 |
} |
512 |
case LCURLY: |
513 |
{ |
514 |
break; |
515 |
} |
516 |
default: |
517 |
{ |
518 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
519 |
} |
520 |
} |
521 |
} |
522 |
match(LCURLY); |
523 |
{ // ( ... )* |
524 |
for (;;) { |
525 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
526 |
bondstatement(); |
527 |
astFactory->addASTChild( currentAST, returnAST ); |
528 |
} |
529 |
else { |
530 |
goto _loop24; |
531 |
} |
532 |
|
533 |
} |
534 |
_loop24:; |
535 |
} // ( ... )* |
536 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
537 |
tmp26_AST = astFactory->create(LT(1)); |
538 |
astFactory->addASTChild(currentAST, tmp26_AST); |
539 |
match(RCURLY); |
540 |
#line 93 "MDParser.g" |
541 |
tmp26_AST->setType(ENDBLOCK); |
542 |
#line 543 "MDParser.cpp" |
543 |
bondblock_AST = currentAST.root; |
544 |
} |
545 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
546 |
reportError(ex); |
547 |
recover(ex,_tokenSet_7); |
548 |
} |
549 |
returnAST = bondblock_AST; |
550 |
} |
551 |
|
552 |
void MDParser::bendblock() { |
553 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
554 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
555 |
ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
556 |
|
557 |
try { // for error handling |
558 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
559 |
tmp27_AST = astFactory->create(LT(1)); |
560 |
astFactory->makeASTRoot(currentAST, tmp27_AST); |
561 |
match(BEND); |
562 |
{ |
563 |
switch ( LA(1)) { |
564 |
case LBRACKET: |
565 |
{ |
566 |
match(LBRACKET); |
567 |
intConst(); |
568 |
match(RBRACKET); |
569 |
break; |
570 |
} |
571 |
case LCURLY: |
572 |
{ |
573 |
break; |
574 |
} |
575 |
default: |
576 |
{ |
577 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
578 |
} |
579 |
} |
580 |
} |
581 |
match(LCURLY); |
582 |
{ // ( ... )* |
583 |
for (;;) { |
584 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
585 |
bendstatement(); |
586 |
astFactory->addASTChild( currentAST, returnAST ); |
587 |
} |
588 |
else { |
589 |
goto _loop29; |
590 |
} |
591 |
|
592 |
} |
593 |
_loop29:; |
594 |
} // ( ... )* |
595 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
596 |
tmp31_AST = astFactory->create(LT(1)); |
597 |
astFactory->addASTChild(currentAST, tmp31_AST); |
598 |
match(RCURLY); |
599 |
#line 100 "MDParser.g" |
600 |
tmp31_AST->setType(ENDBLOCK); |
601 |
#line 602 "MDParser.cpp" |
602 |
bendblock_AST = currentAST.root; |
603 |
} |
604 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
605 |
reportError(ex); |
606 |
recover(ex,_tokenSet_7); |
607 |
} |
608 |
returnAST = bendblock_AST; |
609 |
} |
610 |
|
611 |
void MDParser::torsionblock() { |
612 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
613 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
614 |
ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
615 |
|
616 |
try { // for error handling |
617 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
618 |
tmp32_AST = astFactory->create(LT(1)); |
619 |
astFactory->makeASTRoot(currentAST, tmp32_AST); |
620 |
match(TORSION); |
621 |
{ |
622 |
switch ( LA(1)) { |
623 |
case LBRACKET: |
624 |
{ |
625 |
match(LBRACKET); |
626 |
intConst(); |
627 |
match(RBRACKET); |
628 |
break; |
629 |
} |
630 |
case LCURLY: |
631 |
{ |
632 |
break; |
633 |
} |
634 |
default: |
635 |
{ |
636 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
637 |
} |
638 |
} |
639 |
} |
640 |
match(LCURLY); |
641 |
{ // ( ... )* |
642 |
for (;;) { |
643 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
644 |
torsionstatement(); |
645 |
astFactory->addASTChild( currentAST, returnAST ); |
646 |
} |
647 |
else { |
648 |
goto _loop34; |
649 |
} |
650 |
|
651 |
} |
652 |
_loop34:; |
653 |
} // ( ... )* |
654 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
655 |
tmp36_AST = astFactory->create(LT(1)); |
656 |
astFactory->addASTChild(currentAST, tmp36_AST); |
657 |
match(RCURLY); |
658 |
#line 107 "MDParser.g" |
659 |
tmp36_AST->setType(ENDBLOCK); |
660 |
#line 661 "MDParser.cpp" |
661 |
torsionblock_AST = currentAST.root; |
662 |
} |
663 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
664 |
reportError(ex); |
665 |
recover(ex,_tokenSet_7); |
666 |
} |
667 |
returnAST = torsionblock_AST; |
668 |
} |
669 |
|
670 |
void MDParser::rigidbodyblock() { |
671 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
672 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
673 |
ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
674 |
|
675 |
try { // for error handling |
676 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
677 |
tmp37_AST = astFactory->create(LT(1)); |
678 |
astFactory->makeASTRoot(currentAST, tmp37_AST); |
679 |
match(RIGIDBODY); |
680 |
match(LBRACKET); |
681 |
intConst(); |
682 |
astFactory->addASTChild( currentAST, returnAST ); |
683 |
match(RBRACKET); |
684 |
match(LCURLY); |
685 |
{ // ( ... )* |
686 |
for (;;) { |
687 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
688 |
rigidbodystatement(); |
689 |
astFactory->addASTChild( currentAST, returnAST ); |
690 |
} |
691 |
else { |
692 |
goto _loop38; |
693 |
} |
694 |
|
695 |
} |
696 |
_loop38:; |
697 |
} // ( ... )* |
698 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
699 |
tmp41_AST = astFactory->create(LT(1)); |
700 |
astFactory->addASTChild(currentAST, tmp41_AST); |
701 |
match(RCURLY); |
702 |
#line 114 "MDParser.g" |
703 |
tmp41_AST->setType(ENDBLOCK); |
704 |
#line 705 "MDParser.cpp" |
705 |
rigidbodyblock_AST = currentAST.root; |
706 |
} |
707 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
708 |
reportError(ex); |
709 |
recover(ex,_tokenSet_7); |
710 |
} |
711 |
returnAST = rigidbodyblock_AST; |
712 |
} |
713 |
|
714 |
void MDParser::cutoffgroupblock() { |
715 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
716 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
717 |
ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
718 |
|
719 |
try { // for error handling |
720 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
721 |
tmp42_AST = astFactory->create(LT(1)); |
722 |
astFactory->makeASTRoot(currentAST, tmp42_AST); |
723 |
match(CUTOFFGROUP); |
724 |
{ |
725 |
switch ( LA(1)) { |
726 |
case LBRACKET: |
727 |
{ |
728 |
match(LBRACKET); |
729 |
intConst(); |
730 |
match(RBRACKET); |
731 |
break; |
732 |
} |
733 |
case LCURLY: |
734 |
{ |
735 |
break; |
736 |
} |
737 |
default: |
738 |
{ |
739 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
740 |
} |
741 |
} |
742 |
} |
743 |
match(LCURLY); |
744 |
{ // ( ... )* |
745 |
for (;;) { |
746 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
747 |
cutoffgroupstatement(); |
748 |
astFactory->addASTChild( currentAST, returnAST ); |
749 |
} |
750 |
else { |
751 |
goto _loop43; |
752 |
} |
753 |
|
754 |
} |
755 |
_loop43:; |
756 |
} // ( ... )* |
757 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
758 |
tmp46_AST = astFactory->create(LT(1)); |
759 |
astFactory->addASTChild(currentAST, tmp46_AST); |
760 |
match(RCURLY); |
761 |
#line 121 "MDParser.g" |
762 |
tmp46_AST->setType(ENDBLOCK); |
763 |
#line 764 "MDParser.cpp" |
764 |
cutoffgroupblock_AST = currentAST.root; |
765 |
} |
766 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
767 |
reportError(ex); |
768 |
recover(ex,_tokenSet_7); |
769 |
} |
770 |
returnAST = cutoffgroupblock_AST; |
771 |
} |
772 |
|
773 |
void MDParser::fragmentblock() { |
774 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
775 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
776 |
ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
777 |
|
778 |
try { // for error handling |
779 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
780 |
tmp47_AST = astFactory->create(LT(1)); |
781 |
astFactory->makeASTRoot(currentAST, tmp47_AST); |
782 |
match(FRAGMENT); |
783 |
match(LBRACKET); |
784 |
intConst(); |
785 |
astFactory->addASTChild( currentAST, returnAST ); |
786 |
match(RBRACKET); |
787 |
match(LCURLY); |
788 |
{ // ( ... )* |
789 |
for (;;) { |
790 |
if ((LA(1) == ID)) { |
791 |
fragmentstatement(); |
792 |
astFactory->addASTChild( currentAST, returnAST ); |
793 |
} |
794 |
else { |
795 |
goto _loop47; |
796 |
} |
797 |
|
798 |
} |
799 |
_loop47:; |
800 |
} // ( ... )* |
801 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
802 |
tmp51_AST = astFactory->create(LT(1)); |
803 |
astFactory->addASTChild(currentAST, tmp51_AST); |
804 |
match(RCURLY); |
805 |
#line 128 "MDParser.g" |
806 |
tmp51_AST->setType(ENDBLOCK); |
807 |
#line 808 "MDParser.cpp" |
808 |
fragmentblock_AST = currentAST.root; |
809 |
} |
810 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
811 |
reportError(ex); |
812 |
recover(ex,_tokenSet_7); |
813 |
} |
814 |
returnAST = fragmentblock_AST; |
815 |
} |
816 |
|
817 |
void MDParser::intConst() { |
818 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
819 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
820 |
ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
821 |
|
822 |
try { // for error handling |
823 |
switch ( LA(1)) { |
824 |
case OCTALINT: |
825 |
{ |
826 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
827 |
tmp52_AST = astFactory->create(LT(1)); |
828 |
astFactory->addASTChild(currentAST, tmp52_AST); |
829 |
match(OCTALINT); |
830 |
intConst_AST = currentAST.root; |
831 |
break; |
832 |
} |
833 |
case DECIMALINT: |
834 |
{ |
835 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
836 |
tmp53_AST = astFactory->create(LT(1)); |
837 |
astFactory->addASTChild(currentAST, tmp53_AST); |
838 |
match(DECIMALINT); |
839 |
intConst_AST = currentAST.root; |
840 |
break; |
841 |
} |
842 |
case HEXADECIMALINT: |
843 |
{ |
844 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
845 |
tmp54_AST = astFactory->create(LT(1)); |
846 |
astFactory->addASTChild(currentAST, tmp54_AST); |
847 |
match(HEXADECIMALINT); |
848 |
intConst_AST = currentAST.root; |
849 |
break; |
850 |
} |
851 |
default: |
852 |
{ |
853 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
854 |
} |
855 |
} |
856 |
} |
857 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
858 |
reportError(ex); |
859 |
recover(ex,_tokenSet_9); |
860 |
} |
861 |
returnAST = intConst_AST; |
862 |
} |
863 |
|
864 |
void MDParser::atomstatement() { |
865 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
866 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
867 |
ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
868 |
|
869 |
try { // for error handling |
870 |
switch ( LA(1)) { |
871 |
case ID: |
872 |
{ |
873 |
assignment(); |
874 |
astFactory->addASTChild( currentAST, returnAST ); |
875 |
atomstatement_AST = currentAST.root; |
876 |
break; |
877 |
} |
878 |
case POSITION: |
879 |
{ |
880 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
881 |
tmp55_AST = astFactory->create(LT(1)); |
882 |
astFactory->makeASTRoot(currentAST, tmp55_AST); |
883 |
match(POSITION); |
884 |
match(LPAREN); |
885 |
signedNumberTuple(); |
886 |
astFactory->addASTChild( currentAST, returnAST ); |
887 |
match(RPAREN); |
888 |
match(SEMICOLON); |
889 |
atomstatement_AST = currentAST.root; |
890 |
break; |
891 |
} |
892 |
case ORIENTATION: |
893 |
{ |
894 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
895 |
tmp59_AST = astFactory->create(LT(1)); |
896 |
astFactory->makeASTRoot(currentAST, tmp59_AST); |
897 |
match(ORIENTATION); |
898 |
match(LPAREN); |
899 |
signedNumberTuple(); |
900 |
astFactory->addASTChild( currentAST, returnAST ); |
901 |
match(RPAREN); |
902 |
match(SEMICOLON); |
903 |
atomstatement_AST = currentAST.root; |
904 |
break; |
905 |
} |
906 |
default: |
907 |
{ |
908 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
909 |
} |
910 |
} |
911 |
} |
912 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
913 |
reportError(ex); |
914 |
recover(ex,_tokenSet_10); |
915 |
} |
916 |
returnAST = atomstatement_AST; |
917 |
} |
918 |
|
919 |
void MDParser::signedNumberTuple() { |
920 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
921 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
922 |
ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
923 |
|
924 |
try { // for error handling |
925 |
signedNumber(); |
926 |
astFactory->addASTChild( currentAST, returnAST ); |
927 |
{ // ( ... )* |
928 |
for (;;) { |
929 |
if ((LA(1) == COMMA)) { |
930 |
match(COMMA); |
931 |
signedNumber(); |
932 |
astFactory->addASTChild( currentAST, returnAST ); |
933 |
} |
934 |
else { |
935 |
goto _loop51; |
936 |
} |
937 |
|
938 |
} |
939 |
_loop51:; |
940 |
} // ( ... )* |
941 |
signedNumberTuple_AST = currentAST.root; |
942 |
} |
943 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
944 |
reportError(ex); |
945 |
recover(ex,_tokenSet_11); |
946 |
} |
947 |
returnAST = signedNumberTuple_AST; |
948 |
} |
949 |
|
950 |
void MDParser::bondstatement() { |
951 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
952 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
953 |
ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
954 |
|
955 |
try { // for error handling |
956 |
switch ( LA(1)) { |
957 |
case ID: |
958 |
{ |
959 |
assignment(); |
960 |
astFactory->addASTChild( currentAST, returnAST ); |
961 |
bondstatement_AST = currentAST.root; |
962 |
break; |
963 |
} |
964 |
case MEMBERS: |
965 |
{ |
966 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
967 |
tmp64_AST = astFactory->create(LT(1)); |
968 |
astFactory->makeASTRoot(currentAST, tmp64_AST); |
969 |
match(MEMBERS); |
970 |
match(LPAREN); |
971 |
inttuple(); |
972 |
astFactory->addASTChild( currentAST, returnAST ); |
973 |
match(RPAREN); |
974 |
match(SEMICOLON); |
975 |
bondstatement_AST = currentAST.root; |
976 |
break; |
977 |
} |
978 |
default: |
979 |
{ |
980 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
981 |
} |
982 |
} |
983 |
} |
984 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
985 |
reportError(ex); |
986 |
recover(ex,_tokenSet_12); |
987 |
} |
988 |
returnAST = bondstatement_AST; |
989 |
} |
990 |
|
991 |
void MDParser::inttuple() { |
992 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
993 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
994 |
ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
995 |
|
996 |
try { // for error handling |
997 |
intConst(); |
998 |
astFactory->addASTChild( currentAST, returnAST ); |
999 |
{ // ( ... )* |
1000 |
for (;;) { |
1001 |
if ((LA(1) == COMMA)) { |
1002 |
match(COMMA); |
1003 |
intConst(); |
1004 |
astFactory->addASTChild( currentAST, returnAST ); |
1005 |
} |
1006 |
else { |
1007 |
goto _loop54; |
1008 |
} |
1009 |
|
1010 |
} |
1011 |
_loop54:; |
1012 |
} // ( ... )* |
1013 |
inttuple_AST = currentAST.root; |
1014 |
} |
1015 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1016 |
reportError(ex); |
1017 |
recover(ex,_tokenSet_11); |
1018 |
} |
1019 |
returnAST = inttuple_AST; |
1020 |
} |
1021 |
|
1022 |
void MDParser::bendstatement() { |
1023 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1024 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1025 |
ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1026 |
|
1027 |
try { // for error handling |
1028 |
switch ( LA(1)) { |
1029 |
case ID: |
1030 |
{ |
1031 |
assignment(); |
1032 |
astFactory->addASTChild( currentAST, returnAST ); |
1033 |
bendstatement_AST = currentAST.root; |
1034 |
break; |
1035 |
} |
1036 |
case MEMBERS: |
1037 |
{ |
1038 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1039 |
tmp69_AST = astFactory->create(LT(1)); |
1040 |
astFactory->makeASTRoot(currentAST, tmp69_AST); |
1041 |
match(MEMBERS); |
1042 |
match(LPAREN); |
1043 |
inttuple(); |
1044 |
astFactory->addASTChild( currentAST, returnAST ); |
1045 |
match(RPAREN); |
1046 |
match(SEMICOLON); |
1047 |
bendstatement_AST = currentAST.root; |
1048 |
break; |
1049 |
} |
1050 |
default: |
1051 |
{ |
1052 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1053 |
} |
1054 |
} |
1055 |
} |
1056 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1057 |
reportError(ex); |
1058 |
recover(ex,_tokenSet_12); |
1059 |
} |
1060 |
returnAST = bendstatement_AST; |
1061 |
} |
1062 |
|
1063 |
void MDParser::torsionstatement() { |
1064 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1065 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1066 |
ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1067 |
|
1068 |
try { // for error handling |
1069 |
switch ( LA(1)) { |
1070 |
case ID: |
1071 |
{ |
1072 |
assignment(); |
1073 |
astFactory->addASTChild( currentAST, returnAST ); |
1074 |
torsionstatement_AST = currentAST.root; |
1075 |
break; |
1076 |
} |
1077 |
case MEMBERS: |
1078 |
{ |
1079 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1080 |
tmp73_AST = astFactory->create(LT(1)); |
1081 |
astFactory->makeASTRoot(currentAST, tmp73_AST); |
1082 |
match(MEMBERS); |
1083 |
match(LPAREN); |
1084 |
inttuple(); |
1085 |
astFactory->addASTChild( currentAST, returnAST ); |
1086 |
match(RPAREN); |
1087 |
match(SEMICOLON); |
1088 |
torsionstatement_AST = currentAST.root; |
1089 |
break; |
1090 |
} |
1091 |
default: |
1092 |
{ |
1093 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1094 |
} |
1095 |
} |
1096 |
} |
1097 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1098 |
reportError(ex); |
1099 |
recover(ex,_tokenSet_12); |
1100 |
} |
1101 |
returnAST = torsionstatement_AST; |
1102 |
} |
1103 |
|
1104 |
void MDParser::rigidbodystatement() { |
1105 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1106 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1107 |
ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1108 |
|
1109 |
try { // for error handling |
1110 |
switch ( LA(1)) { |
1111 |
case ID: |
1112 |
{ |
1113 |
assignment(); |
1114 |
astFactory->addASTChild( currentAST, returnAST ); |
1115 |
rigidbodystatement_AST = currentAST.root; |
1116 |
break; |
1117 |
} |
1118 |
case MEMBERS: |
1119 |
{ |
1120 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1121 |
tmp77_AST = astFactory->create(LT(1)); |
1122 |
astFactory->makeASTRoot(currentAST, tmp77_AST); |
1123 |
match(MEMBERS); |
1124 |
match(LPAREN); |
1125 |
inttuple(); |
1126 |
astFactory->addASTChild( currentAST, returnAST ); |
1127 |
match(RPAREN); |
1128 |
match(SEMICOLON); |
1129 |
rigidbodystatement_AST = currentAST.root; |
1130 |
break; |
1131 |
} |
1132 |
default: |
1133 |
{ |
1134 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1135 |
} |
1136 |
} |
1137 |
} |
1138 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1139 |
reportError(ex); |
1140 |
recover(ex,_tokenSet_12); |
1141 |
} |
1142 |
returnAST = rigidbodystatement_AST; |
1143 |
} |
1144 |
|
1145 |
void MDParser::cutoffgroupstatement() { |
1146 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1147 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1148 |
ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1149 |
|
1150 |
try { // for error handling |
1151 |
switch ( LA(1)) { |
1152 |
case ID: |
1153 |
{ |
1154 |
assignment(); |
1155 |
astFactory->addASTChild( currentAST, returnAST ); |
1156 |
cutoffgroupstatement_AST = currentAST.root; |
1157 |
break; |
1158 |
} |
1159 |
case MEMBERS: |
1160 |
{ |
1161 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1162 |
tmp81_AST = astFactory->create(LT(1)); |
1163 |
astFactory->makeASTRoot(currentAST, tmp81_AST); |
1164 |
match(MEMBERS); |
1165 |
match(LPAREN); |
1166 |
inttuple(); |
1167 |
astFactory->addASTChild( currentAST, returnAST ); |
1168 |
match(RPAREN); |
1169 |
match(SEMICOLON); |
1170 |
cutoffgroupstatement_AST = currentAST.root; |
1171 |
break; |
1172 |
} |
1173 |
default: |
1174 |
{ |
1175 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1176 |
} |
1177 |
} |
1178 |
} |
1179 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1180 |
reportError(ex); |
1181 |
recover(ex,_tokenSet_12); |
1182 |
} |
1183 |
returnAST = cutoffgroupstatement_AST; |
1184 |
} |
1185 |
|
1186 |
void MDParser::fragmentstatement() { |
1187 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1188 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1189 |
ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1190 |
|
1191 |
try { // for error handling |
1192 |
assignment(); |
1193 |
astFactory->addASTChild( currentAST, returnAST ); |
1194 |
fragmentstatement_AST = currentAST.root; |
1195 |
} |
1196 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1197 |
reportError(ex); |
1198 |
recover(ex,_tokenSet_13); |
1199 |
} |
1200 |
returnAST = fragmentstatement_AST; |
1201 |
} |
1202 |
|
1203 |
void MDParser::floatConst() { |
1204 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1205 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1206 |
ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1207 |
|
1208 |
try { // for error handling |
1209 |
switch ( LA(1)) { |
1210 |
case FLOATONE: |
1211 |
{ |
1212 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1213 |
tmp85_AST = astFactory->create(LT(1)); |
1214 |
astFactory->addASTChild(currentAST, tmp85_AST); |
1215 |
match(FLOATONE); |
1216 |
floatConst_AST = currentAST.root; |
1217 |
break; |
1218 |
} |
1219 |
case FLOATTWO: |
1220 |
{ |
1221 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1222 |
tmp86_AST = astFactory->create(LT(1)); |
1223 |
astFactory->addASTChild(currentAST, tmp86_AST); |
1224 |
match(FLOATTWO); |
1225 |
floatConst_AST = currentAST.root; |
1226 |
break; |
1227 |
} |
1228 |
default: |
1229 |
{ |
1230 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1231 |
} |
1232 |
} |
1233 |
} |
1234 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1235 |
reportError(ex); |
1236 |
recover(ex,_tokenSet_6); |
1237 |
} |
1238 |
returnAST = floatConst_AST; |
1239 |
} |
1240 |
|
1241 |
void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) |
1242 |
{ |
1243 |
factory.setMaxNodeType(55); |
1244 |
} |
1245 |
const char* MDParser::tokenNames[] = { |
1246 |
"<0>", |
1247 |
"EOF", |
1248 |
"<2>", |
1249 |
"NULL_TREE_LOOKAHEAD", |
1250 |
"\"component\"", |
1251 |
"\"molecule\"", |
1252 |
"\"zconstraint\"", |
1253 |
"\"atom\"", |
1254 |
"\"bond\"", |
1255 |
"\"bend\"", |
1256 |
"\"torsion\"", |
1257 |
"\"rigidBody\"", |
1258 |
"\"cutoffGroup\"", |
1259 |
"\"fragment\"", |
1260 |
"\"members\"", |
1261 |
"\"position\"", |
1262 |
"\"orientation\"", |
1263 |
"ENDBLOCK", |
1264 |
"ID", |
1265 |
"ASSIGNEQUAL", |
1266 |
"SEMICOLON", |
1267 |
"StringLiteral", |
1268 |
"LCURLY", |
1269 |
"RCURLY", |
1270 |
"LBRACKET", |
1271 |
"RBRACKET", |
1272 |
"LPAREN", |
1273 |
"RPAREN", |
1274 |
"COMMA", |
1275 |
"OCTALINT", |
1276 |
"DECIMALINT", |
1277 |
"HEXADECIMALINT", |
1278 |
"PLUS", |
1279 |
"MINUS", |
1280 |
"FLOATONE", |
1281 |
"FLOATTWO", |
1282 |
"DOT", |
1283 |
"COLON", |
1284 |
"QUESTIONMARK", |
1285 |
"Whitespace", |
1286 |
"Comment", |
1287 |
"CPPComment", |
1288 |
"a line directive", |
1289 |
"LineDirective", |
1290 |
"Space", |
1291 |
"CharLiteral", |
1292 |
"EndOfLine", |
1293 |
"Escape", |
1294 |
"Digit", |
1295 |
"Decimal", |
1296 |
"LongSuffix", |
1297 |
"UnsignedSuffix", |
1298 |
"FloatSuffix", |
1299 |
"Exponent", |
1300 |
"Vocabulary", |
1301 |
"Number", |
1302 |
0 |
1303 |
}; |
1304 |
|
1305 |
const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL }; |
1306 |
// "component" "molecule" "zconstraint" ID |
1307 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4); |
1308 |
const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL }; |
1309 |
// EOF |
1310 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4); |
1311 |
const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL }; |
1312 |
// EOF "component" "molecule" "zconstraint" ID |
1313 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4); |
1314 |
const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL }; |
1315 |
// EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion" |
1316 |
// "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation" |
1317 |
// ID RCURLY |
1318 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4); |
1319 |
const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL }; |
1320 |
// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" |
1321 |
// ID |
1322 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4); |
1323 |
const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL }; |
1324 |
// SEMICOLON |
1325 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4); |
1326 |
const unsigned long MDParser::_tokenSet_6_data_[] = { 403701760UL, 0UL, 0UL, 0UL }; |
1327 |
// SEMICOLON RPAREN COMMA |
1328 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4); |
1329 |
const unsigned long MDParser::_tokenSet_7_data_[] = { 8667008UL, 0UL, 0UL, 0UL }; |
1330 |
// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" |
1331 |
// ID RCURLY |
1332 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4); |
1333 |
const unsigned long MDParser::_tokenSet_8_data_[] = { 360448UL, 0UL, 0UL, 0UL }; |
1334 |
// "position" "orientation" ID |
1335 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4); |
1336 |
const unsigned long MDParser::_tokenSet_9_data_[] = { 437256192UL, 0UL, 0UL, 0UL }; |
1337 |
// SEMICOLON RBRACKET RPAREN COMMA |
1338 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4); |
1339 |
const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL }; |
1340 |
// "position" "orientation" ID RCURLY |
1341 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4); |
1342 |
const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL }; |
1343 |
// RPAREN |
1344 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4); |
1345 |
const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL }; |
1346 |
// "members" ID RCURLY |
1347 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4); |
1348 |
const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL }; |
1349 |
// ID RCURLY |
1350 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4); |
1351 |
|
1352 |
|