00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #include <gzstream.h>
00030 #include <iostream>
00031 #include <string.h>
00032
00033 #ifdef GZSTREAM_NAMESPACE
00034 namespace GZSTREAM_NAMESPACE {
00035 #endif
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045 gzstreambuf* gzstreambuf::open( const char* name, int open_mode) {
00046 if ( is_open())
00047 return (gzstreambuf*)0;
00048 mode = open_mode;
00049
00050 if ((mode & std::ios::ate) || (mode & std::ios::app)
00051 || ((mode & std::ios::in) && (mode & std::ios::out)))
00052 return (gzstreambuf*)0;
00053 char fmode[10];
00054 char* fmodeptr = fmode;
00055 if ( mode & std::ios::in)
00056 *fmodeptr++ = 'r';
00057 else if ( mode & std::ios::out)
00058 *fmodeptr++ = 'w';
00059 *fmodeptr++ = 'b';
00060 *fmodeptr = '\0';
00061 file = gzopen( name, fmode);
00062 if (file == 0)
00063 return (gzstreambuf*)0;
00064 opened = 1;
00065 return this;
00066 }
00067
00068 gzstreambuf * gzstreambuf::close() {
00069 if ( is_open()) {
00070 sync();
00071 opened = 0;
00072 if ( gzclose( file) == Z_OK)
00073 return this;
00074 }
00075 return (gzstreambuf*)0;
00076 }
00077
00078 int gzstreambuf::underflow() {
00079 if ( gptr() && ( gptr() < egptr()))
00080 return * reinterpret_cast<unsigned char *>( gptr());
00081
00082 if ( ! (mode & std::ios::in) || ! opened)
00083 return EOF;
00084
00085 int n_putback = gptr() - eback();
00086 if ( n_putback > 4)
00087 n_putback = 4;
00088 memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
00089
00090 int num = gzread( file, buffer+4, bufferSize-4);
00091 if (num <= 0)
00092 return EOF;
00093
00094
00095 setg( buffer + (4 - n_putback),
00096 buffer + 4,
00097 buffer + 4 + num);
00098
00099
00100 return * reinterpret_cast<unsigned char *>( gptr());
00101 }
00102
00103 int gzstreambuf::flush_buffer() {
00104
00105
00106 int w = pptr() - pbase();
00107 if ( gzwrite( file, pbase(), w) != w)
00108 return EOF;
00109 pbump( -w);
00110 return w;
00111 }
00112
00113 int gzstreambuf::overflow( int c) {
00114 if ( ! ( mode & std::ios::out) || ! opened)
00115 return EOF;
00116 if (c != EOF) {
00117 *pptr() = c;
00118 pbump(1);
00119 }
00120 if ( flush_buffer() == EOF)
00121 return EOF;
00122 return c;
00123 }
00124
00125 int gzstreambuf::sync() {
00126
00127
00128
00129 if ( pptr() && pptr() > pbase()) {
00130 if ( flush_buffer() == EOF)
00131 return -1;
00132 }
00133 return 0;
00134 }
00135
00136
00137
00138
00139
00140 gzstreambase::gzstreambase( const char* name, int mode) {
00141 init( &buf);
00142 open( name, mode);
00143 }
00144
00145 gzstreambase::~gzstreambase() {
00146 buf.close();
00147 }
00148
00149 void gzstreambase::open( const char* name, int open_mode) {
00150 if ( ! buf.open( name, open_mode))
00151 clear( rdstate() | std::ios::badbit);
00152 }
00153
00154 void gzstreambase::close() {
00155 if ( buf.is_open())
00156 if ( ! buf.close())
00157 clear( rdstate() | std::ios::badbit);
00158 }
00159
00160 #ifdef GZSTREAM_NAMESPACE
00161 }
00162 #endif
00163
00164
00165