JParser Class Reference

#include <JParser.hpp>

Inheritance diagram for JParser:

Inheritance graph
[legend]
Collaboration diagram for JParser:

Collaboration graph
[legend]
List of all members.

Public Member Functions

void initializeASTFactory (antlr::ASTFactory &factory)
 JParser (antlr::TokenBuffer &tokenBuf)
 JParser (antlr::TokenStream &lexer)
 JParser (const antlr::ParserSharedInputState &state)
int getNumTokens () const
const char * getTokenName (int type) const
const char *const * getTokenNames () const
void jfile ()
void commentblock ()
void informationblock ()
std::string stringvalue ()
void datablock ()
double datavalue ()
void datasection ()
void zdata ()
void rdata ()
void tdata ()
antlr::RefAST getAST ()

Public Attributes

trealdata frequency
trealdata Rx
trealdata Ry
trealdata Rz
CMTDataComp DataXX
CMTDataComp DataXY
CMTDataComp DataYX
CMTDataComp DataYY
CMTDataComp DataZX
CMTDataComp DataZY
double latitude
double longitude
double elevation
double azimuth
std::string name
bool tassigned
bool zassigned
bool rassigned

Protected Member Functions

 JParser (antlr::TokenBuffer &tokenBuf, int k)
 JParser (antlr::TokenStream &lexer, int k)

Protected Attributes

antlr::RefAST returnAST

Detailed Description

Definition at line 20 of file JParser.hpp.


Constructor & Destructor Documentation

JParser::JParser ( antlr::TokenBuffer &  tokenBuf,
int  k 
) [protected]

Definition at line 8 of file JParser.cpp.

00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }

JParser::JParser ( antlr::TokenBuffer &  tokenBuf  ) 

Definition at line 13 of file JParser.cpp.

00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }

JParser::JParser ( antlr::TokenStream &  lexer,
int  k 
) [protected]

Definition at line 18 of file JParser.cpp.

00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }

JParser::JParser ( antlr::TokenStream &  lexer  ) 

Definition at line 23 of file JParser.cpp.

00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }

JParser::JParser ( const antlr::ParserSharedInputState &  state  ) 

Definition at line 28 of file JParser.cpp.

00029 : antlr::LLkParser(state,10)
00030 {
00031 }


Member Function Documentation

void JParser::initializeASTFactory ( antlr::ASTFactory &  factory  ) 

Definition at line 695 of file JParser.cpp.

00696 {
00697 }

int JParser::getNumTokens (  )  const [inline]

Definition at line 65 of file JParser.hpp.

00066         {
00067                 return JParser::NUM_TOKENS;
00068         }

const char* JParser::getTokenName ( int  type  )  const [inline]

Definition at line 69 of file JParser.hpp.

00070         {
00071                 if( type > getNumTokens() ) return 0;
00072                 return JParser::tokenNames[type];
00073         }

const char* const* JParser::getTokenNames (  )  const [inline]

Definition at line 74 of file JParser.hpp.

00075         {
00076                 return JParser::tokenNames;
00077         }

void JParser::jfile (  ) 

Definition at line 33 of file JParser.cpp.

References azimuth, commentblock(), datablock(), DataXX, DataXY, DataYX, DataYY, DataZX, DataZY, elevation, informationblock(), latitude, longitude, CMTDataComp::name, name, NEWLINE, rassigned, stringvalue(), tassigned, and zassigned.

00033                     {
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 }

Here is the call graph for this function:

void JParser::commentblock (  ) 

Definition at line 71 of file JParser.cpp.

References COMMENT.

Referenced by jfile().

00071                            {
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 }

void JParser::informationblock (  ) 

Definition at line 97 of file JParser.cpp.

References azimuth, AZIMUTH, datavalue(), elevation, ELEVATION, ENTRY, EQUAL, latitude, LATITUDE, longitude, LONGITUDE, name, NEWLINE, STATION, stringvalue(), and UNDEF.

Referenced by jfile().

00097                                {
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 }

Here is the call graph for this function:

std::string JParser::stringvalue (  ) 

Definition at line 209 of file JParser.cpp.

References ENTRY.

Referenced by informationblock(), and jfile().

00209                                 {
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 }

void JParser::datablock (  ) 

Definition at line 235 of file JParser.cpp.

References datasection(), TZY, and ZXX.

Referenced by jfile().

00235                         {
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 }

Here is the call graph for this function:

