third_party/zlib/contrib/iostream3/zfstream.cc - bazel - Git at Google

 /*
  * 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 "zfstream.h"
 #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

 /*****************************************************************************/

 // 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);
 }

 // 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);
 }
	/*
	* 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 "zfstream.h"
	#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

	/*****************************************************************************/

	// 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);
	}

	// 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);
	}