common/dist/zlib/contrib/iostream3/zfstream.cc

   1 /*
   2  * A C++ I/O streams interface to the zlib gz* functions
   3  *
   4  * by Ludwig Schwardt <schwardt@sun.ac.za>
   5  * original version by Kevin Ruland <kevin@rodin.wustl.edu>
   6  *
   7  * This version is standard-compliant and compatible with gcc 3.x.
   8  */
   9
  10 #include "zfstream.h"
  11 #include <cstring>          // for strcpy, strcat, strlen (mode strings)
  12 #include <cstdio>           // for BUFSIZ
  13
  14 // Internal buffer sizes (default and "unbuffered" versions)
  15 #define BIGBUFSIZE BUFSIZ
  16 #define SMALLBUFSIZE 1
  17
  18 /*****************************************************************************/
  19
  20 // Default constructor
  21 gzfilebuf::gzfilebuf()
  22 : file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),
  23   buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)
  24 {
  25   // No buffers to start with
  26   this->disable_buffer();
  27 }
  28
  29 // Destructor
  30 gzfilebuf::~gzfilebuf()
  31 {
  32   // Sync output buffer and close only if responsible for file
  33   // (i.e. attached streams should be left open at this stage)
  34   this->sync();
  35   if (own_fd)
  36     this->close();
  37   // Make sure internal buffer is deallocated
  38   this->disable_buffer();
  39 }
  40
  41 // Set compression level and strategy
  42 int
  43 gzfilebuf::setcompression(int comp_level,
  44                           int comp_strategy)
  45 {
  46   return gzsetparams(file, comp_level, comp_strategy);
  47 }
  48
  49 // Open gzipped file
  50 gzfilebuf*
  51 gzfilebuf::open(const char *name,
  52                 std::ios_base::openmode mode)
  53 {
  54   // Fail if file already open
  55   if (this->is_open())
  56     return NULL;
  57   // Don't support simultaneous read/write access (yet)
  58   if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
  59     return NULL;
  60
  61   // Build mode string for gzopen and check it [27.8.1.3.2]
  62   char char_mode[6] = "\0\0\0\0\0";
  63   if (!this->open_mode(mode, char_mode))
  64     return NULL;
  65
  66   // Attempt to open file
  67   if ((file = gzopen(name, char_mode)) == NULL)
  68     return NULL;
  69
  70   // On success, allocate internal buffer and set flags
  71   this->enable_buffer();
  72   io_mode = mode;
  73   own_fd = true;
  74   return this;
  75 }
  76
  77 // Attach to gzipped file
  78 gzfilebuf*
  79 gzfilebuf::attach(int fd,
  80                   std::ios_base::openmode mode)
  81 {
  82   // Fail if file already open
  83   if (this->is_open())
  84     return NULL;
  85   // Don't support simultaneous read/write access (yet)
  86   if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
  87     return NULL;
  88
  89   // Build mode string for gzdopen and check it [27.8.1.3.2]
  90   char char_mode[6] = "\0\0\0\0\0";
  91   if (!this->open_mode(mode, char_mode))
  92     return NULL;
  93
  94   // Attempt to attach to file
  95   if ((file = gzdopen(fd, char_mode)) == NULL)
  96     return NULL;
  97
  98   // On success, allocate internal buffer and set flags
  99   this->enable_buffer();
 100   io_mode = mode;
 101   own_fd = false;
 102   return this;
 103 }
 104
 105 // Close gzipped file
 106 gzfilebuf*
 107 gzfilebuf::close()
 108 {
 109   // Fail immediately if no file is open
 110   if (!this->is_open())
 111     return NULL;
 112   // Assume success
 113   gzfilebuf* retval = this;
 114   // Attempt to sync and close gzipped file
 115   if (this->sync() == -1)
 116     retval = NULL;
 117   if (gzclose(file) < 0)
 118     retval = NULL;
 119   // File is now gone anyway (postcondition [27.8.1.3.8])
 120   file = NULL;
 121   own_fd = false;
 122   // Destroy internal buffer if it exists
 123   this->disable_buffer();
 124   return retval;
 125 }
 126
 127 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 128
 129 // Convert int open mode to mode string
 130 bool
 131 gzfilebuf::open_mode(std::ios_base::openmode mode,
 132                      char* c_mode) const
 133 {
 134   bool testb = mode & std::ios_base::binary;
 135   bool testi = mode & std::ios_base::in;
 136   bool testo = mode & std::ios_base::out;
 137   bool testt = mode & std::ios_base::trunc;
 138   bool testa = mode & std::ios_base::app;
 139
 140   // Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
 141   // Original zfstream hardcoded the compression level to maximum here...
 142   // Double the time for less than 1% size improvement seems
 143   // excessive though - keeping it at the default level
 144   // To change back, just append "9" to the next three mode strings
 145   if (!testi && testo && !testt && !testa)
 146     strcpy(c_mode, "w");
 147   if (!testi && testo && !testt && testa)
 148     strcpy(c_mode, "a");
 149   if (!testi && testo && testt && !testa)
 150     strcpy(c_mode, "w");
 151   if (testi && !testo && !testt && !testa)
 152     strcpy(c_mode, "r");
 153   // No read/write mode yet
 154 //  if (testi && testo && !testt && !testa)
 155 //    strcpy(c_mode, "r+");
 156 //  if (testi && testo && testt && !testa)
 157 //    strcpy(c_mode, "w+");
 158
 159   // Mode string should be empty for invalid combination of flags
 160   if (strlen(c_mode) == 0)
 161     return false;
 162   if (testb)
 163     strcat(c_mode, "b");
 164   return true;
 165 }
 166
 167 // Determine number of characters in internal get buffer
 168 std::streamsize
 169 gzfilebuf::showmanyc()
 170 {
 171   // Calls to underflow will fail if file not opened for reading
 172   if (!this->is_open() || !(io_mode & std::ios_base::in))
 173     return -1;
 174   // Make sure get area is in use
 175   if (this->gptr() && (this->gptr() < this->egptr()))
 176     return std::streamsize(this->egptr() - this->gptr());
 177   else
 178     return 0;
 179 }
 180
 181 // Fill get area from gzipped file
 182 gzfilebuf::int_type
 183 gzfilebuf::underflow()
 184 {
 185   // If something is left in the get area by chance, return it
 186   // (this shouldn't normally happen, as underflow is only supposed
 187   // to be called when gptr >= egptr, but it serves as error check)
 188   if (this->gptr() && (this->gptr() < this->egptr()))
 189     return traits_type::to_int_type(*(this->gptr()));
 190
 191   // If the file hasn't been opened for reading, produce error
 192   if (!this->is_open() || !(io_mode & std::ios_base::in))
 193     return traits_type::eof();
 194
 195   // Attempt to fill internal buffer from gzipped file
 196   // (buffer must be guaranteed to exist...)
 197   int bytes_read = gzread(file, buffer, buffer_size);
 198   // Indicates error or EOF
 199   if (bytes_read <= 0)
 200   {
 201     // Reset get area
 202     this->setg(buffer, buffer, buffer);
 203     return traits_type::eof();
 204   }
 205   // Make all bytes read from file available as get area
 206   this->setg(buffer, buffer, buffer + bytes_read);
 207
 208   // Return next character in get area
 209   return traits_type::to_int_type(*(this->gptr()));
 210 }
 211
 212 // Write put area to gzipped file
 213 gzfilebuf::int_type
 214 gzfilebuf::overflow(int_type c)
 215 {
 216   // Determine whether put area is in use
 217   if (this->pbase())
 218   {
 219     // Double-check pointer range
 220     if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
 221       return traits_type::eof();
 222     // Add extra character to buffer if not EOF
 223     if (!traits_type::eq_int_type(c, traits_type::eof()))
 224     {
 225       *(this->pptr()) = traits_type::to_char_type(c);
 226       this->pbump(1);
 227     }
 228     // Number of characters to write to file
 229     int bytes_to_write = this->pptr() - this->pbase();
 230     // Overflow doesn't fail if nothing is to be written
 231     if (bytes_to_write > 0)
 232     {
 233       // If the file hasn't been opened for writing, produce error
 234       if (!this->is_open() || !(io_mode & std::ios_base::out))
 235         return traits_type::eof();
 236       // If gzipped file won't accept all bytes written to it, fail
 237       if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
 238         return traits_type::eof();
 239       // Reset next pointer to point to pbase on success
 240       this->pbump(-bytes_to_write);
 241     }
 242   }
 243   // Write extra character to file if not EOF
 244   else if (!traits_type::eq_int_type(c, traits_type::eof()))
 245   {
 246     // If the file hasn't been opened for writing, produce error
 247     if (!this->is_open() || !(io_mode & std::ios_base::out))
 248       return traits_type::eof();
 249     // Impromptu char buffer (allows "unbuffered" output)
 250     char_type last_char = traits_type::to_char_type(c);
 251     // If gzipped file won't accept this character, fail
 252     if (gzwrite(file, &last_char, 1) != 1)
 253       return traits_type::eof();
 254   }
 255
 256   // If you got here, you have succeeded (even if c was EOF)
 257   // The return value should therefore be non-EOF
 258   if (traits_type::eq_int_type(c, traits_type::eof()))
 259     return traits_type::not_eof(c);
 260   else
 261     return c;
 262 }
 263
 264 // Assign new buffer
 265 std::streambuf*
 266 gzfilebuf::setbuf(char_type* p,
 267                   std::streamsize n)
 268 {
 269   // First make sure stuff is sync'ed, for safety
 270   if (this->sync() == -1)
 271     return NULL;
 272   // If buffering is turned off on purpose via setbuf(0,0), still allocate one...
 273   // "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
 274   // least a buffer of size 1 (very inefficient though, therefore make it bigger?)
 275   // This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
 276   if (!p || !n)
 277   {
 278     // Replace existing buffer (if any) with small internal buffer
 279     this->disable_buffer();
 280     buffer = NULL;
 281     buffer_size = 0;
 282     own_buffer = true;
 283     this->enable_buffer();
 284   }
 285   else
 286   {
 287     // Replace existing buffer (if any) with external buffer
 288     this->disable_buffer();
 289     buffer = p;
 290     buffer_size = n;
 291     own_buffer = false;
 292     this->enable_buffer();
 293   }
 294   return this;
 295 }
 296
 297 // Write put area to gzipped file (i.e. ensures that put area is empty)
 298 int
 299 gzfilebuf::sync()
 300 {
 301   return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;
 302 }
 303
 304 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 305
 306 // Allocate internal buffer
 307 void
 308 gzfilebuf::enable_buffer()
 309 {
 310   // If internal buffer required, allocate one
 311   if (own_buffer && !buffer)
 312   {
 313     // Check for buffered vs. "unbuffered"
 314     if (buffer_size > 0)
 315     {
 316       // Allocate internal buffer
 317       buffer = new char_type[buffer_size];
 318       // Get area starts empty and will be expanded by underflow as need arises
 319       this->setg(buffer, buffer, buffer);
 320       // Setup entire internal buffer as put area.
 321       // The one-past-end pointer actually points to the last element of the buffer,
 322       // so that overflow(c) can safely add the extra character c to the sequence.
 323       // These pointers remain in place for the duration of the buffer
 324       this->setp(buffer, buffer + buffer_size - 1);
 325     }
 326     else
 327     {
 328       // Even in "unbuffered" case, (small?) get buffer is still required
 329       buffer_size = SMALLBUFSIZE;
 330       buffer = new char_type[buffer_size];
 331       this->setg(buffer, buffer, buffer);
 332       // "Unbuffered" means no put buffer
 333       this->setp(0, 0);
 334     }
 335   }
 336   else
 337   {
 338     // If buffer already allocated, reset buffer pointers just to make sure no
 339     // stale chars are lying around
 340     this->setg(buffer, buffer, buffer);
 341     this->setp(buffer, buffer + buffer_size - 1);
 342   }
 343 }
 344
 345 // Destroy internal buffer
 346 void
 347 gzfilebuf::disable_buffer()
 348 {
 349   // If internal buffer exists, deallocate it
 350   if (own_buffer && buffer)
 351   {
 352     // Preserve unbuffered status by zeroing size
 353     if (!this->pbase())
 354       buffer_size = 0;
 355     delete[] buffer;
 356     buffer = NULL;
 357     this->setg(0, 0, 0);
 358     this->setp(0, 0);
 359   }
 360   else
 361   {
 362     // Reset buffer pointers to initial state if external buffer exists
 363     this->setg(buffer, buffer, buffer);
 364     if (buffer)
 365       this->setp(buffer, buffer + buffer_size - 1);
 366     else
 367       this->setp(0, 0);
 368   }
 369 }
 370
 371 /*****************************************************************************/
 372
 373 // Default constructor initializes stream buffer
 374 gzifstream::gzifstream()
 375 : std::istream(NULL), sb()
 376 { this->init(&sb); }
 377
 378 // Initialize stream buffer and open file
 379 gzifstream::gzifstream(const char* name,
 380                        std::ios_base::openmode mode)
 381 : std::istream(NULL), sb()
 382 {
 383   this->init(&sb);
 384   this->open(name, mode);
 385 }
 386
 387 // Initialize stream buffer and attach to file
 388 gzifstream::gzifstream(int fd,
 389                        std::ios_base::openmode mode)
 390 : std::istream(NULL), sb()
 391 {
 392   this->init(&sb);
 393   this->attach(fd, mode);
 394 }
 395
 396 // Open file and go into fail() state if unsuccessful
 397 void
 398 gzifstream::open(const char* name,
 399                  std::ios_base::openmode mode)
 400 {
 401   if (!sb.open(name, mode | std::ios_base::in))
 402     this->setstate(std::ios_base::failbit);
 403   else
 404     this->clear();
 405 }
 406
 407 // Attach to file and go into fail() state if unsuccessful
 408 void
 409 gzifstream::attach(int fd,
 410                    std::ios_base::openmode mode)
 411 {
 412   if (!sb.attach(fd, mode | std::ios_base::in))
 413     this->setstate(std::ios_base::failbit);
 414   else
 415     this->clear();
 416 }
 417
 418 // Close file
 419 void
 420 gzifstream::close()
 421 {
 422   if (!sb.close())
 423     this->setstate(std::ios_base::failbit);
 424 }
 425
 426 /*****************************************************************************/
 427
 428 // Default constructor initializes stream buffer
 429 gzofstream::gzofstream()
 430 : std::ostream(NULL), sb()
 431 { this->init(&sb); }
 432
 433 // Initialize stream buffer and open file
 434 gzofstream::gzofstream(const char* name,
 435                        std::ios_base::openmode mode)
 436 : std::ostream(NULL), sb()
 437 {
 438   this->init(&sb);
 439   this->open(name, mode);
 440 }
 441
 442 // Initialize stream buffer and attach to file
 443 gzofstream::gzofstream(int fd,
 444                        std::ios_base::openmode mode)
 445 : std::ostream(NULL), sb()
 446 {
 447   this->init(&sb);
 448   this->attach(fd, mode);
 449 }
 450
 451 // Open file and go into fail() state if unsuccessful
 452 void
 453 gzofstream::open(const char* name,
 454                  std::ios_base::openmode mode)
 455 {
 456   if (!sb.open(name, mode | std::ios_base::out))
 457     this->setstate(std::ios_base::failbit);
 458   else
 459     this->clear();
 460 }
 461
 462 // Attach to file and go into fail() state if unsuccessful
 463 void
 464 gzofstream::attach(int fd,
 465                    std::ios_base::openmode mode)
 466 {
 467   if (!sb.attach(fd, mode | std::ios_base::out))
 468     this->setstate(std::ios_base::failbit);
 469   else
 470     this->clear();
 471 }
 472
 473 // Close file
 474 void
 475 gzofstream::close()
 476 {
 477   if (!sb.close())
 478     this->setstate(std::ios_base::failbit);
 479 }