double JParser::datavalue (  ) 

Definition at line 263 of file JParser.cpp.

References ENTRY, and UNDEF.

Referenced by datasection(), informationblock(), rdata(), tdata(), and zdata().

00263                            {
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 }

void JParser::datasection (  ) 

Definition at line 311 of file JParser.cpp.

References datavalue(), DataXX, DataXY, DataYX, DataYY, DataZX, DataZY, CMTDataComp::dphi, CMTDataComp::drhoa, CMTDataComp::dZ, ENTRY, FIELD, frequency, NEWLINE, CMTDataComp::phi, rdata(), CMTDataComp::rhoa, Rx, RXX, RXY, Ry, RYX, RYY, Rz, SI, size, tdata(), TZX, TZY, UNDEF, UNITS, CMTDataComp::Z, zdata(), ZXX, ZXY, ZYX, and ZYY.

Referenced by datablock().

00311                           {
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 }

Here is the call graph for this function:

void JParser::zdata (  ) 

Definition at line 546 of file JParser.cpp.

References datavalue(), CMTDataComp::dZ, ENTRY, frequency, NEWLINE, UNDEF, CMTDataComp::Z, and zassigned.

Referenced by datasection().

00546                     {
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 }

Here is the call graph for this function:

void JParser::rdata (  ) 

Definition at line 603 of file JParser.cpp.

References datavalue(), frequency, NEWLINE, CMTDataComp::phi, rassigned, and CMTDataComp::rhoa.

Referenced by datasection().

00603                     {
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 }

Here is the call graph for this function:

void JParser::tdata (  ) 

Definition at line 642 of file JParser.cpp.

References datavalue(), CMTDataComp::dZ, ENTRY, frequency, NEWLINE, tassigned, UNDEF, and CMTDataComp::Z.

Referenced by datasection().

00642                     {
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 }

Here is the call graph for this function:

antlr::RefAST JParser::getAST (  )  [inline]

Definition at line 89 of file JParser.hpp.

00090         {
00091                 return returnAST;
00092         }


Member Data Documentation

trealdata JParser::frequency

Definition at line 35 of file JParser.hpp.

Referenced by datasection(), rdata(), tdata(), and zdata().

trealdata JParser::Rx

Definition at line 36 of file JParser.hpp.

Referenced by datasection().

trealdata JParser::Ry

Definition at line 37 of file JParser.hpp.

Referenced by datasection().

trealdata JParser::Rz

Definition at line 38 of file JParser.hpp.

Referenced by datasection().

CMTDataComp JParser::DataXX

Definition at line 39 of file JParser.hpp.

Referenced by datasection(), and jfile().

CMTDataComp JParser::DataXY

Definition at line 40 of file JParser.hpp.

Referenced by datasection(), and jfile().

CMTDataComp JParser::DataYX

Definition at line 41 of file JParser.hpp.

Referenced by datasection(), and jfile().

CMTDataComp JParser::DataYY

Definition at line 42 of file JParser.hpp.

Referenced by datasection(), and jfile().

CMTDataComp JParser::DataZX

Definition at line 43 of file JParser.hpp.

Referenced by datasection(), and jfile().

CMTDataComp JParser::DataZY

Definition at line 44 of file JParser.hpp.

Referenced by datasection(), and jfile().

double JParser::latitude

Definition at line 45 of file JParser.hpp.

Referenced by informationblock(), and jfile().

double JParser::longitude

Definition at line 46 of file JParser.hpp.

Referenced by informationblock(), and jfile().

double JParser::elevation

Definition at line 47 of file JParser.hpp.

Referenced by informationblock(), and jfile().

double JParser::azimuth

Definition at line 48 of file JParser.hpp.

Referenced by informationblock(), and jfile().

std::string JParser::name

Definition at line 49 of file JParser.hpp.

Referenced by informationblock(), and jfile().

bool JParser::tassigned

Definition at line 50 of file JParser.hpp.

Referenced by jfile(), and tdata().

bool JParser::zassigned

Definition at line 51 of file JParser.hpp.

Referenced by jfile(), and zdata().

bool JParser::rassigned

Definition at line 52 of file JParser.hpp.

Referenced by jfile(), and rdata().

antlr::RefAST JParser::returnAST [protected]

Definition at line 95 of file JParser.hpp.


The documentation for this class was generated from the following files:
Generated on Thu Nov 22 14:09:28 2007 for GPLIB++ by  doxygen 1.5.1