GPLIB++: JParser.cpp Source File

00001 /* $ANTLR 2.7.6 (20070220): "JParser.g" -> "JParser.cpp"$ */
00002 #include "JParser.hpp"
00003 #include <antlr/NoViableAltException.hpp>
00004 #include <antlr/SemanticException.hpp>
00005 #include <antlr/ASTFactory.hpp>
00006 #line 1 "JParser.g"
00007 #line 8 "JParser.cpp"
00008 JParser::JParser(antlr::TokenBuffer& tokenBuf, int k)
00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }
00012 
00013 JParser::JParser(antlr::TokenBuffer& tokenBuf)
00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }
00017 
00018 JParser::JParser(antlr::TokenStream& lexer, int k)
00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }
00022 
00023 JParser::JParser(antlr::TokenStream& lexer)
00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }
00027 
00028 JParser::JParser(const antlr::ParserSharedInputState& state)
00029 : antlr::LLkParser(state,10)
00030 {
00031 }
00032 
00033 void JParser::jfile() {
00034 #line 52 "JParser.g"
00035         
00036                 zassigned = false;
00037                 rassigned = false;
00038                 tassigned = false;
00039                 latitude = 0;
00040                 longitude =0;
00041                 elevation = 0;
00042                 azimuth = 0;
00043                 name = "default";
00044                 DataXX.name = "zxx";
00045                 DataXY.name = "zxy";
00046                 DataYX.name = "zyx";
00047                 DataYY.name = "zyy";
00048                 DataZX.name = "tzx";
00049                 DataZY.name = "tzy";
00050         
00051 #line 52 "JParser.cpp"
00052         
00053         try {      // for error handling
00054                 commentblock();
00055                 informationblock();
00056                 name=stringvalue();
00057                 match(NEWLINE);
00058                 datablock();
00059                 match(antlr::Token::EOF_TYPE);
00060         }
00061         catch (antlr::RecognitionException& ex) {
00062                 if( inputState->guessing == 0 ) {
00063                         reportError(ex);
00064                         recover(ex,_tokenSet_0);
00065                 } else {
00066                         throw;
00067                 }
00068         }
00069 }
00070 
00071 void JParser::commentblock() {
00072         
00073         try {      // for error handling
00074                 { // ( ... )*
00075                 for (;;) {
00076                         if ((LA(1) == COMMENT)) {
00077                                 match(COMMENT);
00078                         }
00079                         else {
00080                                 goto _loop4;
00081                         }
00082                         
00083                 }
00084                 _loop4:;
00085                 } // ( ... )*
00086         }
00087         catch (antlr::RecognitionException& ex) {
00088                 if( inputState->guessing == 0 ) {
00089                         reportError(ex);
00090                         recover(ex,_tokenSet_1);
00091                 } else {
00092                         throw;
00093                 }
00094         }
00095 }
00096 
00097 void JParser::informationblock() {
00098 #line 77 "JParser.g"
00099         double temp;
00100 #line 101 "JParser.cpp"
00101         
00102         try {      // for error handling
00103                 { // ( ... )*
00104                 for (;;) {
00105                         if (((LA(1) >= AZIMUTH && LA(1) <= STATION))) {
00106                                 {
00107                                 switch ( LA(1)) {
00108                                 case AZIMUTH:
00109                                 {
00110                                         match(AZIMUTH);
00111                                         if ( inputState->guessing==0 ) {
00112 #line 79 "JParser.g"
00113                                                 currdouble = &azimuth; isstring = false; std::cout << "Reading Az. ";
00114 #line 115 "JParser.cpp"
00115                                         }
00116                                         break;
00117                                 }
00118                                 case LATITUDE:
00119                                 {
00120                                         match(LATITUDE);
00121                                         if ( inputState->guessing==0 ) {
00122 #line 80 "JParser.g"
00123                                                 currdouble = &latitude; isstring = false;std::cout << "Reading Lat. ";
00124 #line 125 "JParser.cpp"
00125                                         }
00126                                         break;
00127                                 }
00128                                 case LONGITUDE:
00129                                 {
00130                                         match(LONGITUDE);
00131                                         if ( inputState->guessing==0 ) {
00132 #line 81 "JParser.g"
00133                                                 currdouble = &longitude; isstring = false;std::cout << "Reading Long. ";
00134 #line 135 "JParser.cpp"
00135                                         }
00136                                         break;
00137                                 }
00138                                 case ELEVATION:
00139                                 {
00140                                         match(ELEVATION);
00141                                         if ( inputState->guessing==0 ) {
00142 #line 82 "JParser.g"
00143                                                 currdouble = &elevation; isstring = false;std::cout << "Reading El. ";
00144 #line 145 "JParser.cpp"
00145                                         }
00146                                         break;
00147                                 }
00148                                 case STATION:
00149                                 {
00150                                         match(STATION);
00151                                         if ( inputState->guessing==0 ) {
00152 #line 83 "JParser.g"
00153                                                 isstring = true;
00154 #line 155 "JParser.cpp"
00155                                         }
00156                                         break;
00157                                 }
00158                                 default:
00159                                 {
00160                                         throw antlr::NoViableAltException(LT(1), getFilename());
00161                                 }
00162                                 }
00163                                 }
00164                                 match(EQUAL);
00165                                 {
00166                                 if (((LA(1) == ENTRY) && (LA(2) == NEWLINE) && (_tokenSet_1.member(LA(3))) && (LA(4) == NEWLINE || LA(4) == EQUAL) && (_tokenSet_2.member(LA(5))) && (_tokenSet_3.member(LA(6))) && (_tokenSet_4.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_6.member(LA(9))) && (_tokenSet_7.member(LA(10))))&&(isstring)) {
00167                                         name=stringvalue();
00168                                         if ( inputState->guessing==0 ) {
00169 #line 84 "JParser.g"
00170                                                 std::cout << name << std::endl;
00171 #line 172 "JParser.cpp"
00172                                         }
00173                                 }
00174                                 else if ((LA(1) == UNDEF || LA(1) == ENTRY) && (LA(2) == NEWLINE) && (_tokenSet_1.member(LA(3))) && (LA(4) == NEWLINE || LA(4) == EQUAL) && (_tokenSet_2.member(LA(5))) && (_tokenSet_3.member(LA(6))) && (_tokenSet_4.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_6.member(LA(9))) && (_tokenSet_7.member(LA(10)))) {
00175                                         temp=datavalue();
00176                                         if ( inputState->guessing==0 ) {
00177 #line 85 "JParser.g"
00178                                                 *currdouble = temp;std::cout << temp << std::endl;
00179 #line 180 "JParser.cpp"
00180                                         }
00181                                 }
00182                                 else if ((LA(1) == NEWLINE)) {
00183                                 }
00184                                 else {
00185                                         throw antlr::NoViableAltException(LT(1), getFilename());
00186                                 }
00187                                 
00188                                 }
00189                                 match(NEWLINE);
00190                         }
00191                         else {
00192                                 goto _loop9;
00193                         }
00194                         
00195                 }
00196                 _loop9:;
00197                 } // ( ... )*
00198         }
00199         catch (antlr::RecognitionException& ex) {
00200                 if( inputState->guessing == 0 ) {
00201                         reportError(ex);
00202                         recover(ex,_tokenSet_8);
00203                 } else {
00204                         throw;
00205                 }
00206         }
00207 }
00208 
00209 std::string  JParser::stringvalue() {
00210 #line 187 "JParser.g"
00211         std::string r;
00212 #line 213 "JParser.cpp"
00213         antlr::RefToken  currvalue = antlr::nullToken;
00214         
00215         try {      // for error handling
00216                 currvalue = LT(1);
00217                 match(ENTRY);
00218                 if ( inputState->guessing==0 ) {
00219 #line 188 "JParser.g"
00220                         r = currvalue->getText();
00221 #line 222 "JParser.cpp"
00222                 }
00223         }
00224         catch (antlr::RecognitionException& ex) {
00225                 if( inputState->guessing == 0 ) {
00226                         reportError(ex);
00227                         recover(ex,_tokenSet_9);
00228                 } else {
00229                         throw;
00230                 }
00231         }
00232         return r;
00233 }
00234 
00235 void JParser::datablock() {
00236         
00237         try {      // for error handling
00238                 { // ( ... )+
00239                 int _cnt12=0;
00240                 for (;;) {
00241                         if (((LA(1) >= ZXX && LA(1) <= TZY))) {
00242                                 datasection();
00243                         }
00244                         else {
00245                                 if ( _cnt12>=1 ) { goto _loop12; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00246                         }
00247                         
00248                         _cnt12++;
00249                 }
00250                 _loop12:;
00251                 }  // ( ... )+
00252         }
00253         catch (antlr::RecognitionException& ex) {
00254                 if( inputState->guessing == 0 ) {
00255                         reportError(ex);
00256                         recover(ex,_tokenSet_0);
00257                 } else {
00258                         throw;
00259                 }
00260         }
00261 }
00262 
00263 double  JParser::datavalue() {
00264 #line 182 "JParser.g"
00265         double r;
00266 #line 267 "JParser.cpp"
00267         antlr::RefToken  currvalue = antlr::nullToken;
00268         
00269         try {      // for error handling
00270                 {
00271                 switch ( LA(1)) {
00272                 case UNDEF:
00273                 {
00274                         match(UNDEF);
00275                         if ( inputState->guessing==0 ) {
00276 #line 183 "JParser.g"
00277                                 r = -1000000000;
00278 #line 279 "JParser.cpp"
00279                         }
00280                         break;
00281                 }
00282                 case ENTRY:
00283                 {
00284                         currvalue = LT(1);
00285                         match(ENTRY);
00286                         if ( inputState->guessing==0 ) {
00287 #line 184 "JParser.g"
00288                                 r = atof(currvalue->getText().c_str());
00289 #line 290 "JParser.cpp"
00290                         }
00291                         break;
00292                 }
00293                 default:
00294                 {
00295                         throw antlr::NoViableAltException(LT(1), getFilename());
00296                 }
00297                 }
00298                 }
00299         }
00300         catch (antlr::RecognitionException& ex) {
00301                 if( inputState->guessing == 0 ) {
00302                         reportError(ex);
00303                         recover(ex,_tokenSet_10);
00304                 } else {
00305                         throw;
00306                 }
00307         }
00308         return r;
00309 }
00310 
00311 void JParser::datasection() {
00312 #line 94 "JParser.g"
00313         
00314                 CurrentComp = NULL;
00315                 zsection = false;
00316                 rsection = false;
00317                 tsection = false;
00318                 currindex =0;
00319                 convfactor = 1/(1000 * mu);
00320                 int size;
00321 #line 322 "JParser.cpp"
00322         
00323         try {      // for error handling
00324                 {
00325                 switch ( LA(1)) {
00326                 case ZXX:
00327                 {
00328                         match(ZXX);
00329                         if ( inputState->guessing==0 ) {
00330 #line 103 "JParser.g"
00331                                 zsection = true; rsection = false; CurrentComp=&DataXX;CurrentCoh=&Rx;
00332 #line 333 "JParser.cpp"
00333                         }
00334                         break;
00335                 }
00336                 case ZXY:
00337                 {
00338                         match(ZXY);
00339                         if ( inputState->guessing==0 ) {
00340 #line 104 "JParser.g"
00341                                 zsection = true; rsection = false;CurrentComp=&DataXY;CurrentCoh=&Rx;
00342 #line 343 "JParser.cpp"
00343                         }
00344                         break;
00345                 }
00346                 case ZYX:
00347                 {
00348                         match(ZYX);
00349                         if ( inputState->guessing==0 ) {
00350 #line 105 "JParser.g"
00351                                 zsection = true; rsection = false;CurrentComp=&DataYX;CurrentCoh=&Ry;
00352 #line 353 "JParser.cpp"
00353                         }
00354                         break;
00355                 }
00356                 case ZYY:
00357                 {
00358                         match(ZYY);
00359                         if ( inputState->guessing==0 ) {
00360 #line 106 "JParser.g"
00361                                 zsection = true; rsection = false;CurrentComp=&DataYY;CurrentCoh=&Ry;
00362 #line 363 "JParser.cpp"
00363                         }
00364                         break;
00365                 }
00366                 case RXX:
00367                 {
00368                         match(RXX);
00369                         if ( inputState->guessing==0 ) {
00370 #line 107 "JParser.g"
00371                                 rsection = true; zsection = false;CurrentComp=&DataXX;
00372 #line 373 "JParser.cpp"
00373                         }
00374                         break;
00375                 }
00376                 case RXY:
00377                 {
00378                         match(RXY);
00379                         if ( inputState->guessing==0 ) {
00380 #line 108 "JParser.g"
00381                                 rsection = true; zsection = false;CurrentComp=&DataXY;
00382 #line 383 "JParser.cpp"
00383                         }
00384                         break;
00385                 }
00386                 case RYX:
00387                 {
00388                         match(RYX);
00389                         if ( inputState->guessing==0 ) {
00390 #line 109 "JParser.g"
00391                                 rsection = true; zsection = false;CurrentComp=&DataYX;
00392 #line 393 "JParser.cpp"
00393                         }
00394                         break;
00395                 }
00396                 case RYY:
00397                 {
00398                         match(RYY);
00399                         if ( inputState->guessing==0 ) {
00400 #line 110 "JParser.g"
00401                                 rsection = true; zsection = false;CurrentComp=&DataYY;
00402 #line 403 "JParser.cpp"
00403                         }
00404                         break;
00405                 }
00406                 case TZX:
00407                 {
00408                         match(TZX);
00409                         if ( inputState->guessing==0 ) {
00410 #line 111 "JParser.g"
00411                                 tsection = true; rsection = false; zsection = false; CurrentComp=&DataZX;CurrentCoh=&Rz;
00412 #line 413 "JParser.cpp"
00413                         }
00414                         break;
00415                 }
00416                 case TZY:
00417                 {
00418                         match(TZY);
00419                         if ( inputState->guessing==0 ) {
00420 #line 112 "JParser.g"
00421                                 tsection = true; rsection = false; zsection = false; CurrentComp=&DataZY;CurrentCoh=&Rz;
00422 #line 423 "JParser.cpp"
00423                         }
00424                         break;
00425                 }
00426                 default:
00427                 {
00428                         throw antlr::NoViableAltException(LT(1), getFilename());
00429                 }
00430                 }
00431                 }
00432                 {
00433                 switch ( LA(1)) {
00434                 case SI:
00435                 {
00436                         match(SI);
00437                         if ( inputState->guessing==0 ) {
00438 #line 113 "JParser.g"
00439                                 convfactor = 1./(1000. * mu);
00440 #line 441 "JParser.cpp"
00441                         }
00442                         break;
00443                 }
00444                 case FIELD:
00445                 {
00446                         match(FIELD);
00447                         if ( inputState->guessing==0 ) {
00448 #line 113 "JParser.g"
00449                                 convfactor = 1;
00450 #line 451 "JParser.cpp"
00451                         }
00452                         break;
00453                 }
00454                 case NEWLINE:
00455                 case UNITS:
00456                 {
00457                         break;
00458                 }
00459                 default:
00460                 {
00461                         throw antlr::NoViableAltException(LT(1), getFilename());
00462                 }
00463                 }
00464                 }
00465                 {
00466                 switch ( LA(1)) {
00467                 case UNITS:
00468                 {
00469                         match(UNITS);
00470                         break;
00471                 }
00472                 case NEWLINE:
00473                 {
00474                         break;
00475                 }
00476                 default:
00477                 {
00478                         throw antlr::NoViableAltException(LT(1), getFilename());
00479                 }
00480                 }
00481                 }
00482                 match(NEWLINE);
00483                 size=datavalue();
00484                 if ( inputState->guessing==0 ) {
00485 #line 114 "JParser.g"
00486                         
00487                                                         if (CurrentComp != NULL && (CurrentComp->Z.empty()))
00488                                                         {
00489                                                                 CurrentComp->Z.assign(size,0);
00490                                                                 CurrentComp->dZ.assign(size,0);
00491                                                                 CurrentComp->rhoa.assign(size,0);
00492                                                                 CurrentComp->phi.assign(size,0);
00493                                                                 CurrentComp->drhoa.assign(size,0);
00494                                                                 CurrentComp->dphi.assign(size,0);
00495                                                                 if (frequency.empty())
00496                                                                 {
00497                                                                         frequency.assign(size,-1);
00498                                                                         Rx.assign(size,0);
00499                                                                         Ry.assign(size,0);
00500                                                                         Rz.assign(size,0);
00501                                                                 }
00502                                                         }
00503                                                         
00504 #line 505 "JParser.cpp"
00505                 }
00506                 match(NEWLINE);
00507                 { // ( ... )+
00508                 int _cnt20=0;
00509                 for (;;) {
00510                         if (((LA(1) == UNDEF || LA(1) == ENTRY) && (LA(2) == UNDEF || LA(2) == ENTRY) && (LA(3) == UNDEF || LA(3) == ENTRY) && (LA(4) == UNDEF || LA(4) == ENTRY) && (LA(5) == UNDEF || LA(5) == ENTRY) && (LA(6) == NEWLINE || LA(6) == UNDEF || LA(6) == ENTRY) && (_tokenSet_11.member(LA(7))) && (_tokenSet_12.member(LA(8))) && (_tokenSet_13.member(LA(9))) && (_tokenSet_14.member(LA(10))))&&(zsection)) {
00511                                 zdata();
00512                         }
00513                         else if ((LA(1) == UNDEF || LA(1) == ENTRY) && (LA(2) == UNDEF || LA(2) == ENTRY) && (LA(3) == UNDEF || LA(3) == ENTRY) && (LA(4) == UNDEF || LA(4) == ENTRY) && (LA(5) == UNDEF || LA(5) == ENTRY) && (LA(6) == UNDEF || LA(6) == ENTRY) && (LA(7) == UNDEF || LA(7) == ENTRY) && (LA(8) == UNDEF || LA(8) == ENTRY) && (LA(9) == UNDEF || LA(9) == ENTRY) && (LA(10) == NEWLINE)) {
00514                                 {
00515                                 if (!(rsection))
00516                                         throw antlr::SemanticException("rsection");
00517                                 rdata();
00518                                 }
00519                         }
00520                         else if ((LA(1) == UNDEF || LA(1) == ENTRY) && (LA(2) == UNDEF || LA(2) == ENTRY) && (LA(3) == UNDEF || LA(3) == ENTRY) && (LA(4) == UNDEF || LA(4) == ENTRY) && (LA(5) == UNDEF || LA(5) == ENTRY) && (LA(6) == NEWLINE || LA(6) == UNDEF || LA(6) == ENTRY) && (_tokenSet_11.member(LA(7))) && (_tokenSet_12.member(LA(8))) && (_tokenSet_13.member(LA(9))) && (_tokenSet_14.member(LA(10)))) {
00521                                 {
00522                                 if (!(tsection))
00523                                         throw antlr::SemanticException("tsection");
00524                                 tdata();
00525                                 }
00526                         }
00527                         else {
00528                                 if ( _cnt20>=1 ) { goto _loop20; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00529                         }
00530                         
00531                         _cnt20++;
00532                 }
00533                 _loop20:;
00534                 }  // ( ... )+
00535         }
00536         catch (antlr::RecognitionException& ex) {
00537                 if( inputState->guessing == 0 ) {
00538                         reportError(ex);
00539                         recover(ex,_tokenSet_15);
00540                 } else {
00541                         throw;
00542                 }
00543         }
00544 }
00545 
00546 void JParser::zdata() {
00547 #line 137 "JParser.g"
00548         double r1,r2,r3,r4,r5,r6=0;
00549 #line 550 "JParser.cpp"
00550         
00551         try {      // for error handling
00552                 r1=datavalue();
00553                 r2=datavalue();
00554                 r3=datavalue();
00555                 r4=datavalue();
00556                 r5=datavalue();
00557                 {
00558                 switch ( LA(1)) {
00559                 case UNDEF:
00560                 case ENTRY:
00561                 {
00562                         r6=datavalue();
00563                         break;
00564                 }
00565                 case NEWLINE:
00566                 {
00567                         break;
00568                 }
00569                 default:
00570                 {
00571                         throw antlr::NoViableAltException(LT(1), getFilename());
00572                 }
00573                 }
00574                 }
00575                 match(NEWLINE);
00576                 if ( inputState->guessing==0 ) {
00577 #line 140 "JParser.g"
00578                                 if (r1 > 0)
00579                                                 frequency.at(currindex) = 1./r1;
00580                                         else
00581                                                 if (frequency.at(currindex) != 0)
00582                                                         frequency.at(currindex) = r1;
00583                                         CurrentComp->Z.at(currindex) = convfactor * (r2 + I * r3);
00584                                         CurrentComp->dZ.at(currindex) = convfactor * r4;
00585                                         CurrentCoh->at(currindex) = r6;
00586                                         if (r2 == -1000000000 || r3 == -1000000000)
00587                                                 frequency.at(currindex) = 0;
00588                                         currindex++;
00589                                         zassigned = true;
00590 #line 591 "JParser.cpp"
00591                 }
00592         }
00593         catch (antlr::RecognitionException& ex) {
00594                 if( inputState->guessing == 0 ) {
00595                         reportError(ex);
00596                         recover(ex,_tokenSet_16);
00597                 } else {
00598                         throw;
00599                 }
00600         }
00601 }
00602 
00603 void JParser::rdata() {
00604 #line 154 "JParser.g"
00605         double r1,r2,r3,r4,r5,r6,r7,r8,r9=0;
00606 #line 607 "JParser.cpp"
00607         
00608         try {      // for error handling
00609                 r1=datavalue();
00610                 r2=datavalue();
00611                 r3=datavalue();
00612                 r4=datavalue();
00613                 r5=datavalue();
00614                 r6=datavalue();
00615                 r7=datavalue();
00616                 r8=datavalue();
00617                 r9=datavalue();
00618                 match(NEWLINE);
00619                 if ( inputState->guessing==0 ) {
00620 #line 158 "JParser.g"
00621                         if (r1 > 0)
00622                                                 frequency.at(currindex) = 1./r1;
00623                                         else
00624                                                 frequency.at(currindex) = r1;
00625                                         CurrentComp->rhoa.at(currindex) = r2;
00626                                         CurrentComp->phi.at(currindex) = r3;
00627                                         currindex++; 
00628                                         rassigned = true;
00629 #line 630 "JParser.cpp"
00630                 }
00631         }
00632         catch (antlr::RecognitionException& ex) {
00633                 if( inputState->guessing == 0 ) {
00634                         reportError(ex);
00635                         recover(ex,_tokenSet_16);
00636                 } else {
00637                         throw;
00638                 }
00639         }
00640 }
00641 
00642 void JParser::tdata() {
00643 #line 168 "JParser.g"
00644         double r1,r2,r3,r4,r5,r6;
00645 #line 646 "JParser.cpp"
00646         
00647         try {      // for error handling
00648                 r1=datavalue();
00649                 r2=datavalue();
00650                 r3=datavalue();
00651                 r4=datavalue();
00652                 r5=datavalue();
00653                 {
00654                 switch ( LA(1)) {
00655                 case UNDEF:
00656                 case ENTRY:
00657                 {
00658                         r6=datavalue();
00659                         break;
00660                 }
00661                 case NEWLINE:
00662                 {
00663                         break;
00664                 }
00665                 default:
00666                 {
00667                         throw antlr::NoViableAltException(LT(1), getFilename());
00668                 }
00669                 }
00670                 }
00671                 match(NEWLINE);
00672                 if ( inputState->guessing==0 ) {
00673 #line 171 "JParser.g"
00674                                 if (r1 > 0)
00675                                                 frequency.at(currindex) = 1./r1;
00676                                         else
00677                                                 frequency.at(currindex) = r1;
00678                                         CurrentComp->Z.at(currindex) = r2 + I * r3;
00679                                         CurrentComp->dZ.at(currindex) = r4;
00680                                         currindex++;
00681                                         tassigned = true;
00682 #line 683 "JParser.cpp"
00683                 }
00684         }
00685         catch (antlr::RecognitionException& ex) {
00686                 if( inputState->guessing == 0 ) {
00687                         reportError(ex);
00688                         recover(ex,_tokenSet_16);
00689                 } else {
00690                         throw;
00691                 }
00692         }
00693 }
00694 
00695 void JParser::initializeASTFactory( antlr::ASTFactory& )
00696 {
00697 }
00698 const char* JParser::tokenNames[] = {
00699         "<0>",
00700         "EOF",
00701         "<2>",
00702         "NULL_TREE_LOOKAHEAD",
00703         "NEWLINE",
00704         "COMMENT",
00705         "AZIMUTH",
00706         "LATITUDE",
00707         "LONGITUDE",
00708         "ELEVATION",
00709         "STATION",
00710         "EQUAL",
00711         "ZXX",
00712         "ZXY",
00713         "ZYX",
00714         "ZYY",
00715         "RXX",
00716         "RXY",
00717         "RYX",
00718         "RYY",
00719         "TZX",
00720         "TZY",
00721         "SI",
00722         "FIELD",
00723         "UNITS",
00724         "UNDEF",
00725         "ENTRY",
00726         "PLUS",
00727         "MINUS",
00728         "WS",
00729         "DIGIT",
00730         "CHAR",
00731         "OTHER",
00732         0
00733 };
00734 
00735 const unsigned long JParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL };
00736 // EOF 
00737 const antlr::BitSet JParser::_tokenSet_0(_tokenSet_0_data_,4);
00738 const unsigned long JParser::_tokenSet_1_data_[] = { 67110848UL, 0UL, 0UL, 0UL };
00739 // AZIMUTH LATITUDE LONGITUDE ELEVATION STATION ENTRY 
00740 const antlr::BitSet JParser::_tokenSet_1(_tokenSet_1_data_,4);
00741 const unsigned long JParser::_tokenSet_2_data_[] = { 104853520UL, 0UL, 0UL, 0UL };
00742 // NEWLINE ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY UNDEF ENTRY 
00743 const antlr::BitSet JParser::_tokenSet_2(_tokenSet_2_data_,4);
00744 const unsigned long JParser::_tokenSet_3_data_[] = { 96470992UL, 0UL, 0UL, 0UL };
00745 // NEWLINE AZIMUTH LATITUDE LONGITUDE ELEVATION STATION SI FIELD UNITS 
00746 // ENTRY 
00747 const antlr::BitSet JParser::_tokenSet_3(_tokenSet_3_data_,4);
00748 const unsigned long JParser::_tokenSet_4_data_[] = { 117444560UL, 0UL, 0UL, 0UL };
00749 // NEWLINE AZIMUTH LATITUDE LONGITUDE ELEVATION STATION EQUAL UNITS UNDEF 
00750 // ENTRY 
00751 const antlr::BitSet JParser::_tokenSet_4(_tokenSet_4_data_,4);
00752 const unsigned long JParser::_tokenSet_5_data_[] = { 104855568UL, 0UL, 0UL, 0UL };
00753 // NEWLINE EQUAL ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY UNDEF ENTRY 
00754 const antlr::BitSet JParser::_tokenSet_5(_tokenSet_5_data_,4);
00755 const unsigned long JParser::_tokenSet_6_data_[] = { 134215632UL, 0UL, 0UL, 0UL };
00756 // NEWLINE AZIMUTH LATITUDE LONGITUDE ELEVATION STATION ZXX ZXY ZYX ZYY 
00757 // RXX RXY RYX RYY TZX TZY SI FIELD UNITS UNDEF ENTRY 
00758 const antlr::BitSet JParser::_tokenSet_6(_tokenSet_6_data_,4);
00759 const unsigned long JParser::_tokenSet_7_data_[] = { 130027472UL, 0UL, 0UL, 0UL };
00760 // NEWLINE AZIMUTH LATITUDE LONGITUDE ELEVATION STATION EQUAL SI FIELD 
00761 // UNITS UNDEF ENTRY 
00762 const antlr::BitSet JParser::_tokenSet_7(_tokenSet_7_data_,4);
00763 const unsigned long JParser::_tokenSet_8_data_[] = { 67108864UL, 0UL, 0UL, 0UL };
00764 // ENTRY 
00765 const antlr::BitSet JParser::_tokenSet_8(_tokenSet_8_data_,4);
00766 const unsigned long JParser::_tokenSet_9_data_[] = { 16UL, 0UL, 0UL, 0UL };
00767 // NEWLINE 
00768 const antlr::BitSet JParser::_tokenSet_9(_tokenSet_9_data_,4);
00769 const unsigned long JParser::_tokenSet_10_data_[] = { 100663312UL, 0UL, 0UL, 0UL };
00770 // NEWLINE UNDEF ENTRY 
00771 const antlr::BitSet JParser::_tokenSet_10(_tokenSet_10_data_,4);
00772 const unsigned long JParser::_tokenSet_11_data_[] = { 104853522UL, 0UL, 0UL, 0UL };
00773 // EOF NEWLINE ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY UNDEF ENTRY 
00774 const antlr::BitSet JParser::_tokenSet_11(_tokenSet_11_data_,4);
00775 const unsigned long JParser::_tokenSet_12_data_[] = { 134213650UL, 0UL, 0UL, 0UL };
00776 // EOF NEWLINE ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY SI FIELD UNITS UNDEF 
00777 // ENTRY 
00778 const antlr::BitSet JParser::_tokenSet_12(_tokenSet_12_data_,4);
00779 const unsigned long JParser::_tokenSet_13_data_[] = { 130023442UL, 0UL, 0UL, 0UL };
00780 // EOF NEWLINE SI FIELD UNITS UNDEF ENTRY 
00781 const antlr::BitSet JParser::_tokenSet_13(_tokenSet_13_data_,4);
00782 const unsigned long JParser::_tokenSet_14_data_[] = { 117440530UL, 0UL, 0UL, 0UL };
00783 // EOF NEWLINE UNITS UNDEF ENTRY 
00784 const antlr::BitSet JParser::_tokenSet_14(_tokenSet_14_data_,4);
00785 const unsigned long JParser::_tokenSet_15_data_[] = { 4190210UL, 0UL, 0UL, 0UL };
00786 // EOF ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY 
00787 const antlr::BitSet JParser::_tokenSet_15(_tokenSet_15_data_,4);
00788 const unsigned long JParser::_tokenSet_16_data_[] = { 104853506UL, 0UL, 0UL, 0UL };
00789 // EOF ZXX ZXY ZYX ZYY RXX RXY RYX RYY TZX TZY UNDEF ENTRY 
00790 const antlr::BitSet JParser::_tokenSet_16(_tokenSet_16_data_,4);
00791 
00792