Stream.cpp

Go to the documentation of this file.

/*
 * Stream.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "../Include/Globals.h"
#include "../Include/FlyLegacy.h"
#include "../Include/Utility.h"


//
// Local function that reads the next line from the stream file, discards
//   comment lines, and returns a pointer to the start of the first
//   non-whitespace character in the line.  The complete line is copied
//   in to the buffer pointed to by s.
//
static char*  sgets (char* s, int maxLength, SStream *stream)
{
  char* p = s;

  bool keepGoing = true;
  while (keepGoing) {
    pgets (s, maxLength, (PODFILE*)stream->stream);

    // Skip whitespace and comments
    p = s;
    while ((*p == ' ') || (*p == '\t')) p++;

    // If not a comment, then go ahead and parse it
    if (strncmp (p, "//", 2) != 0) keepGoing = false;
  }

  return p;
}


static Tag    snexttag (char* s, int maxLength, SStream *stream)
{
  Tag tag = 0;

  char *p;
  bool gotTag = false;
  while (!gotTag) {
    p = sgets (s, maxLength, stream);
    // Check for brackets
    if ((strlen(p) >= 6) && (p[0] == '<') && (p[5] == '>')) {
      char tagstring[5];
      strncpy (tagstring, (p+1), 4);
      tag = StringToTag (tagstring);
      gotTag = true;
    }
  }
  return tag;
}


//
// OpenStream - Open a stream file for reading
//
// The function returns 1 if the stream was successfully opened, 0 otherwise
//


int   OpenStream(SStream *stream)
{
  return OpenStream (&globals->pfs, stream);
}


//
// OpenStream - Open a stream file for reading
//
// The function returns 1 if the stream was successfully opened, 0 otherwise
//


int   OpenStream(PFS *pfs, SStream *stream)
{
  int rc = 0;

  // Only allow read-access for now
  if (strcmp (stream->mode, "r") == 0) {
    // Open PODFILE
    stream->stream = popen (pfs, stream->filename);

    if (stream->stream != NULL) {
      // OK
      rc = 1;
    }
  }

  return rc;
}


//
// CloseStream - Close a stream file
//
// This function closes the specified stream file.  No further read/write operations
//   can be performed on the SStream object.
//
void  CloseStream(SStream *stream)
{
  pclose ((PODFILE*)stream->stream);
  stream->stream = NULL;
}


//
// ReadFrom - Initialize a CStreamObject from the contents of a stream file
//
// Example (CAircraft is descended from CStreamObject):
//   CAircraft *pAircraft = new CAircraft();
//   SStream *pStream = new SStream;
//   strcpy (pStream->filename, "World\\Flyhawk.nfo");
//   strcpy (pStream->mode, "r");
//   if (OpenStream (pStream)) {
//     // Stream successfully opened
//     ReadFrom (pAircraft, pStream);
//   }
//
void  ReadFrom(CStreamObject *object, SStream *stream)
{
  // The first tag should be <bgno>.  Some default files (e.g. TRI40.PNL) have
  //   missing <bgno> tags so this code must be tolerant of that.
  char s[256];
  Tag tag;
  bool openingBgno = true;

  // Start sending tags to the CStreamObject, up until (and not including)
  //   the <endo> corresponding to the <bgno> found above.  A count of
  //   nested sub-objects is kept to ensure that we don't quit prematurely
  int nestCount = 0;

  // Now continue to read tags until <endo>, sending them to CStreamObject::Read
  while ( ! (((tag = snexttag (s, 256, stream)) == 'endo') && (nestCount == 0))) {
    if (tag == 'bgno') {
      if (openingBgno) {
        // This is the expected opening <bgno>, just ignore it
      } else {
        // This is the start of a nested sub-object, increment nestCount
        nestCount++;
        object->Read (stream, tag);
      }
    } else if (tag == 'endo') {
      // This is the end of a nested sub-object, so decrement nestCount.
      //   Note that if nestCount is already zero, then we wouldn't get here
      nestCount--;
      object->Read (stream, tag);
    } else {
      // Normal tag, pass it to the object and keep going
      object->Read (stream, tag);
    }

    // After the first tag has been read, we are no longer expecting an
    //   opening <bgno>
    openingBgno = false;
  }

  // Finally call CStreamObject::ReadFinished
  object->ReadFinished();
}


//
// SkipObject - Skip over an object bracketed by <bgno> <endo> tags
//
// This function is called when it is desired to skip over a sub-object
//   (and all of its nested sub-sub-objects) in a stream file.  The first
//   tag read should be <bgno> which marks the beginning of the object to
//   be skipped.  From this point on, all tags and values are read and
//   discarded until the <endo> tag corresponding to the beginning tag
//   is read.
//
void  SkipObject(SStream *stream)
{
  // Advance to <bgno> tag
  char s[256];
  Tag tag;
  while ((tag = snexttag (s, 256, stream)) != 'bgno') {}

  // Continue reading tags up to the <endo> corresponding to the <bgno> found above.
  //   A count ofnested sub-objects is kept to ensure that we don't quit prematurely
  int nestCount = 0;

  // Now continue to read tags until <endo>, sending them to CStreamObject::Read
  bool keepGoing = true;
  while (keepGoing) {
    tag = snexttag (s, 256, stream);
    // == 'endo') && (nestCount == 0))) {
    if (tag == 'bgno') {
      // This is the start of a nested sub-object, so increment nestCount
      nestCount++;
    } else if (tag == 'endo') {
      // This is the end of either a nested sub-object (if nestCount > 0) or
      //   the end of the object we're skipping (if nestCount == 0)
      if (nestCount > 0) {
        nestCount--;
      } else {
        keepGoing = false;
      }
    }
  }
}


//
// AdvanceToTag - Skip forward until the specified tag is found
//

void  AdvanceToTag(unsigned int tag, SStream *stream)
{

}



//
// ReadInt - Read a (signed) integer value from the stream
//

void  ReadInt (int *value, SStream *stream)
{
  // Read up to next token
  char s[256];
  char *p = sgets (s, 256, stream);
  *value = atoi (p);
}


//
// ReadUInt - Read an unsigned integer value from the stream
//

void  ReadUInt (unsigned int *value, SStream *stream)
{
  // Read up to next token
  char s[256];
  char *p = sgets (s, 256, stream);

  // Parse data value
  *value = (unsigned int)(atoi(p));
}


//
// ReadFloat - Read a single-precision float value value from the stream
//
void  ReadFloat (float *value, SStream *stream)
{
  // Read up to next token
  char s[256];
  ReadString (s, 256, stream);
  *value = (float)(atof (s));
}


//
// ReadDouble - Read a double-precision float value value from the stream
//
void  ReadDouble (double *value, SStream *stream)
{
  // Read up to next token
  char s[256];
  ReadString (s, 256, stream);
  *value = atof (s);
}


//
// ReadString - Read a newline-terminated character string from the stream
//
void  ReadString (char *value, int maxLength, SStream *stream)
{
  // Read up to next token
  char s[256];
  char *p = sgets (s, 256, stream);

  // Trim all trailing whitespace by walking backwards from end of string until
  //   a non-whitespace char is found, then replace the succeeding char with \0
  char *q = p + strlen(p) - 1;
  while (isspace(*q)) q--;
  q++;
  *q = '\0';

  if ((int)strlen(p) >= maxLength) {
    // String was longer than supplied buffer
    globals->logWarning->Write ("ReadString : Line truncated (len=%d max=%d)\n%s",
      strlen(p), maxLength, p);
    strncpy (value, p, maxLength-1);
  } else {
    strcpy (value, p);
  }
}


//
// ReadVector - Read a three-component single-precision float vecotr from the stream
//
void  ReadVector (SVector *value, SStream *stream)
{
  // Read up to next token
  char s[256];
  char *p = sgets (s, 256, stream);

  // Parse the data value
  float x, y, z;
  sscanf (p, "%f, %f, %f", &x, &y, &z);
  value->x = (double)x;
  value->y = (double)y;
  value->z = (double)z;
}

//
// ReadLatLon - Read a geographical latitude/longitude position from a stream
//
// Format is:
//    33 56 24.6 N          (N 33 deg 56 min 24.6 sec latitude)
//    118 23 56.5 W         (W 118 deg, 23 min, 56.5 sec longitude)
//
void  ReadLatLon (SPosition *value, SStream *stream)
{
  // Declare locals for parsing of position strings
  char s[256];
  int deg, min;
  float sec;
  char  hemi;

  // First line is latitude
  ReadString (s, 256, stream);
  double lat = 0;
  if (sscanf (s, "%d %d %f %c", &deg, &min, &sec, &hemi) == 4) {
    switch (hemi) {
    case 'N':
    case 'n':
      lat = (deg * 3600.0) + (min * 60.0) + sec;
      break;

    case 'S':
    case 's':
      lat = -((deg * 3600.0) + (min * 60.0) + sec);
      break;

    default:
      gtfo ("ReadLatLon : Invalid latitude hemisphere <%c>", hemi);
    }
  } else {
    gtfo ("ReadLatLon : Malformed latitude string <%s>", s);
  }
  value->lat = lat;

  // Second line is longitude
  ReadString (s, 256, stream);
  double lon = 0;
  if (sscanf (s, "%d %d %f %c", &deg, &min, &sec, &hemi) == 4) {
    switch (hemi) {
    case 'E':
    case 'e':
      lon = (deg * 3600.0) + (min * 60.0) + sec;
      break;

    case 'W':
    case 'w':
      lon = (360.0 * 3600.0) - ((deg * 3600.0) + (min * 60.0) + sec);
      break;

    default:
      gtfo ("ReadPosition : Invalid longitude hemisphere <%c>", hemi);
    }
  } else {
    gtfo ("ReadPosition : Malformed longitude string <%s>", s);
  }
  value->lon = lon;

  // Set altitude to zero
  value->alt = 0;
}


//
// ReadPosition - Read a geographical position from the stream
//
// Format is:
//    33 56'24.6405"N        (N 33 deg 56 min 24.6405 sec latitude)
//    118 23'56.5173"W       (W 118 deg, 23 min, 56.5173 sec longitude)
//    94.248616728049114     (94 feet above MSL altitude)
//
void  ReadPosition (SPosition *value, SStream *stream)
{
  // Declare locals for parsing of position strings
  char s[256];
  int deg, min;
  float sec;
  char  hemi;

  // First line is latitude
  ReadString (s, 256, stream);
  double lat = 0;
  if (sscanf (s, "%d %d'%f\"%c", &deg, &min, &sec, &hemi) == 4) {
    switch (hemi) {
    case 'N':
    case 'n':
      lat = (deg * 3600.0) + (min * 60.0) + sec;
      break;

    case 'S':
    case 's':
      lat = -((deg * 3600.0) + (min * 60.0) + sec);
      break;

    default:
      gtfo ("ReadPosition : Invalid latitude hemisphere <%c>", hemi);
    }
  } else {
    gtfo ("ReadPosition : Malformed latitude string <%s>", s);
  }
  value->lat = lat;

  // Second line is longitude
  ReadString (s, 256, stream);
  double lon = 0;
  if (sscanf (s, "%d %d'%f\"%c", &deg, &min, &sec, &hemi) == 4) {
    switch (hemi) {
    case 'E':
    case 'e':
      lon = (deg * 3600.0) + (min * 60.0) + sec;
      break;

    case 'W':
    case 'w':
      lon = (360.0 * 3600.0) - ((deg * 3600.0) + (min * 60.0) + sec);
      break;

    default:
      gtfo ("ReadPosition : Invalid longitude hemisphere <%c>", hemi);
    }
  } else {
    gtfo ("ReadPosition : Malformed longitude string <%s>", s);
  }
  value->lon = lon;

  // Third line is altitude
  ReadDouble (&value->alt, stream);
}


//
// ReadTime - Read a date/time value from the stream
//
void  ReadTime (SDateTime *value, SStream *stream)
{

}


//
// ReadTimeDelta - Read a time delta value from the stream
//
void  ReadTimeDelta (SDateTimeDelta *value, SStream *stream)
{

}


//
// ReadMessage - Read a message object from a stream
//
void  ReadMessage (SMessage *msg, SStream *stream)
{
  // Advance to <bgno> tag
  char s[256];
  Tag tag;

  // The following kluge is in place because of a typo in a <mesg> object
  //   in the default panel TRI30.PNL which misspells <bgno> as <bgmo>
  while (((tag = snexttag (s, 256, stream)) != 'bgno') && (tag != 'bgmo')) {}

  // Now continue to read tags until <endo>, populating various fields of the
  //   SMessage struct
  bool keepGoing = true;
  while (keepGoing) {
    tag = snexttag (s, 256, stream);
    switch (tag) {
    case 'grou':
    case 'conn':
      // Group (unique ID) tag
      {
        Tag grou;
        ReadTag (&grou, stream);
        msg->group = grou;
      }
      break;

    case 'user':
    case 'usr1':
      // Various members of the user union
      {
        char s[64];
        ReadString (s, 64, stream);

        char dtag_string[16];
        char group_string[16];
        if (sscanf (s, "DATATAG,'%s'", dtag_string) == 1) {
          msg->user.u.datatag = StringToTag (dtag_string);
        } else if (sscanf (s, "GROUP,'%s'", group_string) == 1) {
          msg->group = StringToTag (group_string);
        }
      }
      break;

    case 'dtag':
      // Datatag member of user data
      {
        Tag dtag;
        ReadTag (&dtag, stream);
        msg->user.u.datatag = dtag;
      }
      break;

    case 'type':
      // Data type and initial value
      {
        char s[64];
        ReadString (s, 64, stream);

      }
      break;

    case 'endo':
      // End of message
      keepGoing = false;
      break;

    default:
      // Unrecognized tag
      char s[64];
      TagToString (s, tag);
      globals->logWarning->Write ("ReadMessage : Unrecognized tag %s", s);
    }
  }
}


//
// ReadTag - Read a four-character datatag value from the stream
//
void  ReadTag (Tag *tag, SStream *stream)
{
  char s[64];
  ReadString (s, 64, stream);

  // Pad string with spaces to four chars in length
  while (strlen(s) < 4) {
    strcat (s, " ");
  }

  *tag = StringToTag (s);
}

Documentation generated by