mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-07 13:54:33 +00:00
480 lines
13 KiB
C++
480 lines
13 KiB
C++
/*
|
|
* 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);
|
|
}
|