160 |
|
tmp6_AST = astFactory->create(LT(1)); |
161 |
|
astFactory->addASTChild(currentAST, tmp6_AST); |
162 |
|
match(RCURLY); |
163 |
< |
#line 65 "MDParser.g" |
163 |
> |
#line 62 "MDParser.g" |
164 |
|
tmp6_AST->setType(ENDBLOCK); |
165 |
|
#line 166 "MDParser.cpp" |
166 |
|
componentblock_AST = currentAST.root; |
200 |
|
tmp9_AST = astFactory->create(LT(1)); |
201 |
|
astFactory->addASTChild(currentAST, tmp9_AST); |
202 |
|
match(RCURLY); |
203 |
< |
#line 71 "MDParser.g" |
203 |
> |
#line 68 "MDParser.g" |
204 |
|
tmp9_AST->setType(ENDBLOCK); |
205 |
|
#line 206 "MDParser.cpp" |
206 |
|
moleculeblock_AST = currentAST.root; |
240 |
|
tmp12_AST = astFactory->create(LT(1)); |
241 |
|
astFactory->addASTChild(currentAST, tmp12_AST); |
242 |
|
match(RCURLY); |
243 |
< |
#line 68 "MDParser.g" |
243 |
> |
#line 65 "MDParser.g" |
244 |
|
tmp12_AST->setType(ENDBLOCK); |
245 |
|
#line 246 "MDParser.cpp" |
246 |
|
zconstraintblock_AST = currentAST.root; |
262 |
|
case OCTALINT: |
263 |
|
case DECIMALINT: |
264 |
|
case HEXADECIMALINT: |
265 |
– |
case PLUS: |
266 |
– |
case MINUS: |
265 |
|
case FLOATONE: |
266 |
|
case FLOATTWO: |
267 |
|
{ |
309 |
|
try { // for error handling |
310 |
|
{ |
311 |
|
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 |
– |
} |
312 |
|
case OCTALINT: |
313 |
|
case DECIMALINT: |
314 |
|
case HEXADECIMALINT: |
330 |
– |
case FLOATONE: |
331 |
– |
case FLOATTWO: |
315 |
|
{ |
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 |
– |
{ |
316 |
|
intConst(); |
317 |
|
astFactory->addASTChild( currentAST, returnAST ); |
318 |
|
break; |
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 tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
425 |
< |
tmp17_AST = astFactory->create(LT(1)); |
426 |
< |
astFactory->makeASTRoot(currentAST, tmp17_AST); |
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(); |
443 |
|
} |
444 |
|
_loop19:; |
445 |
|
} // ( ... )* |
446 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
447 |
< |
tmp21_AST = astFactory->create(LT(1)); |
448 |
< |
astFactory->addASTChild(currentAST, tmp21_AST); |
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 84 "MDParser.g" |
451 |
< |
tmp21_AST->setType(ENDBLOCK); |
452 |
< |
#line 484 "MDParser.cpp" |
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) { |
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 tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
469 |
< |
tmp22_AST = astFactory->create(LT(1)); |
470 |
< |
astFactory->makeASTRoot(currentAST, tmp22_AST); |
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)) { |
502 |
|
} |
503 |
|
_loop24:; |
504 |
|
} // ( ... )* |
505 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
506 |
< |
tmp26_AST = astFactory->create(LT(1)); |
507 |
< |
astFactory->addASTChild(currentAST, tmp26_AST); |
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 93 "MDParser.g" |
510 |
< |
tmp26_AST->setType(ENDBLOCK); |
511 |
< |
#line 543 "MDParser.cpp" |
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) { |
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 tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
528 |
< |
tmp27_AST = astFactory->create(LT(1)); |
529 |
< |
astFactory->makeASTRoot(currentAST, tmp27_AST); |
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)) { |
561 |
|
} |
562 |
|
_loop29:; |
563 |
|
} // ( ... )* |
564 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
565 |
< |
tmp31_AST = astFactory->create(LT(1)); |
566 |
< |
astFactory->addASTChild(currentAST, tmp31_AST); |
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 100 "MDParser.g" |
569 |
< |
tmp31_AST->setType(ENDBLOCK); |
570 |
< |
#line 602 "MDParser.cpp" |
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) { |
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 tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
587 |
< |
tmp32_AST = astFactory->create(LT(1)); |
588 |
< |
astFactory->makeASTRoot(currentAST, tmp32_AST); |
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)) { |
620 |
|
} |
621 |
|
_loop34:; |
622 |
|
} // ( ... )* |
623 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
624 |
< |
tmp36_AST = astFactory->create(LT(1)); |
625 |
< |
astFactory->addASTChild(currentAST, tmp36_AST); |
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 107 "MDParser.g" |
628 |
< |
tmp36_AST->setType(ENDBLOCK); |
629 |
< |
#line 661 "MDParser.cpp" |
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) { |
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 tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
646 |
< |
tmp37_AST = astFactory->create(LT(1)); |
647 |
< |
astFactory->makeASTRoot(currentAST, tmp37_AST); |
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(); |
664 |
|
} |
665 |
|
_loop38:; |
666 |
|
} // ( ... )* |
667 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
668 |
< |
tmp41_AST = astFactory->create(LT(1)); |
669 |
< |
astFactory->addASTChild(currentAST, tmp41_AST); |
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 114 "MDParser.g" |
672 |
< |
tmp41_AST->setType(ENDBLOCK); |
673 |
< |
#line 705 "MDParser.cpp" |
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) { |
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 tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
690 |
< |
tmp42_AST = astFactory->create(LT(1)); |
691 |
< |
astFactory->makeASTRoot(currentAST, tmp42_AST); |
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)) { |
723 |
|
} |
724 |
|
_loop43:; |
725 |
|
} // ( ... )* |
726 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
727 |
< |
tmp46_AST = astFactory->create(LT(1)); |
728 |
< |
astFactory->addASTChild(currentAST, tmp46_AST); |
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 121 "MDParser.g" |
731 |
< |
tmp46_AST->setType(ENDBLOCK); |
732 |
< |
#line 764 "MDParser.cpp" |
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) { |
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 tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
749 |
< |
tmp47_AST = astFactory->create(LT(1)); |
750 |
< |
astFactory->makeASTRoot(currentAST, tmp47_AST); |
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(); |
767 |
|
} |
768 |
|
_loop47:; |
769 |
|
} // ( ... )* |
770 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
771 |
< |
tmp51_AST = astFactory->create(LT(1)); |
772 |
< |
astFactory->addASTChild(currentAST, tmp51_AST); |
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 128 "MDParser.g" |
775 |
< |
tmp51_AST->setType(ENDBLOCK); |
776 |
< |
#line 808 "MDParser.cpp" |
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) { |
792 |
|
switch ( LA(1)) { |
793 |
|
case OCTALINT: |
794 |
|
{ |
795 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
796 |
< |
tmp52_AST = astFactory->create(LT(1)); |
797 |
< |
astFactory->addASTChild(currentAST, tmp52_AST); |
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 tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
805 |
< |
tmp53_AST = astFactory->create(LT(1)); |
806 |
< |
astFactory->addASTChild(currentAST, tmp53_AST); |
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 tmp54_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
814 |
< |
tmp54_AST = astFactory->create(LT(1)); |
815 |
< |
astFactory->addASTChild(currentAST, tmp54_AST); |
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; |
846 |
|
} |
847 |
|
case POSITION: |
848 |
|
{ |
849 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp55_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
850 |
< |
tmp55_AST = astFactory->create(LT(1)); |
851 |
< |
astFactory->makeASTRoot(currentAST, tmp55_AST); |
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(); |
860 |
|
} |
861 |
|
case ORIENTATION: |
862 |
|
{ |
863 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp59_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
864 |
< |
tmp59_AST = astFactory->create(LT(1)); |
865 |
< |
astFactory->makeASTRoot(currentAST, tmp59_AST); |
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(); |
932 |
|
} |
933 |
|
case MEMBERS: |
934 |
|
{ |
935 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp64_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
936 |
< |
tmp64_AST = astFactory->create(LT(1)); |
937 |
< |
astFactory->makeASTRoot(currentAST, tmp64_AST); |
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(); |
1004 |
|
} |
1005 |
|
case MEMBERS: |
1006 |
|
{ |
1007 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp69_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1008 |
< |
tmp69_AST = astFactory->create(LT(1)); |
1009 |
< |
astFactory->makeASTRoot(currentAST, tmp69_AST); |
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(); |
1045 |
|
} |
1046 |
|
case MEMBERS: |
1047 |
|
{ |
1048 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp73_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1049 |
< |
tmp73_AST = astFactory->create(LT(1)); |
1050 |
< |
astFactory->makeASTRoot(currentAST, tmp73_AST); |
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(); |
1086 |
|
} |
1087 |
|
case MEMBERS: |
1088 |
|
{ |
1089 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1090 |
< |
tmp77_AST = astFactory->create(LT(1)); |
1091 |
< |
astFactory->makeASTRoot(currentAST, tmp77_AST); |
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(); |
1127 |
|
} |
1128 |
|
case MEMBERS: |
1129 |
|
{ |
1130 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp81_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1131 |
< |
tmp81_AST = astFactory->create(LT(1)); |
1132 |
< |
astFactory->makeASTRoot(currentAST, tmp81_AST); |
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(); |
1178 |
|
switch ( LA(1)) { |
1179 |
|
case FLOATONE: |
1180 |
|
{ |
1181 |
< |
ANTLR_USE_NAMESPACE(antlr)RefAST tmp85_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1182 |
< |
tmp85_AST = astFactory->create(LT(1)); |
1183 |
< |
astFactory->addASTChild(currentAST, tmp85_AST); |
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 tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST; |
1191 |
< |
tmp86_AST = astFactory->create(LT(1)); |
1192 |
< |
astFactory->addASTChild(currentAST, tmp86_AST); |
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; |
1209 |
|
|
1210 |
|
void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) |
1211 |
|
{ |
1212 |
< |
factory.setMaxNodeType(55); |
1212 |
> |
factory.setMaxNodeType(53); |
1213 |
|
} |
1214 |
|
const char* MDParser::tokenNames[] = { |
1215 |
|
"<0>", |
1244 |
|
"OCTALINT", |
1245 |
|
"DECIMALINT", |
1246 |
|
"HEXADECIMALINT", |
1278 |
– |
"PLUS", |
1279 |
– |
"MINUS", |
1247 |
|
"FLOATONE", |
1248 |
|
"FLOATTWO", |
1249 |
|
"DOT", |