ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/mdParser/MDParser.cpp
(Generate patch)

Comparing branches/development/src/mdParser/MDParser.cpp (file contents):
Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC vs.
Revision 1731 by gezelter, Thu May 31 12:25:30 2012 UTC

# Line 1 | Line 1
1 < /* $ANTLR 2.7.7 (20090623): "MDParser.g" -> "MDParser.cpp"$ */
1 > /* $ANTLR 2.7.7 (20110725): "MDParser.g" -> "MDParser.cpp"$ */
2   #include "MDParser.hpp"
3   #include <antlr/NoViableAltException.hpp>
4   #include <antlr/SemanticException.hpp>
# Line 100 | Line 100 | void MDParser::statement() {
100                          statement_AST = currentAST.root;
101                          break;
102                  }
103 +                case FLUCQ:
104 +                {
105 +                        flucqblock();
106 +                        astFactory->addASTChild( currentAST, returnAST );
107 +                        statement_AST = currentAST.root;
108 +                        break;
109 +                }
110 +                case RNEMD:
111 +                {
112 +                        rnemdblock();
113 +                        astFactory->addASTChild( currentAST, returnAST );
114 +                        statement_AST = currentAST.root;
115 +                        break;
116 +                }
117                  default:
118                  {
119                          throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
# Line 167 | Line 181 | void MDParser::componentblock() {
181                  tmp6_AST = astFactory->create(LT(1));
182                  astFactory->addASTChild(currentAST, tmp6_AST);
183                  match(RCURLY);
184 < #line 67 "MDParser.g"
184 > #line 71 "MDParser.g"
185                  tmp6_AST->setType(ENDBLOCK);
186 < #line 173 "MDParser.cpp"
186 > #line 187 "MDParser.cpp"
187                  componentblock_AST = currentAST.root;
188          }
189          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 197 | Line 211 | void MDParser::moleculeblock() {
211                                  astFactory->addASTChild( currentAST, returnAST );
212                          }
213                          else {
214 <                                goto _loop18;
214 >                                goto _loop24;
215                          }
216                          
217                  }
218 <                _loop18:;
218 >                _loop24:;
219                  } // ( ... )*
220                  ANTLR_USE_NAMESPACE(antlr)RefAST tmp9_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
221                  tmp9_AST = astFactory->create(LT(1));
222                  astFactory->addASTChild(currentAST, tmp9_AST);
223                  match(RCURLY);
224 < #line 76 "MDParser.g"
224 > #line 86 "MDParser.g"
225                  tmp9_AST->setType(ENDBLOCK);
226 < #line 213 "MDParser.cpp"
226 > #line 227 "MDParser.cpp"
227                  moleculeblock_AST = currentAST.root;
228          }
229          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 247 | Line 261 | void MDParser::zconstraintblock() {
261                  tmp12_AST = astFactory->create(LT(1));
262                  astFactory->addASTChild(currentAST, tmp12_AST);
263                  match(RCURLY);
264 < #line 70 "MDParser.g"
264 > #line 74 "MDParser.g"
265                  tmp12_AST->setType(ENDBLOCK);
266 < #line 253 "MDParser.cpp"
266 > #line 267 "MDParser.cpp"
267                  zconstraintblock_AST = currentAST.root;
268          }
269          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 287 | Line 301 | void MDParser::restraintblock() {
301                  tmp15_AST = astFactory->create(LT(1));
302                  astFactory->addASTChild(currentAST, tmp15_AST);
303                  match(RCURLY);
304 < #line 73 "MDParser.g"
304 > #line 77 "MDParser.g"
305                  tmp15_AST->setType(ENDBLOCK);
306 < #line 293 "MDParser.cpp"
306 > #line 307 "MDParser.cpp"
307                  restraintblock_AST = currentAST.root;
308          }
309          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 297 | Line 311 | void MDParser::restraintblock() {
311                  recover(ex,_tokenSet_2);
312          }
313          returnAST = restraintblock_AST;
314 + }
315 +
316 + void MDParser::flucqblock() {
317 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
318 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
319 +        ANTLR_USE_NAMESPACE(antlr)RefAST flucqblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
320 +        
321 +        try {      // for error handling
322 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
323 +                tmp16_AST = astFactory->create(LT(1));
324 +                astFactory->makeASTRoot(currentAST, tmp16_AST);
325 +                match(FLUCQ);
326 +                match(LCURLY);
327 +                { // ( ... )*
328 +                for (;;) {
329 +                        if ((LA(1) == ID)) {
330 +                                assignment();
331 +                                astFactory->addASTChild( currentAST, returnAST );
332 +                        }
333 +                        else {
334 +                                goto _loop18;
335 +                        }
336 +                        
337 +                }
338 +                _loop18:;
339 +                } // ( ... )*
340 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
341 +                tmp18_AST = astFactory->create(LT(1));
342 +                astFactory->addASTChild(currentAST, tmp18_AST);
343 +                match(RCURLY);
344 + #line 80 "MDParser.g"
345 +                tmp18_AST->setType(ENDBLOCK);
346 + #line 347 "MDParser.cpp"
347 +                flucqblock_AST = currentAST.root;
348 +        }
349 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
350 +                reportError(ex);
351 +                recover(ex,_tokenSet_2);
352 +        }
353 +        returnAST = flucqblock_AST;
354   }
355  
356 + void MDParser::rnemdblock() {
357 +        returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
358 +        ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
359 +        ANTLR_USE_NAMESPACE(antlr)RefAST rnemdblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
360 +        
361 +        try {      // for error handling
362 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
363 +                tmp19_AST = astFactory->create(LT(1));
364 +                astFactory->makeASTRoot(currentAST, tmp19_AST);
365 +                match(RNEMD);
366 +                match(LCURLY);
367 +                { // ( ... )*
368 +                for (;;) {
369 +                        if ((LA(1) == ID)) {
370 +                                assignment();
371 +                                astFactory->addASTChild( currentAST, returnAST );
372 +                        }
373 +                        else {
374 +                                goto _loop21;
375 +                        }
376 +                        
377 +                }
378 +                _loop21:;
379 +                } // ( ... )*
380 +                ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
381 +                tmp21_AST = astFactory->create(LT(1));
382 +                astFactory->addASTChild(currentAST, tmp21_AST);
383 +                match(RCURLY);
384 + #line 83 "MDParser.g"
385 +                tmp21_AST->setType(ENDBLOCK);
386 + #line 387 "MDParser.cpp"
387 +                rnemdblock_AST = currentAST.root;
388 +        }
389 +        catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
390 +                reportError(ex);
391 +                recover(ex,_tokenSet_2);
392 +        }
393 +        returnAST = rnemdblock_AST;
394 + }
395 +
396   void MDParser::constant() {
397          returnAST = ANTLR_USE_NAMESPACE(antlr)nullAST;
398          ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
# Line 324 | Line 418 | void MDParser::constant() {
418                  }
419                  case ID:
420                  {
421 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp16_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
422 <                        tmp16_AST = astFactory->create(LT(1));
423 <                        astFactory->addASTChild(currentAST, tmp16_AST);
421 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
422 >                        tmp22_AST = astFactory->create(LT(1));
423 >                        astFactory->addASTChild(currentAST, tmp22_AST);
424                          match(ID);
425                          constant_AST = currentAST.root;
426                          break;
427                  }
428                  case StringLiteral:
429                  {
430 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp17_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
431 <                        tmp17_AST = astFactory->create(LT(1));
432 <                        astFactory->addASTChild(currentAST, tmp17_AST);
430 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp23_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
431 >                        tmp23_AST = astFactory->create(LT(1));
432 >                        astFactory->addASTChild(currentAST, tmp23_AST);
433                          match(StringLiteral);
434                          constant_AST = currentAST.root;
435                          break;
# Line 362 | Line 456 | void MDParser::intConst() {
456                  switch ( LA(1)) {
457                  case NUM_INT:
458                  {
459 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp18_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
460 <                        tmp18_AST = astFactory->create(LT(1));
461 <                        astFactory->addASTChild(currentAST, tmp18_AST);
459 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp24_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
460 >                        tmp24_AST = astFactory->create(LT(1));
461 >                        astFactory->addASTChild(currentAST, tmp24_AST);
462                          match(NUM_INT);
463                          intConst_AST = currentAST.root;
464                          break;
465                  }
466                  case NUM_LONG:
467                  {
468 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp19_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
469 <                        tmp19_AST = astFactory->create(LT(1));
470 <                        astFactory->addASTChild(currentAST, tmp19_AST);
468 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp25_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
469 >                        tmp25_AST = astFactory->create(LT(1));
470 >                        astFactory->addASTChild(currentAST, tmp25_AST);
471                          match(NUM_LONG);
472                          intConst_AST = currentAST.root;
473                          break;
# Line 400 | Line 494 | void MDParser::floatConst() {
494                  switch ( LA(1)) {
495                  case NUM_FLOAT:
496                  {
497 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp20_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
498 <                        tmp20_AST = astFactory->create(LT(1));
499 <                        astFactory->addASTChild(currentAST, tmp20_AST);
497 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
498 >                        tmp26_AST = astFactory->create(LT(1));
499 >                        astFactory->addASTChild(currentAST, tmp26_AST);
500                          match(NUM_FLOAT);
501                          floatConst_AST = currentAST.root;
502                          break;
503                  }
504                  case NUM_DOUBLE:
505                  {
506 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp21_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507 <                        tmp21_AST = astFactory->create(LT(1));
508 <                        astFactory->addASTChild(currentAST, tmp21_AST);
506 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
507 >                        tmp27_AST = astFactory->create(LT(1));
508 >                        astFactory->addASTChild(currentAST, tmp27_AST);
509                          match(NUM_DOUBLE);
510                          floatConst_AST = currentAST.root;
511                          break;
# Line 518 | Line 612 | void MDParser::atomblock() {
612          ANTLR_USE_NAMESPACE(antlr)RefAST atomblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
613          
614          try {      // for error handling
615 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp22_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
616 <                tmp22_AST = astFactory->create(LT(1));
617 <                astFactory->makeASTRoot(currentAST, tmp22_AST);
615 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp28_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
616 >                tmp28_AST = astFactory->create(LT(1));
617 >                astFactory->makeASTRoot(currentAST, tmp28_AST);
618                  match(ATOM);
619                  match(LBRACKET);
620                  intConst();
# Line 534 | Line 628 | void MDParser::atomblock() {
628                                  astFactory->addASTChild( currentAST, returnAST );
629                          }
630                          else {
631 <                                goto _loop22;
631 >                                goto _loop28;
632                          }
633                          
634                  }
635 <                _loop22:;
635 >                _loop28:;
636                  } // ( ... )*
637 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp26_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
638 <                tmp26_AST = astFactory->create(LT(1));
639 <                astFactory->addASTChild(currentAST, tmp26_AST);
637 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
638 >                tmp32_AST = astFactory->create(LT(1));
639 >                astFactory->addASTChild(currentAST, tmp32_AST);
640                  match(RCURLY);
641 < #line 90 "MDParser.g"
642 <                tmp26_AST->setType(ENDBLOCK);
643 < #line 550 "MDParser.cpp"
641 > #line 100 "MDParser.g"
642 >                tmp32_AST->setType(ENDBLOCK);
643 > #line 644 "MDParser.cpp"
644                  atomblock_AST = currentAST.root;
645          }
646          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 562 | Line 656 | void MDParser::bondblock() {
656          ANTLR_USE_NAMESPACE(antlr)RefAST bondblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
657          
658          try {      // for error handling
659 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp27_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
660 <                tmp27_AST = astFactory->create(LT(1));
661 <                astFactory->makeASTRoot(currentAST, tmp27_AST);
659 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp33_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
660 >                tmp33_AST = astFactory->create(LT(1));
661 >                astFactory->makeASTRoot(currentAST, tmp33_AST);
662                  match(BOND);
663                  {
664                  switch ( LA(1)) {
# Line 593 | Line 687 | void MDParser::bondblock() {
687                                  astFactory->addASTChild( currentAST, returnAST );
688                          }
689                          else {
690 <                                goto _loop27;
690 >                                goto _loop33;
691                          }
692                          
693                  }
694 <                _loop27:;
694 >                _loop33:;
695                  } // ( ... )*
696 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp31_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
697 <                tmp31_AST = astFactory->create(LT(1));
698 <                astFactory->addASTChild(currentAST, tmp31_AST);
696 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
697 >                tmp37_AST = astFactory->create(LT(1));
698 >                astFactory->addASTChild(currentAST, tmp37_AST);
699                  match(RCURLY);
700 < #line 99 "MDParser.g"
701 <                tmp31_AST->setType(ENDBLOCK);
702 < #line 609 "MDParser.cpp"
700 > #line 109 "MDParser.g"
701 >                tmp37_AST->setType(ENDBLOCK);
702 > #line 703 "MDParser.cpp"
703                  bondblock_AST = currentAST.root;
704          }
705          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 621 | Line 715 | void MDParser::bendblock() {
715          ANTLR_USE_NAMESPACE(antlr)RefAST bendblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
716          
717          try {      // for error handling
718 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp32_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
719 <                tmp32_AST = astFactory->create(LT(1));
720 <                astFactory->makeASTRoot(currentAST, tmp32_AST);
718 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp38_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
719 >                tmp38_AST = astFactory->create(LT(1));
720 >                astFactory->makeASTRoot(currentAST, tmp38_AST);
721                  match(BEND);
722                  {
723                  switch ( LA(1)) {
# Line 652 | Line 746 | void MDParser::bendblock() {
746                                  astFactory->addASTChild( currentAST, returnAST );
747                          }
748                          else {
749 <                                goto _loop32;
749 >                                goto _loop38;
750                          }
751                          
752                  }
753 <                _loop32:;
753 >                _loop38:;
754                  } // ( ... )*
755 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp36_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
756 <                tmp36_AST = astFactory->create(LT(1));
757 <                astFactory->addASTChild(currentAST, tmp36_AST);
755 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
756 >                tmp42_AST = astFactory->create(LT(1));
757 >                astFactory->addASTChild(currentAST, tmp42_AST);
758                  match(RCURLY);
759 < #line 106 "MDParser.g"
760 <                tmp36_AST->setType(ENDBLOCK);
761 < #line 668 "MDParser.cpp"
759 > #line 116 "MDParser.g"
760 >                tmp42_AST->setType(ENDBLOCK);
761 > #line 762 "MDParser.cpp"
762                  bendblock_AST = currentAST.root;
763          }
764          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 680 | Line 774 | void MDParser::torsionblock() {
774          ANTLR_USE_NAMESPACE(antlr)RefAST torsionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
775          
776          try {      // for error handling
777 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp37_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
778 <                tmp37_AST = astFactory->create(LT(1));
779 <                astFactory->makeASTRoot(currentAST, tmp37_AST);
777 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp43_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
778 >                tmp43_AST = astFactory->create(LT(1));
779 >                astFactory->makeASTRoot(currentAST, tmp43_AST);
780                  match(TORSION);
781                  {
782                  switch ( LA(1)) {
# Line 711 | Line 805 | void MDParser::torsionblock() {
805                                  astFactory->addASTChild( currentAST, returnAST );
806                          }
807                          else {
808 <                                goto _loop37;
808 >                                goto _loop43;
809                          }
810                          
811                  }
812 <                _loop37:;
812 >                _loop43:;
813                  } // ( ... )*
814 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp41_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
815 <                tmp41_AST = astFactory->create(LT(1));
816 <                astFactory->addASTChild(currentAST, tmp41_AST);
814 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
815 >                tmp47_AST = astFactory->create(LT(1));
816 >                astFactory->addASTChild(currentAST, tmp47_AST);
817                  match(RCURLY);
818 < #line 113 "MDParser.g"
819 <                tmp41_AST->setType(ENDBLOCK);
820 < #line 727 "MDParser.cpp"
818 > #line 123 "MDParser.g"
819 >                tmp47_AST->setType(ENDBLOCK);
820 > #line 821 "MDParser.cpp"
821                  torsionblock_AST = currentAST.root;
822          }
823          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 739 | Line 833 | void MDParser::inversionblock() {
833          ANTLR_USE_NAMESPACE(antlr)RefAST inversionblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
834          
835          try {      // for error handling
836 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp42_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
837 <                tmp42_AST = astFactory->create(LT(1));
838 <                astFactory->makeASTRoot(currentAST, tmp42_AST);
836 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp48_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
837 >                tmp48_AST = astFactory->create(LT(1));
838 >                astFactory->makeASTRoot(currentAST, tmp48_AST);
839                  match(INVERSION);
840                  {
841                  switch ( LA(1)) {
# Line 770 | Line 864 | void MDParser::inversionblock() {
864                                  astFactory->addASTChild( currentAST, returnAST );
865                          }
866                          else {
867 <                                goto _loop42;
867 >                                goto _loop48;
868                          }
869                          
870                  }
871 <                _loop42:;
871 >                _loop48:;
872                  } // ( ... )*
873 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp46_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
874 <                tmp46_AST = astFactory->create(LT(1));
875 <                astFactory->addASTChild(currentAST, tmp46_AST);
873 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
874 >                tmp52_AST = astFactory->create(LT(1));
875 >                astFactory->addASTChild(currentAST, tmp52_AST);
876                  match(RCURLY);
877 < #line 120 "MDParser.g"
878 <                tmp46_AST->setType(ENDBLOCK);
879 < #line 786 "MDParser.cpp"
877 > #line 130 "MDParser.g"
878 >                tmp52_AST->setType(ENDBLOCK);
879 > #line 880 "MDParser.cpp"
880                  inversionblock_AST = currentAST.root;
881          }
882          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 798 | Line 892 | void MDParser::rigidbodyblock() {
892          ANTLR_USE_NAMESPACE(antlr)RefAST rigidbodyblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
893          
894          try {      // for error handling
895 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp47_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
896 <                tmp47_AST = astFactory->create(LT(1));
897 <                astFactory->makeASTRoot(currentAST, tmp47_AST);
895 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp53_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
896 >                tmp53_AST = astFactory->create(LT(1));
897 >                astFactory->makeASTRoot(currentAST, tmp53_AST);
898                  match(RIGIDBODY);
899                  match(LBRACKET);
900                  intConst();
# Line 814 | Line 908 | void MDParser::rigidbodyblock() {
908                                  astFactory->addASTChild( currentAST, returnAST );
909                          }
910                          else {
911 <                                goto _loop46;
911 >                                goto _loop52;
912                          }
913                          
914                  }
915 <                _loop46:;
915 >                _loop52:;
916                  } // ( ... )*
917 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp51_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
918 <                tmp51_AST = astFactory->create(LT(1));
919 <                astFactory->addASTChild(currentAST, tmp51_AST);
917 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
918 >                tmp57_AST = astFactory->create(LT(1));
919 >                astFactory->addASTChild(currentAST, tmp57_AST);
920                  match(RCURLY);
921 < #line 127 "MDParser.g"
922 <                tmp51_AST->setType(ENDBLOCK);
923 < #line 830 "MDParser.cpp"
921 > #line 137 "MDParser.g"
922 >                tmp57_AST->setType(ENDBLOCK);
923 > #line 924 "MDParser.cpp"
924                  rigidbodyblock_AST = currentAST.root;
925          }
926          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 842 | Line 936 | void MDParser::cutoffgroupblock() {
936          ANTLR_USE_NAMESPACE(antlr)RefAST cutoffgroupblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
937          
938          try {      // for error handling
939 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp52_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
940 <                tmp52_AST = astFactory->create(LT(1));
941 <                astFactory->makeASTRoot(currentAST, tmp52_AST);
939 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp58_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
940 >                tmp58_AST = astFactory->create(LT(1));
941 >                astFactory->makeASTRoot(currentAST, tmp58_AST);
942                  match(CUTOFFGROUP);
943                  {
944                  switch ( LA(1)) {
# Line 873 | Line 967 | void MDParser::cutoffgroupblock() {
967                                  astFactory->addASTChild( currentAST, returnAST );
968                          }
969                          else {
970 <                                goto _loop51;
970 >                                goto _loop57;
971                          }
972                          
973                  }
974 <                _loop51:;
974 >                _loop57:;
975                  } // ( ... )*
976 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp56_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
977 <                tmp56_AST = astFactory->create(LT(1));
978 <                astFactory->addASTChild(currentAST, tmp56_AST);
976 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
977 >                tmp62_AST = astFactory->create(LT(1));
978 >                astFactory->addASTChild(currentAST, tmp62_AST);
979                  match(RCURLY);
980 < #line 134 "MDParser.g"
981 <                tmp56_AST->setType(ENDBLOCK);
982 < #line 889 "MDParser.cpp"
980 > #line 144 "MDParser.g"
981 >                tmp62_AST->setType(ENDBLOCK);
982 > #line 983 "MDParser.cpp"
983                  cutoffgroupblock_AST = currentAST.root;
984          }
985          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 901 | Line 995 | void MDParser::fragmentblock() {
995          ANTLR_USE_NAMESPACE(antlr)RefAST fragmentblock_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
996          
997          try {      // for error handling
998 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp57_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
999 <                tmp57_AST = astFactory->create(LT(1));
1000 <                astFactory->makeASTRoot(currentAST, tmp57_AST);
998 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp63_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
999 >                tmp63_AST = astFactory->create(LT(1));
1000 >                astFactory->makeASTRoot(currentAST, tmp63_AST);
1001                  match(FRAGMENT);
1002                  match(LBRACKET);
1003                  intConst();
# Line 917 | Line 1011 | void MDParser::fragmentblock() {
1011                                  astFactory->addASTChild( currentAST, returnAST );
1012                          }
1013                          else {
1014 <                                goto _loop55;
1014 >                                goto _loop61;
1015                          }
1016                          
1017                  }
1018 <                _loop55:;
1018 >                _loop61:;
1019                  } // ( ... )*
1020 <                ANTLR_USE_NAMESPACE(antlr)RefAST tmp61_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1021 <                tmp61_AST = astFactory->create(LT(1));
1022 <                astFactory->addASTChild(currentAST, tmp61_AST);
1020 >                ANTLR_USE_NAMESPACE(antlr)RefAST tmp67_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1021 >                tmp67_AST = astFactory->create(LT(1));
1022 >                astFactory->addASTChild(currentAST, tmp67_AST);
1023                  match(RCURLY);
1024 < #line 141 "MDParser.g"
1025 <                tmp61_AST->setType(ENDBLOCK);
1026 < #line 933 "MDParser.cpp"
1024 > #line 151 "MDParser.g"
1025 >                tmp67_AST->setType(ENDBLOCK);
1026 > #line 1027 "MDParser.cpp"
1027                  fragmentblock_AST = currentAST.root;
1028          }
1029          catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
# Line 955 | Line 1049 | void MDParser::atomstatement() {
1049                  }
1050                  case POSITION:
1051                  {
1052 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp62_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1053 <                        tmp62_AST = astFactory->create(LT(1));
1054 <                        astFactory->makeASTRoot(currentAST, tmp62_AST);
1052 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp68_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1053 >                        tmp68_AST = astFactory->create(LT(1));
1054 >                        astFactory->makeASTRoot(currentAST, tmp68_AST);
1055                          match(POSITION);
1056                          match(LPAREN);
1057                          doubleNumberTuple();
# Line 969 | Line 1063 | void MDParser::atomstatement() {
1063                  }
1064                  case ORIENTATION:
1065                  {
1066 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp66_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1067 <                        tmp66_AST = astFactory->create(LT(1));
1068 <                        astFactory->makeASTRoot(currentAST, tmp66_AST);
1066 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp72_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1067 >                        tmp72_AST = astFactory->create(LT(1));
1068 >                        astFactory->makeASTRoot(currentAST, tmp72_AST);
1069                          match(ORIENTATION);
1070                          match(LPAREN);
1071                          doubleNumberTuple();
# Line 1010 | Line 1104 | void MDParser::doubleNumberTuple() {
1104                                  astFactory->addASTChild( currentAST, returnAST );
1105                          }
1106                          else {
1107 <                                goto _loop59;
1107 >                                goto _loop65;
1108                          }
1109                          
1110                  }
1111 <                _loop59:;
1111 >                _loop65:;
1112                  } // ( ... )*
1113                  doubleNumberTuple_AST = currentAST.root;
1114          }
# Line 1041 | Line 1135 | void MDParser::bondstatement() {
1135                  }
1136                  case MEMBERS:
1137                  {
1138 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp71_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1139 <                        tmp71_AST = astFactory->create(LT(1));
1140 <                        astFactory->makeASTRoot(currentAST, tmp71_AST);
1138 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp77_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1139 >                        tmp77_AST = astFactory->create(LT(1));
1140 >                        astFactory->makeASTRoot(currentAST, tmp77_AST);
1141                          match(MEMBERS);
1142                          match(LPAREN);
1143                          inttuple();
# Line 1082 | Line 1176 | void MDParser::inttuple() {
1176                                  astFactory->addASTChild( currentAST, returnAST );
1177                          }
1178                          else {
1179 <                                goto _loop62;
1179 >                                goto _loop68;
1180                          }
1181                          
1182                  }
1183 <                _loop62:;
1183 >                _loop68:;
1184                  } // ( ... )*
1185                  inttuple_AST = currentAST.root;
1186          }
# Line 1113 | Line 1207 | void MDParser::bendstatement() {
1207                  }
1208                  case MEMBERS:
1209                  {
1210 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp76_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1211 <                        tmp76_AST = astFactory->create(LT(1));
1212 <                        astFactory->makeASTRoot(currentAST, tmp76_AST);
1210 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp82_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1211 >                        tmp82_AST = astFactory->create(LT(1));
1212 >                        astFactory->makeASTRoot(currentAST, tmp82_AST);
1213                          match(MEMBERS);
1214                          match(LPAREN);
1215                          inttuple();
# Line 1154 | Line 1248 | void MDParser::torsionstatement() {
1248                  }
1249                  case MEMBERS:
1250                  {
1251 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp80_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1252 <                        tmp80_AST = astFactory->create(LT(1));
1253 <                        astFactory->makeASTRoot(currentAST, tmp80_AST);
1251 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp86_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1252 >                        tmp86_AST = astFactory->create(LT(1));
1253 >                        astFactory->makeASTRoot(currentAST, tmp86_AST);
1254                          match(MEMBERS);
1255                          match(LPAREN);
1256                          inttuple();
# Line 1195 | Line 1289 | void MDParser::inversionstatement() {
1289                  }
1290                  case CENTER:
1291                  {
1292 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp84_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1293 <                        tmp84_AST = astFactory->create(LT(1));
1294 <                        astFactory->makeASTRoot(currentAST, tmp84_AST);
1292 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp90_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1293 >                        tmp90_AST = astFactory->create(LT(1));
1294 >                        astFactory->makeASTRoot(currentAST, tmp90_AST);
1295                          match(CENTER);
1296                          match(LPAREN);
1297                          intConst();
# Line 1236 | Line 1330 | void MDParser::rigidbodystatement() {
1330                  }
1331                  case MEMBERS:
1332                  {
1333 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp88_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1334 <                        tmp88_AST = astFactory->create(LT(1));
1335 <                        astFactory->makeASTRoot(currentAST, tmp88_AST);
1333 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp94_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1334 >                        tmp94_AST = astFactory->create(LT(1));
1335 >                        astFactory->makeASTRoot(currentAST, tmp94_AST);
1336                          match(MEMBERS);
1337                          match(LPAREN);
1338                          inttuple();
# Line 1277 | Line 1371 | void MDParser::cutoffgroupstatement() {
1371                  }
1372                  case MEMBERS:
1373                  {
1374 <                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp92_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1375 <                        tmp92_AST = astFactory->create(LT(1));
1376 <                        astFactory->makeASTRoot(currentAST, tmp92_AST);
1374 >                        ANTLR_USE_NAMESPACE(antlr)RefAST tmp98_AST = ANTLR_USE_NAMESPACE(antlr)nullAST;
1375 >                        tmp98_AST = astFactory->create(LT(1));
1376 >                        astFactory->makeASTRoot(currentAST, tmp98_AST);
1377                          match(MEMBERS);
1378                          match(LPAREN);
1379                          inttuple();
# Line 1358 | Line 1452 | void MDParser::initializeASTFactory( ANTLR_USE_NAMESPA
1452  
1453   void MDParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
1454   {
1455 <        factory.setMaxNodeType(53);
1455 >        factory.setMaxNodeType(55);
1456   }
1457   const char* MDParser::tokenNames[] = {
1458          "<0>",
# Line 1381 | Line 1475 | const char* MDParser::tokenNames[] = {
1475          "\"center\"",
1476          "\"position\"",
1477          "\"orientation\"",
1478 +        "\"flucQ\"",
1479 +        "\"RNEMD\"",
1480          "ENDBLOCK",
1481          "ID",
1482          "ASSIGNEQUAL",
# Line 1418 | Line 1514 | const char* MDParser::tokenNames[] = {
1514          0
1515   };
1516  
1517 < const unsigned long MDParser::_tokenSet_0_data_[] = { 2097392UL, 0UL, 0UL, 0UL };
1518 < // "component" "molecule" "zconstraint" "restraint" ID
1517 > const unsigned long MDParser::_tokenSet_0_data_[] = { 11534576UL, 0UL, 0UL, 0UL };
1518 > // "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD" ID
1519   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_0(_tokenSet_0_data_,4);
1520   const unsigned long MDParser::_tokenSet_1_data_[] = { 2UL, 0UL, 0UL, 0UL };
1521   // EOF
1522   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_1(_tokenSet_1_data_,4);
1523 < const unsigned long MDParser::_tokenSet_2_data_[] = { 2097394UL, 0UL, 0UL, 0UL };
1524 < // EOF "component" "molecule" "zconstraint" "restraint" ID
1523 > const unsigned long MDParser::_tokenSet_2_data_[] = { 11534578UL, 0UL, 0UL, 0UL };
1524 > // EOF "component" "molecule" "zconstraint" "restraint" "flucQ" "RNEMD"
1525 > // ID
1526   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_2(_tokenSet_2_data_,4);
1527 < const unsigned long MDParser::_tokenSet_3_data_[] = { 70254578UL, 0UL, 0UL, 0UL };
1527 > const unsigned long MDParser::_tokenSet_3_data_[] = { 281018354UL, 0UL, 0UL, 0UL };
1528   // EOF "component" "molecule" "zconstraint" "restraint" "atom" "bond" "bend"
1529   // "torsion" "inversion" "rigidBody" "cutoffGroup" "fragment" "members"
1530 < // "center" "position" "orientation" ID RCURLY
1530 > // "center" "position" "orientation" "flucQ" "RNEMD" ID RCURLY
1531   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_3(_tokenSet_3_data_,4);
1532 < const unsigned long MDParser::_tokenSet_4_data_[] = { 2162432UL, 0UL, 0UL, 0UL };
1532 > const unsigned long MDParser::_tokenSet_4_data_[] = { 8453888UL, 0UL, 0UL, 0UL };
1533   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1534   // "fragment" ID
1535   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_4(_tokenSet_4_data_,4);
1536 < const unsigned long MDParser::_tokenSet_5_data_[] = { 8388608UL, 0UL, 0UL, 0UL };
1536 > const unsigned long MDParser::_tokenSet_5_data_[] = { 33554432UL, 0UL, 0UL, 0UL };
1537   // SEMICOLON
1538   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_5(_tokenSet_5_data_,4);
1539 < const unsigned long MDParser::_tokenSet_6_data_[] = { 3498049536UL, 0UL, 0UL, 0UL };
1539 > const unsigned long MDParser::_tokenSet_6_data_[] = { 1107296256UL, 3UL, 0UL, 0UL };
1540   // SEMICOLON RBRACKET RPAREN COMMA
1541   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_6(_tokenSet_6_data_,4);
1542 < const unsigned long MDParser::_tokenSet_7_data_[] = { 3229614080UL, 0UL, 0UL, 0UL };
1542 > const unsigned long MDParser::_tokenSet_7_data_[] = { 33554432UL, 3UL, 0UL, 0UL };
1543   // SEMICOLON RPAREN COMMA
1544   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_7(_tokenSet_7_data_,4);
1545 < const unsigned long MDParser::_tokenSet_8_data_[] = { 69271296UL, 0UL, 0UL, 0UL };
1545 > const unsigned long MDParser::_tokenSet_8_data_[] = { 276889344UL, 0UL, 0UL, 0UL };
1546   // "atom" "bond" "bend" "torsion" "inversion" "rigidBody" "cutoffGroup"
1547   // "fragment" ID RCURLY
1548   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_8(_tokenSet_8_data_,4);
1549 < const unsigned long MDParser::_tokenSet_9_data_[] = { 2883584UL, 0UL, 0UL, 0UL };
1549 > const unsigned long MDParser::_tokenSet_9_data_[] = { 9175040UL, 0UL, 0UL, 0UL };
1550   // "position" "orientation" ID
1551   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_9(_tokenSet_9_data_,4);
1552 < const unsigned long MDParser::_tokenSet_10_data_[] = { 69992448UL, 0UL, 0UL, 0UL };
1552 > const unsigned long MDParser::_tokenSet_10_data_[] = { 277610496UL, 0UL, 0UL, 0UL };
1553   // "position" "orientation" ID RCURLY
1554   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_10(_tokenSet_10_data_,4);
1555 < const unsigned long MDParser::_tokenSet_11_data_[] = { 1073741824UL, 0UL, 0UL, 0UL };
1555 > const unsigned long MDParser::_tokenSet_11_data_[] = { 0UL, 1UL, 0UL, 0UL };
1556   // RPAREN
1557   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_11(_tokenSet_11_data_,4);
1558 < const unsigned long MDParser::_tokenSet_12_data_[] = { 69271552UL, 0UL, 0UL, 0UL };
1558 > const unsigned long MDParser::_tokenSet_12_data_[] = { 276889600UL, 0UL, 0UL, 0UL };
1559   // "members" ID RCURLY
1560   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_12(_tokenSet_12_data_,4);
1561 < const unsigned long MDParser::_tokenSet_13_data_[] = { 69337088UL, 0UL, 0UL, 0UL };
1561 > const unsigned long MDParser::_tokenSet_13_data_[] = { 276955136UL, 0UL, 0UL, 0UL };
1562   // "center" ID RCURLY
1563   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_13(_tokenSet_13_data_,4);
1564 < const unsigned long MDParser::_tokenSet_14_data_[] = { 69206016UL, 0UL, 0UL, 0UL };
1564 > const unsigned long MDParser::_tokenSet_14_data_[] = { 276824064UL, 0UL, 0UL, 0UL };
1565   // ID RCURLY
1566   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_14(_tokenSet_14_data_,4);
1567 < const unsigned long MDParser::_tokenSet_15_data_[] = { 3221225472UL, 0UL, 0UL, 0UL };
1567 > const unsigned long MDParser::_tokenSet_15_data_[] = { 0UL, 3UL, 0UL, 0UL };
1568   // RPAREN COMMA
1569   const ANTLR_USE_NAMESPACE(antlr)BitSet MDParser::_tokenSet_15(_tokenSet_15_data_,4);
1570  

Diff Legend

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