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 62 "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 68 "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 65 "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 FLOATONE: |
266 |
case FLOATTWO: |
267 |
{ |
268 |
signedNumber(); |
269 |
astFactory->addASTChild( currentAST, returnAST ); |
270 |
constant_AST = currentAST.root; |
271 |
break; |
272 |
} |
273 |
case ID: |
274 |
{ |
275 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp13_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
276 |
tmp13_AST = astFactory->create(LT(1)); |
277 |
astFactory->addASTChild(currentAST, tmp13_AST); |
278 |
match(ID); |
279 |
constant_AST = currentAST.root; |
280 |
break; |
281 |
} |
282 |
case StringLiteral: |
283 |
{ |
284 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp14_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
285 |
tmp14_AST = astFactory->create(LT(1)); |
286 |
astFactory->addASTChild(currentAST, tmp14_AST); |
287 |
match(StringLiteral); |
288 |
constant_AST = currentAST.root; |
289 |
break; |
290 |
} |
291 |
default: |
292 |
{ |
293 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
294 |
} |
295 |
} |
296 |
} |
297 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
298 |
reportError(ex); |
299 |
recover(ex,_tokenSet_5); |
300 |
} |
301 |
returnAST = constant_AST; |
302 |
} |
303 |
|
304 |
void MDParser::signedNumber() { |
305 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
306 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
307 |
ANTLR_USE_NAMESPACE(antlr)RefAST signedNumber_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
308 |
|
309 |
try { // for error handling |
310 |
{ |
311 |
switch ( LA(1)) { |
312 |
case OCTALINT: |
313 |
case DECIMALINT: |
314 |
case HEXADECIMALINT: |
315 |
{ |
316 |
intConst(); |
317 |
astFactory->addASTChild( currentAST, returnAST ); |
318 |
break; |
319 |
} |
320 |
case FLOATONE: |
321 |
case FLOATTWO: |
322 |
{ |
323 |
floatConst(); |
324 |
astFactory->addASTChild( currentAST, returnAST ); |
325 |
break; |
326 |
} |
327 |
default: |
328 |
{ |
329 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
330 |
} |
331 |
} |
332 |
} |
333 |
signedNumber_AST = currentAST.root; |
334 |
} |
335 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
336 |
reportError(ex); |
337 |
recover(ex,_tokenSet_6); |
338 |
} |
339 |
returnAST = signedNumber_AST; |
340 |
} |
341 |
|
342 |
void MDParser::moleculestatement() { |
343 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
344 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
345 |
ANTLR_USE_NAMESPACE(antlr)RefAST moleculestatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
346 |
|
347 |
try { // for error handling |
348 |
switch ( LA(1)) { |
349 |
case ID: |
350 |
{ |
351 |
assignment(); |
352 |
astFactory->addASTChild( currentAST, returnAST ); |
353 |
moleculestatement_AST = currentAST.root; |
354 |
break; |
355 |
} |
356 |
case ATOM: |
357 |
{ |
358 |
atomblock(); |
359 |
astFactory->addASTChild( currentAST, returnAST ); |
360 |
moleculestatement_AST = currentAST.root; |
361 |
break; |
362 |
} |
363 |
case BOND: |
364 |
{ |
365 |
bondblock(); |
366 |
astFactory->addASTChild( currentAST, returnAST ); |
367 |
moleculestatement_AST = currentAST.root; |
368 |
break; |
369 |
} |
370 |
case BEND: |
371 |
{ |
372 |
bendblock(); |
373 |
astFactory->addASTChild( currentAST, returnAST ); |
374 |
moleculestatement_AST = currentAST.root; |
375 |
break; |
376 |
} |
377 |
case TORSION: |
378 |
{ |
379 |
torsionblock(); |
380 |
astFactory->addASTChild( currentAST, returnAST ); |
381 |
moleculestatement_AST = currentAST.root; |
382 |
break; |
383 |
} |
384 |
case RIGIDBODY: |
385 |
{ |
386 |
rigidbodyblock(); |
387 |
astFactory->addASTChild( currentAST, returnAST ); |
388 |
moleculestatement_AST = currentAST.root; |
389 |
break; |
390 |
} |
391 |
case CUTOFFGROUP: |
392 |
{ |
393 |
cutoffgroupblock(); |
394 |
astFactory->addASTChild( currentAST, returnAST ); |
395 |
moleculestatement_AST = currentAST.root; |
396 |
break; |
397 |
} |
398 |
case FRAGMENT: |
399 |
{ |
400 |
fragmentblock(); |
401 |
astFactory->addASTChild( currentAST, returnAST ); |
402 |
moleculestatement_AST = currentAST.root; |
403 |
break; |
404 |
} |
405 |
default: |
406 |
{ |
407 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
408 |
} |
409 |
} |
410 |
} |
411 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
412 |
reportError(ex); |
413 |
recover(ex,_tokenSet_7); |
414 |
} |
415 |
returnAST = moleculestatement_AST; |
416 |
} |
417 |
|
418 |
void MDParser::atomblock() { |
419 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
420 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
421 |
ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
422 |
|
423 |
try { // for error handling |
424 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp15_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
425 |
tmp15_AST = astFactory->create(LT(1)); |
426 |
astFactory->makeASTRoot(currentAST, tmp15_AST); |
427 |
match(ATOM); |
428 |
match(LBRACKET); |
429 |
intConst(); |
430 |
astFactory->addASTChild( currentAST, returnAST ); |
431 |
match(RBRACKET); |
432 |
match(LCURLY); |
433 |
{ // ( ... )* |
434 |
for (;;) { |
435 |
if ((_tokenSet_8.member(LA(1)))) { |
436 |
atomstatement(); |
437 |
astFactory->addASTChild( currentAST, returnAST ); |
438 |
} |
439 |
else { |
440 |
goto _loop19; |
441 |
} |
442 |
|
443 |
} |
444 |
_loop19:; |
445 |
} // ( ... )* |
446 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
447 |
tmp19_AST = astFactory->create(LT(1)); |
448 |
astFactory->addASTChild(currentAST, tmp19_AST); |
449 |
match(RCURLY); |
450 |
#line 81 "MDParser.g" |
451 |
tmp19_AST->setType(ENDBLOCK); |
452 |
#line 453 "MDParser.cpp" |
453 |
atomblock_AST = currentAST.root; |
454 |
} |
455 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
456 |
reportError(ex); |
457 |
recover(ex,_tokenSet_7); |
458 |
} |
459 |
returnAST = atomblock_AST; |
460 |
} |
461 |
|
462 |
void MDParser::bondblock() { |
463 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
464 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
465 |
ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
466 |
|
467 |
try { // for error handling |
468 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
469 |
tmp20_AST = astFactory->create(LT(1)); |
470 |
astFactory->makeASTRoot(currentAST, tmp20_AST); |
471 |
match(BOND); |
472 |
{ |
473 |
switch ( LA(1)) { |
474 |
case LBRACKET: |
475 |
{ |
476 |
match(LBRACKET); |
477 |
intConst(); |
478 |
match(RBRACKET); |
479 |
break; |
480 |
} |
481 |
case LCURLY: |
482 |
{ |
483 |
break; |
484 |
} |
485 |
default: |
486 |
{ |
487 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
488 |
} |
489 |
} |
490 |
} |
491 |
match(LCURLY); |
492 |
{ // ( ... )* |
493 |
for (;;) { |
494 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
495 |
bondstatement(); |
496 |
astFactory->addASTChild( currentAST, returnAST ); |
497 |
} |
498 |
else { |
499 |
goto _loop24; |
500 |
} |
501 |
|
502 |
} |
503 |
_loop24:; |
504 |
} // ( ... )* |
505 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
506 |
tmp24_AST = astFactory->create(LT(1)); |
507 |
astFactory->addASTChild(currentAST, tmp24_AST); |
508 |
match(RCURLY); |
509 |
#line 90 "MDParser.g" |
510 |
tmp24_AST->setType(ENDBLOCK); |
511 |
#line 512 "MDParser.cpp" |
512 |
bondblock_AST = currentAST.root; |
513 |
} |
514 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
515 |
reportError(ex); |
516 |
recover(ex,_tokenSet_7); |
517 |
} |
518 |
returnAST = bondblock_AST; |
519 |
} |
520 |
|
521 |
void MDParser::bendblock() { |
522 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
523 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
524 |
ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
525 |
|
526 |
try { // for error handling |
527 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
528 |
tmp25_AST = astFactory->create(LT(1)); |
529 |
astFactory->makeASTRoot(currentAST, tmp25_AST); |
530 |
match(BEND); |
531 |
{ |
532 |
switch ( LA(1)) { |
533 |
case LBRACKET: |
534 |
{ |
535 |
match(LBRACKET); |
536 |
intConst(); |
537 |
match(RBRACKET); |
538 |
break; |
539 |
} |
540 |
case LCURLY: |
541 |
{ |
542 |
break; |
543 |
} |
544 |
default: |
545 |
{ |
546 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
547 |
} |
548 |
} |
549 |
} |
550 |
match(LCURLY); |
551 |
{ // ( ... )* |
552 |
for (;;) { |
553 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
554 |
bendstatement(); |
555 |
astFactory->addASTChild( currentAST, returnAST ); |
556 |
} |
557 |
else { |
558 |
goto _loop29; |
559 |
} |
560 |
|
561 |
} |
562 |
_loop29:; |
563 |
} // ( ... )* |
564 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp29_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
565 |
tmp29_AST = astFactory->create(LT(1)); |
566 |
astFactory->addASTChild(currentAST, tmp29_AST); |
567 |
match(RCURLY); |
568 |
#line 97 "MDParser.g" |
569 |
tmp29_AST->setType(ENDBLOCK); |
570 |
#line 571 "MDParser.cpp" |
571 |
bendblock_AST = currentAST.root; |
572 |
} |
573 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
574 |
reportError(ex); |
575 |
recover(ex,_tokenSet_7); |
576 |
} |
577 |
returnAST = bendblock_AST; |
578 |
} |
579 |
|
580 |
void MDParser::torsionblock() { |
581 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
582 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
583 |
ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
584 |
|
585 |
try { // for error handling |
586 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp30_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
587 |
tmp30_AST = astFactory->create(LT(1)); |
588 |
astFactory->makeASTRoot(currentAST, tmp30_AST); |
589 |
match(TORSION); |
590 |
{ |
591 |
switch ( LA(1)) { |
592 |
case LBRACKET: |
593 |
{ |
594 |
match(LBRACKET); |
595 |
intConst(); |
596 |
match(RBRACKET); |
597 |
break; |
598 |
} |
599 |
case LCURLY: |
600 |
{ |
601 |
break; |
602 |
} |
603 |
default: |
604 |
{ |
605 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
606 |
} |
607 |
} |
608 |
} |
609 |
match(LCURLY); |
610 |
{ // ( ... )* |
611 |
for (;;) { |
612 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
613 |
torsionstatement(); |
614 |
astFactory->addASTChild( currentAST, returnAST ); |
615 |
} |
616 |
else { |
617 |
goto _loop34; |
618 |
} |
619 |
|
620 |
} |
621 |
_loop34:; |
622 |
} // ( ... )* |
623 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp34_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
624 |
tmp34_AST = astFactory->create(LT(1)); |
625 |
astFactory->addASTChild(currentAST, tmp34_AST); |
626 |
match(RCURLY); |
627 |
#line 104 "MDParser.g" |
628 |
tmp34_AST->setType(ENDBLOCK); |
629 |
#line 630 "MDParser.cpp" |
630 |
torsionblock_AST = currentAST.root; |
631 |
} |
632 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
633 |
reportError(ex); |
634 |
recover(ex,_tokenSet_7); |
635 |
} |
636 |
returnAST = torsionblock_AST; |
637 |
} |
638 |
|
639 |
void MDParser::rigidbodyblock() { |
640 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
641 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
642 |
ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
643 |
|
644 |
try { // for error handling |
645 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp35_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
646 |
tmp35_AST = astFactory->create(LT(1)); |
647 |
astFactory->makeASTRoot(currentAST, tmp35_AST); |
648 |
match(RIGIDBODY); |
649 |
match(LBRACKET); |
650 |
intConst(); |
651 |
astFactory->addASTChild( currentAST, returnAST ); |
652 |
match(RBRACKET); |
653 |
match(LCURLY); |
654 |
{ // ( ... )* |
655 |
for (;;) { |
656 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
657 |
rigidbodystatement(); |
658 |
astFactory->addASTChild( currentAST, returnAST ); |
659 |
} |
660 |
else { |
661 |
goto _loop38; |
662 |
} |
663 |
|
664 |
} |
665 |
_loop38:; |
666 |
} // ( ... )* |
667 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp39_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
668 |
tmp39_AST = astFactory->create(LT(1)); |
669 |
astFactory->addASTChild(currentAST, tmp39_AST); |
670 |
match(RCURLY); |
671 |
#line 111 "MDParser.g" |
672 |
tmp39_AST->setType(ENDBLOCK); |
673 |
#line 674 "MDParser.cpp" |
674 |
rigidbodyblock_AST = currentAST.root; |
675 |
} |
676 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
677 |
reportError(ex); |
678 |
recover(ex,_tokenSet_7); |
679 |
} |
680 |
returnAST = rigidbodyblock_AST; |
681 |
} |
682 |
|
683 |
void MDParser::cutoffgroupblock() { |
684 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
685 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
686 |
ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
687 |
|
688 |
try { // for error handling |
689 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp40_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
690 |
tmp40_AST = astFactory->create(LT(1)); |
691 |
astFactory->makeASTRoot(currentAST, tmp40_AST); |
692 |
match(CUTOFFGROUP); |
693 |
{ |
694 |
switch ( LA(1)) { |
695 |
case LBRACKET: |
696 |
{ |
697 |
match(LBRACKET); |
698 |
intConst(); |
699 |
match(RBRACKET); |
700 |
break; |
701 |
} |
702 |
case LCURLY: |
703 |
{ |
704 |
break; |
705 |
} |
706 |
default: |
707 |
{ |
708 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
709 |
} |
710 |
} |
711 |
} |
712 |
match(LCURLY); |
713 |
{ // ( ... )* |
714 |
for (;;) { |
715 |
if ((LA(1) == MEMBERS || LA(1) == ID)) { |
716 |
cutoffgroupstatement(); |
717 |
astFactory->addASTChild( currentAST, returnAST ); |
718 |
} |
719 |
else { |
720 |
goto _loop43; |
721 |
} |
722 |
|
723 |
} |
724 |
_loop43:; |
725 |
} // ( ... )* |
726 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp44_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
727 |
tmp44_AST = astFactory->create(LT(1)); |
728 |
astFactory->addASTChild(currentAST, tmp44_AST); |
729 |
match(RCURLY); |
730 |
#line 118 "MDParser.g" |
731 |
tmp44_AST->setType(ENDBLOCK); |
732 |
#line 733 "MDParser.cpp" |
733 |
cutoffgroupblock_AST = currentAST.root; |
734 |
} |
735 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
736 |
reportError(ex); |
737 |
recover(ex,_tokenSet_7); |
738 |
} |
739 |
returnAST = cutoffgroupblock_AST; |
740 |
} |
741 |
|
742 |
void MDParser::fragmentblock() { |
743 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
744 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
745 |
ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
746 |
|
747 |
try { // for error handling |
748 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp45_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
749 |
tmp45_AST = astFactory->create(LT(1)); |
750 |
astFactory->makeASTRoot(currentAST, tmp45_AST); |
751 |
match(FRAGMENT); |
752 |
match(LBRACKET); |
753 |
intConst(); |
754 |
astFactory->addASTChild( currentAST, returnAST ); |
755 |
match(RBRACKET); |
756 |
match(LCURLY); |
757 |
{ // ( ... )* |
758 |
for (;;) { |
759 |
if ((LA(1) == ID)) { |
760 |
fragmentstatement(); |
761 |
astFactory->addASTChild( currentAST, returnAST ); |
762 |
} |
763 |
else { |
764 |
goto _loop47; |
765 |
} |
766 |
|
767 |
} |
768 |
_loop47:; |
769 |
} // ( ... )* |
770 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp49_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
771 |
tmp49_AST = astFactory->create(LT(1)); |
772 |
astFactory->addASTChild(currentAST, tmp49_AST); |
773 |
match(RCURLY); |
774 |
#line 125 "MDParser.g" |
775 |
tmp49_AST->setType(ENDBLOCK); |
776 |
#line 777 "MDParser.cpp" |
777 |
fragmentblock_AST = currentAST.root; |
778 |
} |
779 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
780 |
reportError(ex); |
781 |
recover(ex,_tokenSet_7); |
782 |
} |
783 |
returnAST = fragmentblock_AST; |
784 |
} |
785 |
|
786 |
void MDParser::intConst() { |
787 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
788 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
789 |
ANTLR_USE_NAMESPACE(antlr)RefAST intConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
790 |
|
791 |
try { // for error handling |
792 |
switch ( LA(1)) { |
793 |
case OCTALINT: |
794 |
{ |
795 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp50_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
796 |
tmp50_AST = astFactory->create(LT(1)); |
797 |
astFactory->addASTChild(currentAST, tmp50_AST); |
798 |
match(OCTALINT); |
799 |
intConst_AST = currentAST.root; |
800 |
break; |
801 |
} |
802 |
case DECIMALINT: |
803 |
{ |
804 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
805 |
tmp51_AST = astFactory->create(LT(1)); |
806 |
astFactory->addASTChild(currentAST, tmp51_AST); |
807 |
match(DECIMALINT); |
808 |
intConst_AST = currentAST.root; |
809 |
break; |
810 |
} |
811 |
case HEXADECIMALINT: |
812 |
{ |
813 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
814 |
tmp52_AST = astFactory->create(LT(1)); |
815 |
astFactory->addASTChild(currentAST, tmp52_AST); |
816 |
match(HEXADECIMALINT); |
817 |
intConst_AST = currentAST.root; |
818 |
break; |
819 |
} |
820 |
default: |
821 |
{ |
822 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
823 |
} |
824 |
} |
825 |
} |
826 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
827 |
reportError(ex); |
828 |
recover(ex,_tokenSet_9); |
829 |
} |
830 |
returnAST = intConst_AST; |
831 |
} |
832 |
|
833 |
void MDParser::atomstatement() { |
834 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
835 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
836 |
ANTLR_USE_NAMESPACE(antlr)RefAST atomstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
837 |
|
838 |
try { // for error handling |
839 |
switch ( LA(1)) { |
840 |
case ID: |
841 |
{ |
842 |
assignment(); |
843 |
astFactory->addASTChild( currentAST, returnAST ); |
844 |
atomstatement_AST = currentAST.root; |
845 |
break; |
846 |
} |
847 |
case POSITION: |
848 |
{ |
849 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
850 |
tmp53_AST = astFactory->create(LT(1)); |
851 |
astFactory->makeASTRoot(currentAST, tmp53_AST); |
852 |
match(POSITION); |
853 |
match(LPAREN); |
854 |
signedNumberTuple(); |
855 |
astFactory->addASTChild( currentAST, returnAST ); |
856 |
match(RPAREN); |
857 |
match(SEMICOLON); |
858 |
atomstatement_AST = currentAST.root; |
859 |
break; |
860 |
} |
861 |
case ORIENTATION: |
862 |
{ |
863 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
864 |
tmp57_AST = astFactory->create(LT(1)); |
865 |
astFactory->makeASTRoot(currentAST, tmp57_AST); |
866 |
match(ORIENTATION); |
867 |
match(LPAREN); |
868 |
signedNumberTuple(); |
869 |
astFactory->addASTChild( currentAST, returnAST ); |
870 |
match(RPAREN); |
871 |
match(SEMICOLON); |
872 |
atomstatement_AST = currentAST.root; |
873 |
break; |
874 |
} |
875 |
default: |
876 |
{ |
877 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
878 |
} |
879 |
} |
880 |
} |
881 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
882 |
reportError(ex); |
883 |
recover(ex,_tokenSet_10); |
884 |
} |
885 |
returnAST = atomstatement_AST; |
886 |
} |
887 |
|
888 |
void MDParser::signedNumberTuple() { |
889 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
890 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
891 |
ANTLR_USE_NAMESPACE(antlr)RefAST signedNumberTuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
892 |
|
893 |
try { // for error handling |
894 |
signedNumber(); |
895 |
astFactory->addASTChild( currentAST, returnAST ); |
896 |
{ // ( ... )* |
897 |
for (;;) { |
898 |
if ((LA(1) == COMMA)) { |
899 |
match(COMMA); |
900 |
signedNumber(); |
901 |
astFactory->addASTChild( currentAST, returnAST ); |
902 |
} |
903 |
else { |
904 |
goto _loop51; |
905 |
} |
906 |
|
907 |
} |
908 |
_loop51:; |
909 |
} // ( ... )* |
910 |
signedNumberTuple_AST = currentAST.root; |
911 |
} |
912 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
913 |
reportError(ex); |
914 |
recover(ex,_tokenSet_11); |
915 |
} |
916 |
returnAST = signedNumberTuple_AST; |
917 |
} |
918 |
|
919 |
void MDParser::bondstatement() { |
920 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
921 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
922 |
ANTLR_USE_NAMESPACE(antlr)RefAST bondstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
923 |
|
924 |
try { // for error handling |
925 |
switch ( LA(1)) { |
926 |
case ID: |
927 |
{ |
928 |
assignment(); |
929 |
astFactory->addASTChild( currentAST, returnAST ); |
930 |
bondstatement_AST = currentAST.root; |
931 |
break; |
932 |
} |
933 |
case MEMBERS: |
934 |
{ |
935 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
936 |
tmp62_AST = astFactory->create(LT(1)); |
937 |
astFactory->makeASTRoot(currentAST, tmp62_AST); |
938 |
match(MEMBERS); |
939 |
match(LPAREN); |
940 |
inttuple(); |
941 |
astFactory->addASTChild( currentAST, returnAST ); |
942 |
match(RPAREN); |
943 |
match(SEMICOLON); |
944 |
bondstatement_AST = currentAST.root; |
945 |
break; |
946 |
} |
947 |
default: |
948 |
{ |
949 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
950 |
} |
951 |
} |
952 |
} |
953 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
954 |
reportError(ex); |
955 |
recover(ex,_tokenSet_12); |
956 |
} |
957 |
returnAST = bondstatement_AST; |
958 |
} |
959 |
|
960 |
void MDParser::inttuple() { |
961 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
962 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
963 |
ANTLR_USE_NAMESPACE(antlr)RefAST inttuple_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
964 |
|
965 |
try { // for error handling |
966 |
intConst(); |
967 |
astFactory->addASTChild( currentAST, returnAST ); |
968 |
{ // ( ... )* |
969 |
for (;;) { |
970 |
if ((LA(1) == COMMA)) { |
971 |
match(COMMA); |
972 |
intConst(); |
973 |
astFactory->addASTChild( currentAST, returnAST ); |
974 |
} |
975 |
else { |
976 |
goto _loop54; |
977 |
} |
978 |
|
979 |
} |
980 |
_loop54:; |
981 |
} // ( ... )* |
982 |
inttuple_AST = currentAST.root; |
983 |
} |
984 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
985 |
reportError(ex); |
986 |
recover(ex,_tokenSet_11); |
987 |
} |
988 |
returnAST = inttuple_AST; |
989 |
} |
990 |
|
991 |
void MDParser::bendstatement() { |
992 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
993 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
994 |
ANTLR_USE_NAMESPACE(antlr)RefAST bendstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
995 |
|
996 |
try { // for error handling |
997 |
switch ( LA(1)) { |
998 |
case ID: |
999 |
{ |
1000 |
assignment(); |
1001 |
astFactory->addASTChild( currentAST, returnAST ); |
1002 |
bendstatement_AST = currentAST.root; |
1003 |
break; |
1004 |
} |
1005 |
case MEMBERS: |
1006 |
{ |
1007 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1008 |
tmp67_AST = astFactory->create(LT(1)); |
1009 |
astFactory->makeASTRoot(currentAST, tmp67_AST); |
1010 |
match(MEMBERS); |
1011 |
match(LPAREN); |
1012 |
inttuple(); |
1013 |
astFactory->addASTChild( currentAST, returnAST ); |
1014 |
match(RPAREN); |
1015 |
match(SEMICOLON); |
1016 |
bendstatement_AST = currentAST.root; |
1017 |
break; |
1018 |
} |
1019 |
default: |
1020 |
{ |
1021 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1022 |
} |
1023 |
} |
1024 |
} |
1025 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1026 |
reportError(ex); |
1027 |
recover(ex,_tokenSet_12); |
1028 |
} |
1029 |
returnAST = bendstatement_AST; |
1030 |
} |
1031 |
|
1032 |
void MDParser::torsionstatement() { |
1033 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1034 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1035 |
ANTLR_USE_NAMESPACE(antlr)RefAST torsionstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1036 |
|
1037 |
try { // for error handling |
1038 |
switch ( LA(1)) { |
1039 |
case ID: |
1040 |
{ |
1041 |
assignment(); |
1042 |
astFactory->addASTChild( currentAST, returnAST ); |
1043 |
torsionstatement_AST = currentAST.root; |
1044 |
break; |
1045 |
} |
1046 |
case MEMBERS: |
1047 |
{ |
1048 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1049 |
tmp71_AST = astFactory->create(LT(1)); |
1050 |
astFactory->makeASTRoot(currentAST, tmp71_AST); |
1051 |
match(MEMBERS); |
1052 |
match(LPAREN); |
1053 |
inttuple(); |
1054 |
astFactory->addASTChild( currentAST, returnAST ); |
1055 |
match(RPAREN); |
1056 |
match(SEMICOLON); |
1057 |
torsionstatement_AST = currentAST.root; |
1058 |
break; |
1059 |
} |
1060 |
default: |
1061 |
{ |
1062 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1063 |
} |
1064 |
} |
1065 |
} |
1066 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1067 |
reportError(ex); |
1068 |
recover(ex,_tokenSet_12); |
1069 |
} |
1070 |
returnAST = torsionstatement_AST; |
1071 |
} |
1072 |
|
1073 |
void MDParser::rigidbodystatement() { |
1074 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1075 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1076 |
ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodystatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1077 |
|
1078 |
try { // for error handling |
1079 |
switch ( LA(1)) { |
1080 |
case ID: |
1081 |
{ |
1082 |
assignment(); |
1083 |
astFactory->addASTChild( currentAST, returnAST ); |
1084 |
rigidbodystatement_AST = currentAST.root; |
1085 |
break; |
1086 |
} |
1087 |
case MEMBERS: |
1088 |
{ |
1089 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp75_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1090 |
tmp75_AST = astFactory->create(LT(1)); |
1091 |
astFactory->makeASTRoot(currentAST, tmp75_AST); |
1092 |
match(MEMBERS); |
1093 |
match(LPAREN); |
1094 |
inttuple(); |
1095 |
astFactory->addASTChild( currentAST, returnAST ); |
1096 |
match(RPAREN); |
1097 |
match(SEMICOLON); |
1098 |
rigidbodystatement_AST = currentAST.root; |
1099 |
break; |
1100 |
} |
1101 |
default: |
1102 |
{ |
1103 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1104 |
} |
1105 |
} |
1106 |
} |
1107 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1108 |
reportError(ex); |
1109 |
recover(ex,_tokenSet_12); |
1110 |
} |
1111 |
returnAST = rigidbodystatement_AST; |
1112 |
} |
1113 |
|
1114 |
void MDParser::cutoffgroupstatement() { |
1115 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1116 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1117 |
ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1118 |
|
1119 |
try { // for error handling |
1120 |
switch ( LA(1)) { |
1121 |
case ID: |
1122 |
{ |
1123 |
assignment(); |
1124 |
astFactory->addASTChild( currentAST, returnAST ); |
1125 |
cutoffgroupstatement_AST = currentAST.root; |
1126 |
break; |
1127 |
} |
1128 |
case MEMBERS: |
1129 |
{ |
1130 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp79_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1131 |
tmp79_AST = astFactory->create(LT(1)); |
1132 |
astFactory->makeASTRoot(currentAST, tmp79_AST); |
1133 |
match(MEMBERS); |
1134 |
match(LPAREN); |
1135 |
inttuple(); |
1136 |
astFactory->addASTChild( currentAST, returnAST ); |
1137 |
match(RPAREN); |
1138 |
match(SEMICOLON); |
1139 |
cutoffgroupstatement_AST = currentAST.root; |
1140 |
break; |
1141 |
} |
1142 |
default: |
1143 |
{ |
1144 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1145 |
} |
1146 |
} |
1147 |
} |
1148 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1149 |
reportError(ex); |
1150 |
recover(ex,_tokenSet_12); |
1151 |
} |
1152 |
returnAST = cutoffgroupstatement_AST; |
1153 |
} |
1154 |
|
1155 |
void MDParser::fragmentstatement() { |
1156 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1157 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1158 |
ANTLR_USE_NAMESPACE(antlr)RefAST fragmentstatement_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1159 |
|
1160 |
try { // for error handling |
1161 |
assignment(); |
1162 |
astFactory->addASTChild( currentAST, returnAST ); |
1163 |
fragmentstatement_AST = currentAST.root; |
1164 |
} |
1165 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1166 |
reportError(ex); |
1167 |
recover(ex,_tokenSet_13); |
1168 |
} |
1169 |
returnAST = fragmentstatement_AST; |
1170 |
} |
1171 |
|
1172 |
void MDParser::floatConst() { |
1173 |
returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1174 |
ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; |
1175 |
ANTLR_USE_NAMESPACE(antlr)RefAST floatConst_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1176 |
|
1177 |
try { // for error handling |
1178 |
switch ( LA(1)) { |
1179 |
case FLOATONE: |
1180 |
{ |
1181 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp83_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1182 |
tmp83_AST = astFactory->create(LT(1)); |
1183 |
astFactory->addASTChild(currentAST, tmp83_AST); |
1184 |
match(FLOATONE); |
1185 |
floatConst_AST = currentAST.root; |
1186 |
break; |
1187 |
} |
1188 |
case FLOATTWO: |
1189 |
{ |
1190 |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1191 |
tmp84_AST = astFactory->create(LT(1)); |
1192 |
astFactory->addASTChild(currentAST, tmp84_AST); |
1193 |
match(FLOATTWO); |
1194 |
floatConst_AST = currentAST.root; |
1195 |
break; |
1196 |
} |
1197 |
default: |
1198 |
{ |
1199 |
throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); |
1200 |
} |
1201 |
} |
1202 |
} |
1203 |
catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { |
1204 |
reportError(ex); |
1205 |
recover(ex,_tokenSet_6); |
1206 |
} |
1207 |
returnAST = floatConst_AST; |
1208 |
} |
1209 |
|
1210 |
void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) |
1211 |
{ |
1212 |
factory.setMaxNodeType(53); |
1213 |
} |
1214 |
const char* MDParser::tokenNames[] = { |
1215 |
"<0>", |
1216 |
"EOF", |
1217 |
"<2>", |
1218 |
"NULL_TREE_LOOKAHEAD", |
1219 |
"\"component\"", |
1220 |
"\"molecule\"", |
1221 |
"\"zconstraint\"", |
1222 |
"\"atom\"", |
1223 |
"\"bond\"", |
1224 |
"\"bend\"", |
1225 |
"\"torsion\"", |
1226 |
"\"rigidBody\"", |
1227 |
"\"cutoffGroup\"", |
1228 |
"\"fragment\"", |
1229 |
"\"members\"", |
1230 |
"\"position\"", |
1231 |
"\"orientation\"", |
1232 |
"ENDBLOCK", |
1233 |
"ID", |
1234 |
"ASSIGNEQUAL", |
1235 |
"SEMICOLON", |
1236 |
"StringLiteral", |
1237 |
"LCURLY", |
1238 |
"RCURLY", |
1239 |
"LBRACKET", |
1240 |
"RBRACKET", |
1241 |
"LPAREN", |
1242 |
"RPAREN", |
1243 |
"COMMA", |
1244 |
"OCTALINT", |
1245 |
"DECIMALINT", |
1246 |
"HEXADECIMALINT", |
1247 |
"FLOATONE", |
1248 |
"FLOATTWO", |
1249 |
"DOT", |
1250 |
"COLON", |
1251 |
"QUESTIONMARK", |
1252 |
"Whitespace", |
1253 |
"Comment", |
1254 |
"CPPComment", |
1255 |
"a line directive", |
1256 |
"LineDirective", |
1257 |
"Space", |
1258 |
"CharLiteral", |
1259 |
"EndOfLine", |
1260 |
"Escape", |
1261 |
"Digit", |
1262 |
"Decimal", |
1263 |
"LongSuffix", |
1264 |
"UnsignedSuffix", |
1265 |
"FloatSuffix", |
1266 |
"Exponent", |
1267 |
"Vocabulary", |
1268 |
"Number", |
1269 |
0 |
1270 |
}; |
1271 |
|
1272 |
const unsigned long MDParser::_tokenSet_0_data_[] = { 262256UL, 0UL, 0UL, 0UL }; |
1273 |
// "component" "molecule" "zconstraint" ID |
1274 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4); |
1275 |
const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL }; |
1276 |
// EOF |
1277 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4); |
1278 |
const unsigned long MDParser::_tokenSet_2_data_[] = { 262258UL, 0UL, 0UL, 0UL }; |
1279 |
// EOF "component" "molecule" "zconstraint" ID |
1280 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4); |
1281 |
const unsigned long MDParser::_tokenSet_3_data_[] = { 8781810UL, 0UL, 0UL, 0UL }; |
1282 |
// EOF "component" "molecule" "zconstraint" "atom" "bond" "bend" "torsion" |
1283 |
// "rigidBody" "cutoffGroup" "fragment" "members" "position" "orientation" |
1284 |
// ID RCURLY |
1285 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4); |
1286 |
const unsigned long MDParser::_tokenSet_4_data_[] = { 278400UL, 0UL, 0UL, 0UL }; |
1287 |
// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" |
1288 |
// ID |
1289 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4); |
1290 |
const unsigned long MDParser::_tokenSet_5_data_[] = { 1048576UL, 0UL, 0UL, 0UL }; |
1291 |
// SEMICOLON |
1292 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4); |
1293 |
const unsigned long MDParser::_tokenSet_6_data_[] = { 403701760UL, 0UL, 0UL, 0UL }; |
1294 |
// SEMICOLON RPAREN COMMA |
1295 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4); |
1296 |
const unsigned long MDParser::_tokenSet_7_data_[] = { 8667008UL, 0UL, 0UL, 0UL }; |
1297 |
// "atom" "bond" "bend" "torsion" "rigidBody" "cutoffGroup" "fragment" |
1298 |
// ID RCURLY |
1299 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4); |
1300 |
const unsigned long MDParser::_tokenSet_8_data_[] = { 360448UL, 0UL, 0UL, 0UL }; |
1301 |
// "position" "orientation" ID |
1302 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4); |
1303 |
const unsigned long MDParser::_tokenSet_9_data_[] = { 437256192UL, 0UL, 0UL, 0UL }; |
1304 |
// SEMICOLON RBRACKET RPAREN COMMA |
1305 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4); |
1306 |
const unsigned long MDParser::_tokenSet_10_data_[] = { 8749056UL, 0UL, 0UL, 0UL }; |
1307 |
// "position" "orientation" ID RCURLY |
1308 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4); |
1309 |
const unsigned long MDParser::_tokenSet_11_data_[] = { 134217728UL, 0UL, 0UL, 0UL }; |
1310 |
// RPAREN |
1311 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4); |
1312 |
const unsigned long MDParser::_tokenSet_12_data_[] = { 8667136UL, 0UL, 0UL, 0UL }; |
1313 |
// "members" ID RCURLY |
1314 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4); |
1315 |
const unsigned long MDParser::_tokenSet_13_data_[] = { 8650752UL, 0UL, 0UL, 0UL }; |
1316 |
// ID RCURLY |
1317 |
const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4); |
1318 |
|
1319 |
|