text: /*
   * A C++ I/O streams interface to the zlib gz* functions
   *
   * by Ludwig Schwardt <schwardt@sun.ac.za>
   * original version by Kevin Ruland <kevin@rodin.wustl.edu>
   *
   * This version is standard-compliant and compatible with gcc 3.x.
   */
  
  #include "gzstream.hpp"
  #include <cstring>          // for strcpy, strcat, strlen (mode strings)
  #include <cstdio>           // for BUFSIZ
  
  // Internal buffer sizes (default and "unbuffered" versions)
  #define BIGBUFSIZE BUFSIZ
  #define SMALLBUFSIZE 1
  
  using namespace gwsc;
  
  /*****************************************************************************/
  
  // Default constructor
  gzfilebuf::gzfilebuf()
  : file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),
    buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)
  {
    // No buffers to start with
    this->disable_buffer();
  }
  
  // Destructor
  gzfilebuf::~gzfilebuf()
  {
    // Sync output buffer and close only if responsible for file
    // (i.e. attached streams should be left open at this stage)
    this->sync();
    if (own_fd)
      this->close();
    // Make sure internal buffer is deallocated
    this->disable_buffer();
  }
  
  // Set compression level and strategy
  int
  gzfilebuf::setcompression(int comp_level,
                            int comp_strategy)
  {
    return gzsetparams(file, comp_level, comp_strategy);
  }
  
  // Open gzipped file
  gzfilebuf*
  gzfilebuf::open(const char *name,
                  std::ios_base::openmode mode)
  {
    // Fail if file already open
    if (this->is_open())
      return NULL;
    // Don't support simultaneous read/write access (yet)
    if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
      return NULL;
  
    // Build mode string for gzopen and check it [27.8.1.3.2]
    char char_mode[6] = "\0\0\0\0\0";
    if (!this->open_mode(mode, char_mode))
      return NULL;
  
    // Attempt to open file
    if ((file = gzopen(name, char_mode)) == NULL)
      return NULL;
  
    // On success, allocate internal buffer and set flags
    this->enable_buffer();
    io_mode = mode;
    own_fd = true;
    return this;
  }
  
  // Attach to gzipped file
  gzfilebuf*
  gzfilebuf::attach(int fd,
                    std::ios_base::openmode mode)
  {
    // Fail if file already open
    if (this->is_open())
      return NULL;
    // Don't support simultaneous read/write access (yet)
    if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
      return NULL;
  
    // Build mode string for gzdopen and check it [27.8.1.3.2]
    char char_mode[6] = "\0\0\0\0\0";
    if (!this->open_mode(mode, char_mode))
      return NULL;
  
    // Attempt to attach to file
    if ((file = gzdopen(fd, char_mode)) == NULL)
      return NULL;
  
    // On success, allocate internal buffer and set flags
    this->enable_buffer();
    io_mode = mode;
    own_fd = false;
    return this;
  }
  
  // Close gzipped file
  gzfilebuf*
  gzfilebuf::close()
  {
    // Fail immediately if no file is open
    if (!this->is_open())
      return NULL;
    // Assume success
    gzfilebuf* retval = this;
    // Attempt to sync and close gzipped file
    if (this->sync() == -1)
      retval = NULL;
    if (gzclose(file) < 0)
      retval = NULL;
    // File is now gone anyway (postcondition [27.8.1.3.8])
    file = NULL;
    own_fd = false;
    // Destroy internal buffer if it exists
    this->disable_buffer();
    return retval;
  }
  
  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
  // Convert int open mode to mode string
  bool
  gzfilebuf::open_mode(std::ios_base::openmode mode,
                       char* c_mode) const
  {
    bool testb = mode & std::ios_base::binary;
    bool testi = mode & std::ios_base::in;
    bool testo = mode & std::ios_base::out;
    bool testt = mode & std::ios_base::trunc;
    bool testa = mode & std::ios_base::app;
  
    // Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
    // Original zfstream hardcoded the compression level to maximum here...
    // Double the time for less than 1% size improvement seems
    // excessive though - keeping it at the default level
    // To change back, just append "9" to the next three mode strings
    if (!testi && testo && !testt && !testa)
      strcpy(c_mode, "w");
    if (!testi && testo && !testt && testa)
      strcpy(c_mode, "a");
    if (!testi && testo && testt && !testa)
      strcpy(c_mode, "w");
    if (testi && !testo && !testt && !testa)
      strcpy(c_mode, "r");
    // No read/write mode yet
  //  if (testi && testo && !testt && !testa)
  //    strcpy(c_mode, "r+");
  //  if (testi && testo && testt && !testa)
  //    strcpy(c_mode, "w+");
  
    // Mode string should be empty for invalid combination of flags
    if (strlen(c_mode) == 0)
      return false;
    if (testb)
      strcat(c_mode, "b");
    return true;
  }
  
  // Determine number of characters in internal get buffer
  std::streamsize
  gzfilebuf::showmanyc()
  {
    // Calls to underflow will fail if file not opened for reading
    if (!this->is_open() || !(io_mode & std::ios_base::in))
      return -1;
    // Make sure get area is in use
    if (this->gptr() && (this->gptr() < this->egptr()))
      return std::streamsize(this->egptr() - this->gptr());
    else
      return 0;
  }
  
  // Fill get area from gzipped file
  gzfilebuf::int_type
  gzfilebuf::underflow()
  {
    // If something is left in the get area by chance, return it
    // (this shouldn't normally happen, as underflow is only supposed
    // to be called when gptr >= egptr, but it serves as error check)
    if (this->gptr() && (this->gptr() < this->egptr()))
      return traits_type::to_int_type(*(this->gptr()));
  
    // If the file hasn't been opened for reading, produce error
    if (!this->is_open() || !(io_mode & std::ios_base::in))
      return traits_type::eof();
  
    // Attempt to fill internal buffer from gzipped file
    // (buffer must be guaranteed to exist...)
    int bytes_read = gzread(file, buffer, buffer_size);
    // Indicates error or EOF
    if (bytes_read <= 0)
    {
      // Reset get area
      this->setg(buffer, buffer, buffer);
      return traits_type::eof();
    }
    // Make all bytes read from file available as get area
    this->setg(buffer, buffer, buffer + bytes_read);
  
    // Return next character in get area
    return traits_type::to_int_type(*(this->gptr()));
  }
  
  // Write put area to gzipped file
  gzfilebuf::int_type
  gzfilebuf::overflow(int_type c)
  {
    // Determine whether put area is in use
    if (this->pbase())
    {
      // Double-check pointer range
      if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
        return traits_type::eof();
      // Add extra character to buffer if not EOF
      if (!traits_type::eq_int_type(c, traits_type::eof()))
      {
        *(this->pptr()) = traits_type::to_char_type(c);
        this->pbump(1);
      }
      // Number of characters to write to file
      int bytes_to_write = this->pptr() - this->pbase();
      // Overflow doesn't fail if nothing is to be written
      if (bytes_to_write > 0)
      {
        // If the file hasn't been opened for writing, produce error
        if (!this->is_open() || !(io_mode & std::ios_base::out))
          return traits_type::eof();
        // If gzipped file won't accept all bytes written to it, fail
        if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
          return traits_type::eof();
        // Reset next pointer to point to pbase on success
        this->pbump(-bytes_to_write);
      }
    }
    // Write extra character to file if not EOF
    else if (!traits_type::eq_int_type(c, traits_type::eof()))
    {
      // If the file hasn't been opened for writing, produce error
      if (!this->is_open() || !(io_mode & std::ios_base::out))
        return traits_type::eof();
      // Impromptu char buffer (allows "unbuffered" output)
      char_type last_char = traits_type::to_char_type(c);
      // If gzipped file won't accept this character, fail
      if (gzwrite(file, &last_char, 1) != 1)
        return traits_type::eof();
    }
  
    // If you got here, you have succeeded (even if c was EOF)
    // The return value should therefore be non-EOF
    if (traits_type::eq_int_type(c, traits_type::eof()))
      return traits_type::not_eof(c);
    else
      return c;
  }
  
  // Assign new buffer
  std::streambuf*
  gzfilebuf::setbuf(char_type* p,
                    std::streamsize n)
  {
    // First make sure stuff is sync'ed, for safety
    if (this->sync() == -1)
      return NULL;
    // If buffering is turned off on purpose via setbuf(0,0), still allocate one...
    // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
    // least a buffer of size 1 (very inefficient though, therefore make it bigger?)
    // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
    if (!p || !n)
    {
      // Replace existing buffer (if any) with small internal buffer
      this->disable_buffer();
      buffer = NULL;
      buffer_size = 0;
      own_buffer = true;
      this->enable_buffer();
    }
    else
    {
      // Replace existing buffer (if any) with external buffer
      this->disable_buffer();
      buffer = p;
      buffer_size = n;
      own_buffer = false;
      this->enable_buffer();
    }
    return this;
  }
  
  // Write put area to gzipped file (i.e. ensures that put area is empty)
  int
  gzfilebuf::sync()
  {
    return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;
  }
  
  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
  // Allocate internal buffer
  void
  gzfilebuf::enable_buffer()
  {
    // If internal buffer required, allocate one
    if (own_buffer && !buffer)
    {
      // Check for buffered vs. "unbuffered"
      if (buffer_size > 0)
      {
        // Allocate internal buffer
        buffer = new char_type[buffer_size];
        // Get area starts empty and will be expanded by underflow as need arises
        this->setg(buffer, buffer, buffer);
        // Setup entire internal buffer as put area.
        // The one-past-end pointer actually points to the last element of the buffer,
        // so that overflow(c) can safely add the extra character c to the sequence.
        // These pointers remain in place for the duration of the buffer
        this->setp(buffer, buffer + buffer_size - 1);
      }
      else
      {
        // Even in "unbuffered" case, (small?) get buffer is still required
        buffer_size = SMALLBUFSIZE;
        buffer = new char_type[buffer_size];
        this->setg(buffer, buffer, buffer);
        // "Unbuffered" means no put buffer
        this->setp(0, 0);
      }
    }
    else
    {
      // If buffer already allocated, reset buffer pointers just to make sure no
      // stale chars are lying around
      this->setg(buffer, buffer, buffer);
      this->setp(buffer, buffer + buffer_size - 1);
    }
  }
  
  // Destroy internal buffer
  void
  gzfilebuf::disable_buffer()
  {
    // If internal buffer exists, deallocate it
    if (own_buffer && buffer)
    {
      // Preserve unbuffered status by zeroing size
      if (!this->pbase())
        buffer_size = 0;
      delete[] buffer;
      buffer = NULL;
      this->setg(0, 0, 0);
      this->setp(0, 0);
    }
    else
    {
      // Reset buffer pointers to initial state if external buffer exists
      this->setg(buffer, buffer, buffer);
      if (buffer)
        this->setp(buffer, buffer + buffer_size - 1);
      else
        this->setp(0, 0);
    }
  }
  
  /*****************************************************************************/
  
  // Default constructor initializes stream buffer
  gzifstream::gzifstream()
  : std::istream(NULL), sb()
  { this->init(&sb); }
  
  // Initialize stream buffer and open file
  gzifstream::gzifstream(const char* name,
                         std::ios_base::openmode mode)
  : std::istream(NULL), sb()
  {
    this->init(&sb);
    this->open(name, mode);
  }
  
  // Initialize stream buffer and attach to file
  gzifstream::gzifstream(int fd,
                         std::ios_base::openmode mode)
  : std::istream(NULL), sb()
  {
    this->init(&sb);
    this->attach(fd, mode);
  }
  
  // Open file and go into fail() state if unsuccessful
  void
  gzifstream::open(const char* name,
                   std::ios_base::openmode mode)
  {
    if (!sb.open(name, mode | std::ios_base::in))
      this->setstate(std::ios_base::failbit);
    else
      this->clear();
  }
  
  // Attach to file and go into fail() state if unsuccessful
  void
  gzifstream::attach(int fd,
                     std::ios_base::openmode mode)
  {
    if (!sb.attach(fd, mode | std::ios_base::in))
      this->setstate(std::ios_base::failbit);
    else
      this->clear();
  }
  
  // Close file
  void
  gzifstream::close()
  {
    if (!sb.close())
      this->setstate(std::ios_base::failbit);
  }
  
  /*****************************************************************************/
  
  // Default constructor initializes stream buffer
  gzofstream::gzofstream()
  : std::ostream(NULL), sb()
  { this->init(&sb); }
  
  // Initialize stream buffer and open file
  gzofstream::gzofstream(const char* name,
                         std::ios_base::openmode mode)
  : std::ostream(NULL), sb()
  {
    this->init(&sb);
    this->open(name, mode);
  }
  
  gzofstream::gzofstream(const std::string & name,
                         std::ios_base::openmode mode)
  : std::ostream(NULL), sb()
  {
    this->init(&sb);
    this->open(name.c_str(), mode);
  }
  
  // Initialize stream buffer and attach to file
  gzofstream::gzofstream(int fd,
                         std::ios_base::openmode mode)
  : std::ostream(NULL), sb()
  {
    this->init(&sb);
    this->attach(fd, mode);
  }
  
  // Open file and go into fail() state if unsuccessful
  void
  gzofstream::open(const char* name,
                   std::ios_base::openmode mode)
  {
    if (!sb.open(name, mode | std::ios_base::out))
      this->setstate(std::ios_base::failbit);
    else
      this->clear();
  }
  
  // Attach to file and go into fail() state if unsuccessful
  void
  gzofstream::attach(int fd,
                     std::ios_base::openmode mode)
  {
    if (!sb.attach(fd, mode | std::ios_base::out))
      this->setstate(std::ios_base::failbit);
    else
      this->clear();
  }
  
  // Close file
  void
  gzofstream::close()
  {
    if (!sb.close())
      this->setstate(std::ios_base::failbit);
  }
  