ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/mdParser/MDParser.cpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/mdParser/MDParser.cpp (file contents):
Revision 2469 by tim, Fri Dec 2 15:38:03 2005 UTC vs.
Revision 2509 by tim, Wed Dec 14 18:02:28 2005 UTC

# Line 160 | Line 160 | void MDParser::componentblock() {
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;
# Line 200 | Line 200 | void MDParser::moleculeblock() {
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;
# Line 240 | Line 240 | void MDParser::zconstraintblock() {
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;
# Line 262 | Line 262 | void MDParser::constant() {
262                  case OCTALINT:
263                  case DECIMALINT:
264                  case HEXADECIMALINT:
265 –                case PLUS:
266 –                case MINUS:
265                  case FLOATONE:
266                  case FLOATTWO:
267                  {
# Line 311 | Line 309 | void MDParser::signedNumber() {
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;
# Line 452 | Line 421 | void MDParser::atomblock() {
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();
# Line 474 | Line 443 | void MDParser::atomblock() {
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) {
# Line 496 | Line 465 | void MDParser::bondblock() {
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)) {
# Line 533 | Line 502 | void MDParser::bondblock() {
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) {
# Line 555 | Line 524 | void MDParser::bendblock() {
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)) {
# Line 592 | Line 561 | void MDParser::bendblock() {
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) {
# Line 614 | Line 583 | void MDParser::torsionblock() {
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)) {
# Line 651 | Line 620 | void MDParser::torsionblock() {
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) {
# Line 673 | Line 642 | void MDParser::rigidbodyblock() {
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();
# Line 695 | Line 664 | void MDParser::rigidbodyblock() {
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) {
# Line 717 | Line 686 | void MDParser::cutoffgroupblock() {
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)) {
# Line 754 | Line 723 | void MDParser::cutoffgroupblock() {
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) {
# Line 776 | Line 745 | void MDParser::fragmentblock() {
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();
# Line 798 | Line 767 | void MDParser::fragmentblock() {
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) {
# Line 823 | Line 792 | void MDParser::intConst() {
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;
# Line 877 | Line 846 | void MDParser::atomstatement() {
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();
# Line 891 | Line 860 | void MDParser::atomstatement() {
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();
# Line 963 | Line 932 | void MDParser::bondstatement() {
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();
# Line 1035 | Line 1004 | void MDParser::bendstatement() {
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();
# Line 1076 | Line 1045 | void MDParser::torsionstatement() {
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();
# Line 1117 | Line 1086 | void MDParser::rigidbodystatement() {
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();
# Line 1158 | Line 1127 | void MDParser::cutoffgroupstatement() {
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();
# Line 1209 | Line 1178 | void MDParser::floatConst() {
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;
# Line 1240 | Line 1209 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPA
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>",
# Line 1275 | Line 1244 | const char* MDParser::tokenNames[] = {
1244          "OCTALINT",
1245          "DECIMALINT",
1246          "HEXADECIMALINT",
1278 –        "PLUS",
1279 –        "MINUS",
1247          "FLOATONE",
1248          "FLOATTWO",
1249          "DOT",

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines