GZipFile Class Reference

A file stream compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format. More...

#include <zstream.h>

List of all members.

Public Member Functions
	GZipFile ()
	GZipFile constructor.
	~GZipFile ()
	GZipFile destructor.
GZipStream *	gz_init (iostream *pFileStream, TCHAR *mode, BOOL Header=FALSE)
	Initialises the compression system and tries to grab the memory required. gz_init returns NULL if there was insufficient memory to allocate the (de)compression state; errno can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). Graeme ( 15/11/99) : Added the Header parameter to the parameter list. This enables the GZipStream to be initialised so that it writes the ZLib header, which was previously supressed.
GZipStream *	gz_open (iostream *pFileStream, TCHAR *mode, TCHAR *path)
	Opens a gzip file for reading or writing. The mode parameter is as in fopen ("rb" or "wb"). The stream is given at present by the iostream class, the patname is optional and is just used for debugging.
INT32	gz_open (GZipStream *s)
	The form of open if we have already called init. At present, this is fairly simple and just checks out a few things.
INT32	gzpeek (GZipStream *s, char *data)
	Reads the next byte from the input stream and returns this to the caller. It then remembers this value for the next read. gzread returns the number of uncompressed bytes actually read (0 for end of file, -1 for error).
INT32	gzread (GZipStream *s, char *data, unsigned len)
	Reads the given number of uncompressed bytes from the compressed file. If the input file was not in gzip format, gzread copies the given number of bytes into the buffer. gzread returns the number of uncompressed bytes actually read (0 for end of file, -1 for error).
INT32	gzwrite (GZipStream *s, const char *data, unsigned len)
	Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of bytes actually written (0 in case of error).
INT32	gzflush (GZipStream *s, INT32 flush)
	Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number (see function gzerror below). gzflush returns Z_OK if the flush parameter is Z_FINISH and all output could be flushed. gzflush should be called only when strictly necessary because it can degrade compression.
INT32	gzclose (GZipStream *s)
	Flushes all pending output if necessary, closes the compressed file and deallocates all the (de)compression state. The return value is the zlib error number (see function gzerror below).
INT32	destroy (GZipStream *file)
	Cleanup then free the given GZipStream. Return a zlib error code. Assume caller will close the file.
FilePos	GetCurrentFilePos (GZipStream *s)
	Allows the progress bar to be updated with the current position in the compressed file.
Static Public Member Functions
static double	GetStreamVersionNo ()
	To find out the current version number of the stream and hence files which it can recoknise. The verison is of the form 0.92.
static uLong	crc32 (uLong crc, Bytef *buf, uInt len)
	Update a running crc with the bytes buf[0..len-1] and return the updated crc. If buf is NULL, this function returns the required initial value for the crc. Pre- and post-conditioning (one's complement) is performed within this function so it shouldn't be done by the application. Usage example:.
static uLong	adler32 (uLong adler, const Bytef *buf, uInt len)
	Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is NULL, this function returns the required initial value for the checksum. An Adler-32 checksum is almost as reliable as a CRC32 but can be computed much faster. Usage example:.
static uLongf *	get_crc_table ()
static void *	zcalloc (void *opaque, unsigned items, unsigned size)
	Allocate memory of size items and with size bytes per item.
static void	zcfree (void *opaque, void *ptr)
	A wrapper round the free function.
Protected Member Functions
void	putLong (iostream *file, uLong x)
	Outputs an INT32 in LSB order to the given file.
uLong	getLong (Byte *buf)
	Reads an INT32 in LSB order from the given buffer.
Protected Attributes
ZipDeflate *	deflate
ZipInflate *	inflate
Private Member Functions
	CC_DECLARE_MEMDUMP (GZipFile)

---

Detailed Description

A file stream compressor and decompressor. Allows the CCDiskFile to offer compression of files. At present just used to compress the native file format.

Author:

Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Humprhys

Date:

23/5/95

Definition at line 240 of file zstream.h.

---

Constructor & Destructor Documentation

GZipFile::GZipFile (   )

GZipFile constructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 34/05/95 Definition at line 289 of file zstream.cpp. { deflate = NULL; inflate = NULL; }

GZipFile::~GZipFile (   )

GZipFile destructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 34/05/95 Definition at line 305 of file zstream.cpp. { #ifdef DO_EXPORT // Remove the deflate class, if present if (deflate != NULL) { delete deflate; deflate = NULL; } #endif // Remove the inflate class, if present if (inflate != NULL) { delete inflate; inflate = NULL; } }

---

Member Function Documentation

uLong GZipFile::adler32 (  uLong  adler, const Bytef *  buf, uInt  len )  [static]

Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is NULL, this function returns the required initial value for the checksum. An Adler-32 checksum is almost as reliable as a CRC32 but can be computed much faster. Usage example:. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: crc  previous checksum value??? [INPUTS] buf pointer to the buffer to check len length of the buffer Returns: the checksum value uLong adler = adler32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { adler = adler32(adler, buffer, length); } if (adler != original_adler) error(); Definition at line 1624 of file zstream.cpp. { UINT32 s1 = adler & 0xffff; UINT32 s2 = (adler >> 16) & 0xffff; INT32 k; if (buf == Z_NULL) return 1L; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { A_DO16(buf); buf += 16; k -= 16; } if (k != 0) do { s1 += *buf++; s2 += s1; } while (--k); s1 %= BASE; s2 %= BASE; } return (s2 << 16) | s1;}

GZipFile::CC_DECLARE_MEMDUMP (  GZipFile   )  [private]

uLong GZipFile::crc32 (  uLong  crc, Bytef *  buf, uInt  len )  [static]

Update a running crc with the bytes buf[0..len-1] and return the updated crc. If buf is NULL, this function returns the required initial value for the crc. Pre- and post-conditioning (one's complement) is performed within this function so it shouldn't be done by the application. Usage example:. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: crc  previous checksum value??? [INPUTS] buf pointer to the buffer to check len length of the buffer Returns: the checksum value uLong crc = crc32(0L, Z_NULL, 0); while (read_buffer(buffer, length) != EOF) { crc = crc32(crc, buffer, length); } if (crc != original_crc) error(); Definition at line 1550 of file zstream.cpp. { if (buf == Z_NULL) return 0L; #ifdef DYNAMIC_CRC_TABLE if (crc_table_empty) make_crc_table(); #endif crc = crc ^ 0xffffffffL; while (len >= 8) { DO8(buf); len -= 8; } if (len) do { DO1(buf); } while (--len); return crc ^ 0xffffffffL; }

INT32 GZipFile::destroy (  GZipStream *  s  )

Cleanup then free the given GZipStream. Return a zlib error code. Assume caller will close the file. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Definition at line 352 of file zstream.cpp. { TRACEUSER( "Neville", _T("GZipFile::gzflush\n")); // Check that a valid stream has been passed in if (!s) return Z_STREAM_ERROR; INT32 err = Z_OK; // Try and free up the buffers that we have allocated TRYFREE(s->inbuf); TRYFREE(s->outbuf); TRYFREE(s->path); TRYFREE(s->msg); if (s->mode == 'w') { #ifdef DO_EXPORT if (s->stream.De_state != NULL && deflate != NULL) err = deflate->End(&(s->stream)); // Now remove the deflate class, if present if (deflate != NULL) { delete deflate; deflate = NULL; } #endif } else if (s->mode == 'r') { if (s->stream.In_state != NULL && inflate != NULL) err = inflate->End(&(s->stream)); // Now remove the inflate class, if present if (inflate != NULL) { delete inflate; inflate = NULL; } } // If we had a file claimed then try and close it // Assume this is done by the caller as in the native file save we still have some // bits to write out to the file. // Assume pointer is of no use anymore so set to NULL. s->file = NULL; if (s->z_err < 0) err = s->z_err; // free up our ZipStream object delete s; s = NULL; return err; }

uLongf * GZipFile::get_crc_table (   )  [static]

Definition at line 1572 of file zstream.cpp. { #ifdef DYNAMIC_CRC_TABLE if (crc_table_empty) make_crc_table(); #endif return (uLongf *)crc_table; }

FilePos GZipFile::GetCurrentFilePos (  GZipStream *  s  )

Allows the progress bar to be updated with the current position in the compressed file. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/05/95 Parameters: s  the zip stream that we should be using [INPUTS] Returns: the current file position Definition at line 1056 of file zstream.cpp. { if (s == NULL || s->file == NULL) return 0; // Get the current file position, this will be ready to read in the next chunk of data // into the input buffer. // Take off the position that we started at FilePos Pos = FilePos(s->file->tellg()) - s->InitialPos; // Take off the current amount left in the input buffer. This is our current position. Pos -= (FilePos)s->stream.avail_in; return Pos; }

uLong GZipFile::getLong (  Byte *  buf  )  [protected]

Reads an INT32 in LSB order from the given buffer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Definition at line 1228 of file zstream.cpp. { uLong x = 0; Byte *p = buf+4; do { x <<= 8; x |= *--p; } while (p != buf); return x; }

double GZipFile::GetStreamVersionNo (   )  [static]

To find out the current version number of the stream and hence files which it can recoknise. The verison is of the form 0.92. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/05/95 Returns: the current version number of the stream in the form 0.92 Definition at line 336 of file zstream.cpp. { return ZLIB_VERSIONNO; }

GZipStream * GZipFile::gz_init (  iostream *  pFileStream, TCHAR *  mode, BOOL  Header = FALSE )

Initialises the compression system and tries to grab the memory required. gz_init returns NULL if there was insufficient memory to allocate the (de)compression state; errno can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). Graeme ( 15/11/99) : Added the Header parameter to the parameter list. This enables the GZipStream to be initialised so that it writes the ZLib header, which was previously supressed. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/06/95 Parameters: pFileStream  the iostream class to use for reading/writing [INPUTS] mode rw mode for this file Definition at line 432 of file zstream.cpp. { TRACEUSER( "Neville", _T("GZipFile::gz_init\n")); if (pFileStream == NULL) { ERROR3("GZipFile::gz_open Expects file class to be supplied and open as of yet!"); return NULL; } GZipStream *s = new GZipStream; if (!s) return NULL; s->stream.zalloc = (alloc_func)0; s->stream.zfree = (free_func)0; s->stream.next_in = NULL; s->inbuf = NULL; s->stream.next_out = NULL; s->outbuf = NULL; s->stream.avail_in = 0; s->stream.avail_out = 0; s->file = pFileStream; // will be NULL if wanting it to be opened s->z_err = Z_OK; s->z_eof = 0; s->crc = crc32(0L, NULL, 0); s->msg = NULL; s->transparent = 0; s->Peek = FALSE; // no value peeked s->PeekedValue = '#'; // random value s->PeekStatus = 0; // status 0 bytes present // Work our whether we are reading or writing from the supplied mode TCHAR *p = mode; s->mode = '\0'; do { if( *p == _T('r') ) s->mode = _T('r'); if( *p == _T('w') ) s->mode = _T('w'); } while (*p++); if( s->mode == _T('\0') ) { destroy(s); return NULL; } INT32 err; if( s->mode == _T('w') ) { #ifdef DO_EXPORT // First, create the deflate class ready for use deflate = new ZipDeflate; if (deflate == NULL) { destroy(s); return NULL; } // Now initialise it, ready for use. // Graeme ( 15/11/99 ) - Added the switch on Header to allow for the // zlib header. if ( Header ) { // Initialise using MAX_WBITS, so that the ZLib header is created. err = deflate->Init(&(s->stream), Z_DEFAULT_COMPRESSION, DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, 0); } else { // windowBits is passed < 0 to suppress zlib header. err = deflate->Init(&(s->stream), Z_DEFAULT_COMPRESSION, DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0); } s->stream.next_out = (Byte*) ALLOC(Z_BUFSIZE); s->outbuf = s->stream.next_out; s->stream.avail_out = Z_BUFSIZE; if (err != Z_OK || s->outbuf == NULL) { destroy(s); return NULL; } /* err = deflate->SetDictionary(&(s->stream), dictionary, dictionary_size); if (err != Z_OK) { destroy(s); return NULL; } */ #else return NULL; #endif } else { // First, create the inflate class ready for use inflate = new ZipInflate; if (inflate == NULL) { destroy(s); return NULL; } err = inflate->Init(&(s->stream), -MAX_WBITS); s->inbuf = (Byte*) ALLOC(Z_BUFSIZE); s->stream.next_in = s->inbuf; if (err != Z_OK || s->inbuf == NULL) { destroy(s); return NULL; } /* err = inflate->SetDictionary(&(s->stream), dictionary, dictionary_size); if (err != Z_OK) { destroy(s); return NULL; } */ } s->Inited = TRUE; return s; }

INT32 GZipFile::gz_open (  GZipStream *  s  )

The form of open if we have already called init. At present, this is fairly simple and just checks out a few things. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 1/06/95 Parameters: s  the zip stream that we should be using [INPUTS] Definition at line 574 of file zstream.cpp. { TRACEUSER( "Neville", _T("GZipFile::gz_open init already called\n")); // check that everyhting is valid before preceeding if (s == NULL) return Z_STREAM_ERROR; // Check if init has been called if (!s->Inited) return Z_STREAM_ERROR; // Note the current position in the file for later use s->InitialPos = s->file->tellg(); // check if there is an actual file stream class attached if (s->file == NULL) { destroy(s); return 0; } // Check if reading and already at end of file if (s->mode == 'r' && s->file->eof()) { s->z_err = Z_DATA_ERROR; return Z_DATA_ERROR; } // Check if reading and the next bytes are not compressed if (s->mode == 'r') { s->stream.avail_in = 15; s->file->read( (char *)s->inbuf, s->stream.avail_in ); // Seek back to where we were before we started this test s->file->seekp(s->InitialPos); if (s->stream.avail_in == 15) { // If we find the following words then the data is not compressed // We must fail but cleanly as all we need to do is read it uncomrpessed if( strncmp( (PCSTR)s->inbuf, "%%AWColourTable", 15 ) == 0 ) { s->stream.avail_in = 0; s->z_err = Z_UNCOMPRESSED_ERROR; return Z_UNCOMPRESSED_ERROR; } s->stream.avail_in = 0; } else { s->z_err = Z_DATA_ERROR; return Z_DATA_ERROR; } } // Everything went ok return Z_OK; }

GZipStream * GZipFile::gz_open (  iostream *  pFileStream, TCHAR *  mode, TCHAR *  path )

Opens a gzip file for reading or writing. The mode parameter is as in fopen ("rb" or "wb"). The stream is given at present by the iostream class, the patname is optional and is just used for debugging. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: pFileStream  the iostream class to use for reading/writing [INPUTS] mode rw mode for this file path pathname for this file (optional) gz_open return NULL if the stream could not be opened or if there was insufficient memory to allocate the (de)compression state; errno can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). Definition at line 654 of file zstream.cpp. { TRACEUSER( "Neville", _T("GZipFile::gz_open\n")); if (pFileStream == NULL) { ERROR3("GZipFile::gz_open Expects file class to be supplied and open as of yet!"); return NULL; } INT32 err; TCHAR *p = mode; GZipStream *s = new GZipStream; if (!s) return NULL; s->stream.zalloc = (alloc_func) 0; s->stream.zfree = (free_func) 0; s->stream.next_in = NULL; s->inbuf = NULL; s->stream.next_out = NULL; s->outbuf = NULL; s->stream.avail_in = 0; s->stream.avail_out = 0; s->file = pFileStream; // will be NULL if wanting it to be opened s->z_err = Z_OK; s->z_eof = 0; s->crc = crc32(0L, NULL, 0); s->msg = NULL; s->transparent = 0; // Our extra bits s->Peek = FALSE; // no value peeked s->PeekedValue = '#'; // random value s->PeekStatus = 0; // status 0 bytes present s->path = NULL; if (path != NULL) { s->path = (TCHAR*) ALLOC((camStrlen(path) + 1) * sizeof(TCHAR)); if (s->path == NULL) { destroy(s); return NULL; } camStrcpy(s->path, path); /* do this early for debugging */ } // Note the current position in the file for later use s->InitialPos = s->file->tellg(); // Work our whether we are reading or writing from the supplied mode s->mode = '\0'; do { if (*p == 'r') s->mode = 'r'; if (*p == 'w') s->mode = 'w'; } while (*p++); if (s->mode == '\0') { destroy(s); return NULL; } if (s->mode == 'w') { #ifdef DO_EXPORT // First, create the deflate class ready for use deflate = new ZipDeflate; if (deflate == NULL) { destroy(s); return NULL; } // Now initialise it, ready for use err = deflate->Init(&(s->stream), Z_DEFAULT_COMPRESSION, DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, 0); /* windowBits is passed < 0 to suppress zlib header */ s->stream.next_out = (Byte*) ALLOC(Z_BUFSIZE); s->outbuf = s->stream.next_out; if (err != Z_OK || s->outbuf == NULL) { destroy(s); return NULL; } s->stream.avail_out = Z_BUFSIZE; /* err = deflate->SetDictionary(&(s->stream), dictionary, dictionary_size); if (err != Z_OK) { destroy(s); return NULL; } */ #else return NULL; #endif } else { // First, create the inflate class ready for use inflate = new ZipInflate; if (inflate == NULL) { destroy(s); return NULL; } err = inflate->Init(&(s->stream), -MAX_WBITS); s->inbuf = (Byte*) ALLOC(Z_BUFSIZE); s->stream.next_in = s->inbuf; if (err != Z_OK || s->inbuf == NULL) { destroy(s); return NULL; } /*err = inflate->SetDictionary(&(s->stream), dictionary, dictionary_size); if (err != Z_OK) { destroy(s); return NULL; } */ } // Moved from inside write clause by 0.99 upgrade //s->stream.avail_out = Z_BUFSIZE; if (s->file == NULL) { destroy(s); return NULL; } // All simple header writing code is done by the native file class // All header/compression verison checking is done by the native file class if (s->mode == 'r') { // This is all done in the native file filter so need to do it here // reset buffer back to zero ready for the true data itself s->stream.avail_in = 0; if (s->file->eof()) { s->z_err = Z_DATA_ERROR; } // Check if reading and the next bytes are not compressed s->stream.avail_in = 15; s->file->read( (char *)s->inbuf, s->stream.avail_in ); // Seek back to where we were before we started this test s->file->seekg(s->InitialPos); if (s->stream.avail_in == 15) { // If we find the following words then the data is not compressed // We must fail but cleanly as all we need to do is read it uncomrpessed if( strncmp( (char *)s->inbuf, "%%AWColourTable", 15 ) == 0 ) { s->stream.avail_in = 0; s->z_err = Z_UNCOMPRESSED_ERROR; return s; } s->stream.avail_in = 0; } else { s->z_err = Z_DATA_ERROR; return s; } } s->Inited = TRUE; return s; }

INT32 GZipFile::gzclose (  GZipStream *  s  )

Flushes all pending output if necessary, closes the compressed file and deallocates all the (de)compression state. The return value is the zlib error number (see function gzerror below). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the z stream to be used [INPUTS] Returns: Z_OK or an error number if there has been a problem Definition at line 1256 of file zstream.cpp. { TRACEUSER( "Neville", _T("GZipFile::gzclose\n")); uInt n; if (s == NULL) return Z_STREAM_ERROR; if (s->mode == 'w') { #ifdef DO_EXPORT INT32 err; err = gzflush(s, Z_FINISH); if (err != Z_OK) return destroy(s); putLong (s->file, s->crc); putLong (s->file, s->stream.total_in); TRACEUSER( "Neville", _T("gzclose calc'd crc = %d\n"),s->crc); TRACEUSER( "Neville", _T("gzclose bytes written = %d\n"),s->stream.total_out); #endif } else if (s->mode == 'r' && s->z_err == Z_STREAM_END) { /* slide CRC and original size if they are at the end of inbuf */ if ((n = s->stream.avail_in) < 8 && !s->z_eof) { Byte *p = s->inbuf; Byte *q = s->stream.next_in; while (n--) { *p++ = *q++; }; n = s->stream.avail_in; // n += fread(p, 1, 8, s->file); INT32 len = 8; s->file->read( (char *)p, len ); n += len; s->stream.next_in = s->inbuf; } // check CRC and original size uLong FileCrc = getLong(s->stream.next_in); uLong FileSize = getLong(s->stream.next_in + 4); TRACEUSER( "Neville", _T("check stored crc %d, against calc'd crc = %d\n"), FileCrc, s->crc); TRACEUSER( "Neville", _T("check stored bytes written %d, against count = %d\n"), FileSize, s->stream.total_out); TRACEUSER( "Neville", _T("bytes left in buffer %d\n"), n); if (n < 8 || FileCrc != s->crc || FileSize != s->stream.total_out) { s->z_err = Z_DATA_ERROR; } // Quick bodge here. We now have n bytes left in the buffer, this will include 8 for the CRC etc. // If we close down compression then the file pointer will be sitting n - 8 bytes on from the // position where we actually want it. Therefore, we must skip back to the correct position. FilePos Pos = s->file->tellg(); Pos = Pos - (n - 8); s->file->seekg(Pos); } return destroy(s); }

INT32 GZipFile::gzflush (  GZipStream *  s, INT32  flush )

Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number (see function gzerror below). gzflush returns Z_OK if the flush parameter is Z_FINISH and all output could be flushed. gzflush should be called only when strictly necessary because it can degrade compression. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip stream that is to be used [INPUTS] flush Definition at line 1149 of file zstream.cpp. { #ifdef DO_EXPORT TRACEUSER( "Neville", _T("GZipFile::gzflush\n")); uInt len; INT32 done = 0; if (s == NULL || s->mode != 'w' || deflate == NULL) return Z_STREAM_ERROR; s->stream.avail_in = 0; /* should be zero already anyway */ for (;;) { len = Z_BUFSIZE - s->stream.avail_out; if (len != 0) { // if (fwrite(s->outbuf, 1, len, s->file) != len) uInt len2 = len; s->file->write((const char*)s->outbuf, len2); if ( len2 != len) { s->z_err = Z_ERRNO; return Z_ERRNO; } s->stream.next_out = s->outbuf; s->stream.avail_out = Z_BUFSIZE; } if (done) break; s->z_err = deflate->deflate(&(s->stream), flush); /* deflate has finished flushing only when it hasn't used up * all the available space in the output buffer: */ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END); if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break; } return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; #else return Z_STREAM_ERROR; #endif }

INT32 GZipFile::gzpeek (  GZipStream *  s, char *  buf )

Reads the next byte from the input stream and returns this to the caller. It then remembers this value for the next read. gzread returns the number of uncompressed bytes actually read (0 for end of file, -1 for error). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip stream that we should be using [INPUTS] buf the character that we are to return Returns: number of uncompressed bytes actually read (0 for end of file, -1 for error) Definition at line 851 of file zstream.cpp. { // check that everyhting is valid before preceeding if (s == NULL || s->mode != 'r' || inflate == NULL || buf == NULL) return Z_STREAM_ERROR; // First check for problem states from last reading/peeking if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */ if (s->z_err == Z_STREAM_END) return 0; /* don't read crc as data */ // first check if we are in the peeked state already if (s->PeekStatus > 0) { // just return the peeked character // add in the values from the peeks ERROR3IF(s->PeekStatus > 1,"peek with status > 1"); buf[0] = s->PeekedValue; // set first byte to be the peeked value // return amount read to caller return 1; } Byte *b = (Byte*)buf; s->stream.next_out = b; // remember the current uncompressed buffer size as this will give us where unsigned offset = s->stream.avail_out; if(offset !=0) ERROR3IF(offset != 0,"peek offset not zero"); s->stream.avail_out += 1; // we want 1 character while (s->stream.avail_out != 0) { if (s->stream.avail_in == 0 && !s->z_eof) { s->stream.avail_in = Z_BUFSIZE; // Note the current file position FilePos Pos = s->file->tellg(); s->file->read((char *) s->inbuf, s->stream.avail_in ); FilePos PosAfter = s->file->tellg(); s->stream.avail_in = PosAfter- Pos; TRACEUSER( "Neville", _T("GZipFile::gz_peek filled buffer size %d\n"),s->stream.avail_in); if (s->stream.avail_in == 0) { s->z_eof = 1; // s->file->setf(s->file->eofbit); } /* else if (s->stream.avail_in == (uInt)EOF) { // s->stream.avail_in = 0; s->z_eof = 1; // s->z_err = Z_ERRNO; // break; }*/ else if (s->stream.avail_in < Z_BUFSIZE || s->file->eof()) { // We are at the end of the file but have read some data in // We must set the goodbit to clear the eof and fail bits as otherwise // all the checks in the diskfile will then fail. s->z_eof = 1; s->file->clear(s->file->goodbit); } s->stream.next_in = s->inbuf; } s->z_err = inflate->inflate(&(s->stream), Z_NO_FLUSH); if (s->z_err == Z_STREAM_END || s->z_err != Z_OK || s->z_eof) break; } // Update len with the bytes left in the uncompressed stream, should be 0 if everything ok unsigned len = 1 - s->stream.avail_out; s->PeekedValue = *buf; // remember the value that was read in s->PeekStatus += 1; // increment peek count s->stream.avail_out += 1; // say that we have peeked 1 character // return the actual amount read in back to the caller return len; }

INT32 GZipFile::gzread (  GZipStream *  s, char *  buf, unsigned  len )

Reads the given number of uncompressed bytes from the compressed file. If the input file was not in gzip format, gzread copies the given number of bytes into the buffer. gzread returns the number of uncompressed bytes actually read (0 for end of file, -1 for error). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip stream that we should be using [INPUTS] buf the buffer that needs the data reading into Returns: number of uncompressed bytes actually read (0 for end of file, -1 for error) Definition at line 949 of file zstream.cpp. { //TRACEUSER( "Neville", _T("GZipFile::gz_read\n")); // check that everyhting is valid before preceeding if (s == NULL || s->mode != 'r' || inflate == NULL || buf == NULL) return Z_STREAM_ERROR; Byte *b = (Byte*)buf; // Section added by version 0.99 update if (s->transparent) { TRACEUSER( "Neville", _T("GZipFile::gz_read trying transparent!\n")); return 0; } // First check for problem states from last reading/peeking if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */ if (s->z_err == Z_STREAM_END) return 0; /* don't read crc as data */ // use the supplied buffer to read the characters into s->stream.next_out = b; // if we have peeked then avail_out will be equal to the number of peeks made if (s->stream.avail_out > 0) { // add in the values from the peeks ERROR3IF(s->stream.avail_out > 1,"read with peek > 1"); buf[0] = s->PeekedValue; // set first byte to be the peeked value s->PeekStatus -= 1; // decrement peek count s->stream.avail_out -= 1; // need one less byte for input if (len == 1) { // only 1 byte wanted and we have just supplied this // checksum the byte that we have just read in s->crc = crc32(s->crc, b, len); return len; } // otherwise we require some more input s->stream.avail_out = len - 1; // need one less byte for input s->stream.next_out = b + 1; // move buffer pointer on by one } else s->stream.avail_out = len; while (s->stream.avail_out != 0) { if (s->stream.avail_in == 0 && !s->z_eof) { s->stream.avail_in = Z_BUFSIZE; // Note the current file position FilePos Pos = s->file->tellg(); s->file->read((char *) s->inbuf, s->stream.avail_in ); FilePos PosAfter = s->file->rdbuf()->pubseekoff( 0, iostream::cur, iostream::in ); s->stream.avail_in = PosAfter- Pos; TRACEUSER( "Neville", _T("GZipFile::gz_read filled buffer size %d\n"),s->stream.avail_in); if (s->stream.avail_in == 0) { //s->file->setf(s->file->eofbit); s->z_eof = 1; } /*else if (s->stream.avail_in == (uInt)EOF) { // s->stream.avail_in = 0; s->z_eof = 1; // s->z_err = Z_ERRNO; // break; } */ else if (s->stream.avail_in < Z_BUFSIZE || s->file->eof()) { // We are at the end of the file but have read some data in // We must set the goodbit to clear the eof and fail bits as otherwise // all the checks in the diskfile will then fail. s->z_eof = 1; s->file->clear(s->file->goodbit); } s->stream.next_in = s->inbuf; } s->z_err = inflate->inflate(&(s->stream), Z_NO_FLUSH); if (s->z_err == Z_STREAM_END || s->z_err != Z_OK || s->z_eof) break; } // Update len with the bytes left in the uncompressed stream, should be 0 if everything ok len -= s->stream.avail_out; // checksum the data that we have just read in s->crc = crc32(s->crc, b, len); // return the actual amount read in back to the caller return len; }

INT32 GZipFile::gzwrite (  GZipStream *  s, const char *  buf, unsigned  len )

Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of bytes actually written (0 in case of error). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: s  the zip stream that we should be using [INPUTS] buf the buffer that needs exporting len the length of the buffer Returns: the number of uncompressed bytes actually written (0 in case of error) Definition at line 1088 of file zstream.cpp. { #ifdef DO_EXPORT //TRACEUSER( "Neville", _T("GZipFile::gz_write\n")); if (s == NULL || s->mode != 'w' || deflate == NULL || buf == NULL) return Z_STREAM_ERROR; Byte* b = (Byte*)buf; s->stream.next_in = b; s->stream.avail_in = len; while (s->stream.avail_in != 0) { if (s->stream.avail_out == 0) { s->stream.next_out = s->outbuf; INT32 len = Z_BUFSIZE; s->file->write((const char*)s->outbuf, len); if (len != Z_BUFSIZE) { s->z_err = Z_ERRNO; break; } s->stream.avail_out = Z_BUFSIZE; } s->z_err = deflate->deflate(&(s->stream), Z_NO_FLUSH); // Check if we had a problem or not if (s->z_err != Z_OK) break; } // Update our checksum of the data s->crc = crc32(s->crc, b, len); // Return the number of bytes that we actually wrote return len - s->stream.avail_in; #else return Z_STREAM_ERROR; #endif }

void GZipFile::putLong (  iostream *  file, uLong  x )  [protected]

Outputs an INT32 in LSB order to the given file. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Definition at line 1205 of file zstream.cpp. { #ifdef DO_EXPORT INT32 n; for (n = 0; n < 4; n++) { // _fputtc((INT32)(x & 0xff), file); file->put((TCHAR)(x & 0xff)); x >>= 8; } #endif }

void * GZipFile::zcalloc (  void *  opaque, unsigned  items, unsigned  size )  [static]

Allocate memory of size items and with size bytes per item. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: opaque  random memory handle/checksum value, never used [INPUTS] items number of items required size size of each buffer item Returns: the checksum value Definition at line 1664 of file zstream.cpp. { // allocate memory of size items and with size bytes per item //return calloc(items, size); return CCMalloc(items * size); }

void GZipFile::zcfree (  void *  opaque, void *  ptr )  [static]

A wrapper round the free function. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 24/05/95 Parameters: opaque  random memory handle/checksum value, never used [INPUTS] ptr memory pointer to free, must have been allocated by zcalloc Definition at line 1683 of file zstream.cpp. { //free(ptr); if (ptr) CCFree(ptr); }

---

Member Data Documentation

ZipDeflate* GZipFile::deflate [protected]

Definition at line 255 of file zstream.h.

ZipInflate* GZipFile::inflate [protected]

Definition at line 256 of file zstream.h.

---

The documentation for this class was generated from the following files:

• Kernel/zstream.h (r1785/r1282)
• Kernel/zstream.cpp (r1785/r1282)

---