mirror of https://github.com/madler/zlib.git
Mark Adler
13 years ago
commit
bcf78a2097
28 changed files with 6146 additions and 0 deletions
@ -0,0 +1,51 @@ |
||||
ChangeLog file for zlib |
||||
|
||||
Changes in 0.71 (14 April 95) |
||||
- Fixed more MSDOS compilation problems :( There is still a bug with |
||||
TurboC large model. |
||||
|
||||
Changes in 0.7 (14 April 95) |
||||
- Added full inflate support. |
||||
- Simplified the crc32() interface. The pre- and post-conditioning |
||||
(one's complement) is now done inside crc32(). WARNING: this is |
||||
incompatible with previous versions; see zlib.h for the new usage. |
||||
|
||||
Changes in 0.61 (12 April 95) |
||||
- workaround for a bug in TurboC. example and minigzip now work on MSDOS. |
||||
|
||||
Changes in 0.6 (11 April 95) |
||||
- added minigzip.c |
||||
- added gzdopen to reopen a file descriptor as gzFile |
||||
- added transparent reading of non-gziped files in gzread. |
||||
- fixed bug in gzread (don't read crc as data) |
||||
- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose). |
||||
- don't allocate big arrays in the stack (for MSDOS) |
||||
- fix some MSDOS compilation problems |
||||
|
||||
Changes in 0.5: |
||||
- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but |
||||
not yet Z_FULL_FLUSH. |
||||
- support decompression but only in a single step (forced Z_FINISH) |
||||
- added opaque object for zalloc and zfree. |
||||
- added deflateReset and inflateReset |
||||
- added a variable zlib_version for consistency checking. |
||||
- renamed the 'filter' parameter of deflateInit2 as 'strategy'. |
||||
Added Z_FILTERED and Z_HUFFMAN_ONLY constants. |
||||
|
||||
Changes in 0.4: |
||||
- avoid "zip" everywhere, use zlib instead of ziplib. |
||||
- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush |
||||
if compression method == 8. |
||||
- added adler32 and crc32 |
||||
- renamed deflateOptions as deflateInit2, call one or the other but not both |
||||
- added the method parameter for deflateInit2. |
||||
- added inflateInit2 |
||||
- simplied considerably deflateInit and inflateInit by not supporting |
||||
user-provided history buffer. This is supported only in deflateInit2 |
||||
and inflateInit2. |
||||
|
||||
Changes in 0.3: |
||||
- prefix all macro names with Z_ |
||||
- use Z_FINISH instead of deflateEnd to finish compression. |
||||
- added Z_HUFFMAN_ONLY |
||||
- added gzerror() |
||||
@ -0,0 +1,59 @@ |
||||
CC=cc
|
||||
CFLAGS=-O
|
||||
#CFLAGS=-g -DDEBUG
|
||||
LDFLAGS=-L. -lgz
|
||||
|
||||
RANLIB=ranlib
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o
|
||||
|
||||
TEST_OBJS = example.o minigzip.o inftest.o
|
||||
|
||||
all: example minigzip inftest |
||||
|
||||
test: all |
||||
./example
|
||||
echo hello world | ./minigzip | ./minigzip -d
|
||||
|
||||
libgz.a: $(OBJS) |
||||
ar rc $@ $(OBJS)
|
||||
$(RANLIB) $@
|
||||
|
||||
example: example.o libgz.a |
||||
$(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS)
|
||||
|
||||
minigzip: minigzip.o libgz.a |
||||
$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
|
||||
|
||||
inftest: inftest.o libgz.a |
||||
$(CC) $(CFLAGS) -o $@ inftest.o $(LDFLAGS)
|
||||
|
||||
clean: |
||||
rm -f *.o example minigzip inftest libgz.a foo.gz
|
||||
|
||||
zip: |
||||
zip -ul9 zlib README ChangeLog Makefile *.[ch]
|
||||
|
||||
tgz: |
||||
cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \
|
||||
zlib/*.[ch]
|
||||
|
||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
|
||||
|
||||
adler32.o: zutil.h zlib.h zconf.h |
||||
compress.o: zlib.h zconf.h |
||||
crc32.o: zutil.h zlib.h zconf.h |
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h |
||||
example.o: zlib.h zconf.h |
||||
gzio.o: zutil.h zlib.h zconf.h |
||||
infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h |
||||
infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h |
||||
inflate.o: zutil.h zlib.h zconf.h infblock.h |
||||
inftest.o: zutil.h zlib.h zconf.h |
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h |
||||
infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h |
||||
minigzip.o: zlib.h zconf.h |
||||
trees.o: deflate.h zutil.h zlib.h zconf.h |
||||
uncompr.o: zlib.h zconf.h |
||||
zutil.o: zutil.h zlib.h zconf.h |
||||
@ -0,0 +1,57 @@ |
||||
zlib 0.71 is a beta version of a general purpose compression library. |
||||
|
||||
The data format used by the zlib library is described in the |
||||
file zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available |
||||
in ftp.uu.net:/pub/archiving/zip/doc. |
||||
|
||||
All functions of the compression library are documented in the file |
||||
zlib.h. A usage example of the library is given in the file example.c |
||||
which also tests that the library is working correctly. |
||||
To compile all files and run the test program, just type: make test |
||||
|
||||
The changes made in version 0.71 are documented in the file ChangeLog. |
||||
The main changes since 0.5 are: |
||||
- added full inflate support |
||||
- added minigzip.c |
||||
- added gzdopen to reopen a file descriptor as gzFile |
||||
- added transparent reading of non-gziped files in gzread. |
||||
- fix some MSDOS problems. example and minigzip now work on MSDOS. |
||||
- Simplified the crc32() interface. The pre- and post-conditioning |
||||
(one's complement) is now done inside crc32(). WARNING: this is |
||||
incompatible with previous versions; see zlib.h for the new usage. |
||||
|
||||
On MSDOS, this version works in large and small model with MSC; in |
||||
small model only with TurboC (bug being investigated). For both |
||||
compilers, small model compression works only for small values of |
||||
MEM_LEVEL and WBITS (see zutil.h), and requires -DUSE_CALLOC. |
||||
|
||||
|
||||
Copyright (C) 1995 Jean-loup Gailly and Mark Adler |
||||
|
||||
This software is provided 'as-is', without any express or implied |
||||
warranty. In no event will the authors be held liable for any damages |
||||
arising from the use of this software. |
||||
|
||||
Permission is granted to anyone to use this software for any purpose, |
||||
including commercial applications, and to alter it and redistribute it |
||||
freely, subject to the following restrictions: |
||||
|
||||
1. The origin of this software must not be misrepresented; you must not |
||||
claim that you wrote the original software. If you use this software |
||||
in a product, an acknowledgment in the product documentation would be |
||||
appreciated but is not required. |
||||
2. Altered source versions must be plainly marked as such, and must not be |
||||
misrepresented as being the original software. |
||||
3. This notice may not be removed or altered from any source distribution. |
||||
|
||||
Jean-loup Gailly Mark Adler |
||||
gzip@prep.ai.mit.edu madler@cco.caltech.edu |
||||
|
||||
If you use the zlib library in a product, we would appreciate *not* |
||||
receiving lengthy legal documents to sign. The sources are provided |
||||
for free but without warranty of any kind. The library has been |
||||
entirely written by Jean-loup Gailly and Mark Adler; it does not |
||||
include third-party code. |
||||
|
||||
If you redistribute modified sources, we would appreciate that you include |
||||
in the file ChangeLog history information documenting your changes. |
||||
@ -0,0 +1,46 @@ |
||||
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: adler32.c,v 1.5 1995/04/14 14:49:51 jloup Exp $ */ |
||||
|
||||
#include "zutil.h" |
||||
|
||||
#define BASE 65521 /* largest prime smaller than 65536 */ |
||||
#define NMAX 5552 |
||||
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ |
||||
|
||||
#define DO1(buf) {s1 += *buf++; s2 += s1;} |
||||
#define DO2(buf) DO1(buf); DO1(buf); |
||||
#define DO4(buf) DO2(buf); DO2(buf); |
||||
#define DO8(buf) DO4(buf); DO4(buf); |
||||
#define DO16(buf) DO8(buf); DO8(buf); |
||||
|
||||
/* ========================================================================= */ |
||||
uLong adler32(adler, buf, len) |
||||
uLong adler; |
||||
Byte *buf; |
||||
uInt len; |
||||
{ |
||||
unsigned long s1 = adler & 0xffff; |
||||
unsigned long s2 = (adler >> 16) & 0xffff; |
||||
int k; |
||||
|
||||
if (buf == Z_NULL) return 1L; |
||||
|
||||
while (len > 0) { |
||||
k = len < NMAX ? len : NMAX; |
||||
len -= k; |
||||
while (k >= 16) { |
||||
DO16(buf); |
||||
k -= 16; |
||||
} |
||||
if (k != 0) do { |
||||
DO1(buf); |
||||
} while (--k); |
||||
s1 %= BASE; |
||||
s2 %= BASE; |
||||
} |
||||
return (s2 << 16) | s1; |
||||
} |
||||
@ -0,0 +1,55 @@ |
||||
/* compress.c -- compress a memory buffer
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: compress.c,v 1.4 1995/04/10 15:52:04 jloup Exp $ */ |
||||
|
||||
#include "zlib.h" |
||||
|
||||
/* ===========================================================================
|
||||
Compresses the source buffer into the destination buffer. sourceLen is |
||||
the byte length of the source buffer. Upon entry, destLen is the total |
||||
size of the destination buffer, which must be at least 0.1% larger than |
||||
sourceLen plus 8 bytes. Upon exit, destLen is the actual size of the |
||||
compressed buffer. |
||||
This function can be used to compress a whole file at once if the |
||||
input file is mmap'ed. |
||||
compress returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output |
||||
buffer. |
||||
*/ |
||||
int compress (dest, destLen, source, sourceLen) |
||||
Byte *dest; |
||||
uLong *destLen; |
||||
Byte *source; |
||||
uLong sourceLen; |
||||
{ |
||||
z_stream stream; |
||||
int err; |
||||
|
||||
stream.next_in = source; |
||||
stream.avail_in = (uInt)sourceLen; |
||||
/* Check for source > 64K on 16-bit machine: */ |
||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
||||
|
||||
stream.next_out = dest; |
||||
stream.avail_out = (uInt)*destLen; |
||||
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; |
||||
|
||||
stream.zalloc = (alloc_func)0; |
||||
stream.zfree = (free_func)0; |
||||
|
||||
err = deflateInit(&stream, Z_DEFAULT_COMPRESSION); |
||||
if (err != Z_OK) return err; |
||||
|
||||
err = deflate(&stream, Z_FINISH); |
||||
if (err != Z_OK) { |
||||
deflateEnd(&stream); |
||||
return err; |
||||
} |
||||
*destLen = stream.total_out; |
||||
|
||||
err = deflateEnd(&stream); |
||||
return err; |
||||
} |
||||
@ -0,0 +1,103 @@ |
||||
/* crc32.c -- compute the CRC-32 of a data stream
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: crc32.c,v 1.4 1995/04/14 14:55:12 jloup Exp $ */ |
||||
|
||||
#include "zlib.h" |
||||
|
||||
extern uLong crc_table[]; /* crc table, defined below */ |
||||
|
||||
/* ========================================================================= */ |
||||
uLong crc32(crc, buf, len) |
||||
uLong crc; |
||||
Byte *buf; |
||||
uInt len; |
||||
{ |
||||
if (buf == Z_NULL) return 0L; |
||||
crc = crc ^ 0xffffffffL; |
||||
if (len) do { |
||||
crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); |
||||
} while (--len); |
||||
return crc ^ 0xffffffffL; |
||||
} |
||||
|
||||
/* =========================================================================
|
||||
* Make the crc table. This function is needed only if you want to compute |
||||
* the table dynamically. |
||||
*/ |
||||
#ifdef DYNAMIC_CRC_TABLE |
||||
|
||||
void make_crc_table() |
||||
{ |
||||
uLong c; |
||||
int n, k; |
||||
|
||||
for (n = 0; n < 256; n++) |
||||
{ |
||||
c = (uLong)n; |
||||
for (k = 0; k < 8; k++) |
||||
c = c & 1 ? 0xedb88320L ^ (c >> 1) : c >> 1; |
||||
crc_table[n] = c; |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
/* ========================================================================
|
||||
* Table of CRC-32's of all single-byte values (made by make_crc_table) |
||||
*/ |
||||
uLong crc_table[] = { |
||||
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, |
||||
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, |
||||
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, |
||||
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, |
||||
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, |
||||
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, |
||||
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, |
||||
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, |
||||
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, |
||||
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, |
||||
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, |
||||
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, |
||||
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, |
||||
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, |
||||
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, |
||||
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, |
||||
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, |
||||
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, |
||||
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, |
||||
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, |
||||
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, |
||||
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, |
||||
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, |
||||
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, |
||||
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, |
||||
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, |
||||
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, |
||||
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, |
||||
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, |
||||
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, |
||||
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, |
||||
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, |
||||
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, |
||||
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, |
||||
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, |
||||
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, |
||||
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, |
||||
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, |
||||
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, |
||||
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, |
||||
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, |
||||
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, |
||||
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, |
||||
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, |
||||
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, |
||||
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, |
||||
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, |
||||
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, |
||||
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, |
||||
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, |
||||
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, |
||||
0x2d02ef8dL |
||||
}; |
||||
@ -0,0 +1,932 @@ |
||||
/* deflate.c -- compress data using the deflation algorithm
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/*
|
||||
* ALGORITHM |
||||
* |
||||
* The "deflation" process depends on being able to identify portions |
||||
* of the input text which are identical to earlier input (within a |
||||
* sliding window trailing behind the input currently being processed). |
||||
* |
||||
* The most straightforward technique turns out to be the fastest for |
||||
* most input files: try all possible matches and select the longest. |
||||
* The key feature of this algorithm is that insertions into the string |
||||
* dictionary are very simple and thus fast, and deletions are avoided |
||||
* completely. Insertions are performed at each input character, whereas |
||||
* string matches are performed only when the previous match ends. So it |
||||
* is preferable to spend more time in matches to allow very fast string |
||||
* insertions and avoid deletions. The matching algorithm for small |
||||
* strings is inspired from that of Rabin & Karp. A brute force approach |
||||
* is used to find longer strings when a small match has been found. |
||||
* A similar algorithm is used in comic (by Jan-Mark Wams) and freeze |
||||
* (by Leonid Broukhis). |
||||
* A previous version of this file used a more sophisticated algorithm |
||||
* (by Fiala and Greene) which is guaranteed to run in linear amortized |
||||
* time, but has a larger average cost, uses more memory and is patented. |
||||
* However the F&G algorithm may be faster for some highly redundant |
||||
* files if the parameter max_chain_length (described below) is too large. |
||||
* |
||||
* ACKNOWLEDGEMENTS |
||||
* |
||||
* The idea of lazy evaluation of matches is due to Jan-Mark Wams, and |
||||
* I found it in 'freeze' written by Leonid Broukhis. |
||||
* Thanks to many people for bug reports and testing. |
||||
* |
||||
* REFERENCES |
||||
* |
||||
* Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". |
||||
* Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc |
||||
* |
||||
* A description of the Rabin and Karp algorithm is given in the book |
||||
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252. |
||||
* |
||||
* Fiala,E.R., and Greene,D.H. |
||||
* Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 |
||||
* |
||||
*/ |
||||
|
||||
/* $Id: deflate.c,v 1.3 1995/04/10 16:03:45 jloup Exp $ */ |
||||
|
||||
#include "deflate.h" |
||||
|
||||
char copyright[] = " deflate Copyright 1995 Jean-loup Gailly "; |
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome |
||||
in the documentation of your product. If for some reason you cannot |
||||
include such an acknowledgment, I would appreciate that you keep this |
||||
copyright string in the executable of your product. |
||||
*/ |
||||
|
||||
#define NIL 0 |
||||
/* Tail of hash chains */ |
||||
|
||||
#ifndef TOO_FAR |
||||
# define TOO_FAR 4096 |
||||
#endif |
||||
/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ |
||||
|
||||
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) |
||||
/* Minimum amount of lookahead, except at the end of the input file.
|
||||
* See deflate.c for comments about the MIN_MATCH+1. |
||||
*/ |
||||
|
||||
/* Values for max_lazy_match, good_match and max_chain_length, depending on
|
||||
* the desired pack level (0..9). The values given below have been tuned to |
||||
* exclude worst case performance for pathological files. Better values may be |
||||
* found for specific files. |
||||
*/ |
||||
|
||||
typedef struct config_s { |
||||
ush good_length; /* reduce lazy search above this match length */ |
||||
ush max_lazy; /* do not perform lazy search above this match length */ |
||||
ush nice_length; /* quit search above this match length */ |
||||
ush max_chain; |
||||
} config; |
||||
|
||||
local config configuration_table[10] = { |
||||
/* good lazy nice chain */ |
||||
/* 0 */ {0, 0, 0, 0}, /* store only */ |
||||
/* 1 */ {4, 4, 8, 4}, /* maximum speed, no lazy matches */ |
||||
/* 2 */ {4, 5, 16, 8}, |
||||
/* 3 */ {4, 6, 32, 32}, |
||||
|
||||
/* 4 */ {4, 4, 16, 16}, /* lazy matches */ |
||||
/* 5 */ {8, 16, 32, 32}, |
||||
/* 6 */ {8, 16, 128, 128}, |
||||
/* 7 */ {8, 32, 128, 256}, |
||||
/* 8 */ {32, 128, 258, 1024}, |
||||
/* 9 */ {32, 258, 258, 4096}}; /* maximum compression */ |
||||
|
||||
/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
|
||||
* For deflate_fast() (levels <= 3) good is ignored and lazy has a different |
||||
* meaning. |
||||
*/ |
||||
|
||||
#define EQUAL 0 |
||||
/* result of memcmp for equal strings */ |
||||
|
||||
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ |
||||
|
||||
/* ===========================================================================
|
||||
* Prototypes for local functions. |
||||
*/ |
||||
|
||||
local void fill_window __P((deflate_state *s)); |
||||
local int deflate_fast __P((deflate_state *s, int flush)); |
||||
local int deflate_slow __P((deflate_state *s, int flush)); |
||||
local void lm_init __P((deflate_state *s)); |
||||
|
||||
local int longest_match __P((deflate_state *s, IPos cur_match)); |
||||
#ifdef ASMV |
||||
void match_init __P((void)); /* asm code initialization */ |
||||
#endif |
||||
|
||||
#ifdef DEBUG |
||||
local void check_match __P((deflate_state *s, IPos start, IPos match, |
||||
int length)); |
||||
#endif |
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* Update a hash value with the given input byte |
||||
* IN assertion: all calls to to UPDATE_HASH are made with consecutive |
||||
* input characters, so that a running hash key can be computed from the |
||||
* previous key instead of complete recalculation each time. |
||||
*/ |
||||
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) |
||||
|
||||
/* ===========================================================================
|
||||
* Insert string str in the dictionary and set match_head to the previous head |
||||
* of the hash chain (the most recent string with same hash key). Return |
||||
* the previous length of the hash chain. |
||||
* IN assertion: all calls to to INSERT_STRING are made with consecutive |
||||
* input characters and the first MIN_MATCH bytes of str are valid |
||||
* (except for the last MIN_MATCH-1 bytes of the input file). |
||||
*/ |
||||
#define INSERT_STRING(s, str, match_head) \ |
||||
(UPDATE_HASH(s, s->ins_h, s->window[(str) + MIN_MATCH-1]), \
|
||||
s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \
|
||||
s->head[s->ins_h] = (str)) |
||||
|
||||
/* ========================================================================= */ |
||||
int deflateInit (strm, level) |
||||
z_stream *strm; |
||||
int level; |
||||
{ |
||||
return deflateInit2 (strm, level, DEFLATED, WBITS, MEM_LEVEL, 0); |
||||
/* To do: ignore strm->next_in if we use it as window */ |
||||
} |
||||
|
||||
/* ========================================================================= */ |
||||
int deflateInit2 (strm, level, method, windowBits, memLevel, strategy) |
||||
z_stream *strm; |
||||
int level; |
||||
int method; |
||||
int windowBits; |
||||
int memLevel; |
||||
int strategy; |
||||
{ |
||||
deflate_state *s; |
||||
int noheader = 0; |
||||
|
||||
if (strm == Z_NULL) return Z_STREAM_ERROR; |
||||
|
||||
strm->msg = Z_NULL; |
||||
if (strm->zalloc == Z_NULL) strm->zalloc = zcalloc; |
||||
if (strm->zfree == Z_NULL) strm->zfree = zcfree; |
||||
|
||||
if (level == Z_DEFAULT_COMPRESSION) level = 6; |
||||
|
||||
if (windowBits < 0) { /* undocumented feature: suppress zlib header */ |
||||
noheader = 1; |
||||
windowBits = -windowBits; |
||||
} |
||||
if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != DEFLATED || |
||||
windowBits < 8 || windowBits > 15 || level < 1 || level > 9) { |
||||
return Z_STREAM_ERROR; |
||||
} |
||||
s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); |
||||
if (s == Z_NULL) return Z_MEM_ERROR; |
||||
strm->state = (struct internal_state *)s; |
||||
s->strm = strm; |
||||
|
||||
s->noheader = noheader; |
||||
s->w_bits = windowBits; |
||||
s->w_size = 1 << s->w_bits; |
||||
|
||||
s->hash_bits = memLevel + 7; |
||||
s->hash_size = 1 << s->hash_bits; |
||||
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); |
||||
|
||||
s->window = (Byte*) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); |
||||
s->prev = (Pos*) ZALLOC(strm, s->w_size, sizeof(Pos)); |
||||
s->head = (Pos*) ZALLOC(strm, s->hash_size, sizeof(Pos)); |
||||
|
||||
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ |
||||
|
||||
s->pending_buf = (uch*) ZALLOC(strm, s->lit_bufsize, 2*sizeof(ush)); |
||||
|
||||
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || |
||||
s->pending_buf == Z_NULL) { |
||||
strm->msg = z_errmsg[1-Z_MEM_ERROR]; |
||||
deflateEnd (strm); |
||||
return Z_MEM_ERROR; |
||||
} |
||||
s->d_buf = (ush*) &(s->pending_buf[s->lit_bufsize]); |
||||
s->l_buf = (uch*) &(s->pending_buf[3*s->lit_bufsize]); |
||||
/* We overlay pending_buf and d_buf+l_buf. This works since the average
|
||||
* output size for (length,distance) codes is <= 32 bits (worst case |
||||
* is 15+15+13=33). |
||||
*/ |
||||
|
||||
s->level = level; |
||||
s->strategy = strategy; |
||||
s->method = method; |
||||
|
||||
return deflateReset(strm); |
||||
} |
||||
|
||||
/* ========================================================================= */ |
||||
int deflateReset (strm) |
||||
z_stream *strm; |
||||
{ |
||||
deflate_state *s; |
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || |
||||
strm->zalloc == Z_NULL || strm->zfree == Z_NULL) return Z_STREAM_ERROR; |
||||
|
||||
strm->total_in = strm->total_out = 0; |
||||
strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ |
||||
strm->data_type = Z_UNKNOWN; |
||||
|
||||
s = (deflate_state *)strm->state; |
||||
s->pending = 0; |
||||
s->pending_out = s->pending_buf; |
||||
|
||||
s->status = s->noheader ? BUSY_STATE : INIT_STATE; |
||||
s->adler = 1; |
||||
|
||||
ct_init(s); |
||||
lm_init(s); |
||||
|
||||
return Z_OK; |
||||
} |
||||
|
||||
/* =========================================================================
|
||||
* Put a short the pending_out buffer. The 16-bit value is put in MSB order. |
||||
* IN assertion: the stream state is correct and there is enough room in |
||||
* the pending_out buffer. |
||||
*/ |
||||
local void putShortMSB (s, b) |
||||
deflate_state *s; |
||||
uInt b; |
||||
{ |
||||
put_byte(s, b >> 8); |
||||
put_byte(s, b & 0xff); |
||||
}
|
||||
|
||||
/* =========================================================================
|
||||
* Flush as much pending output as possible. |
||||
*/ |
||||
local void flush_pending(strm) |
||||
z_stream *strm; |
||||
{ |
||||
unsigned len = strm->state->pending; |
||||
|
||||
if (len > strm->avail_out) len = strm->avail_out; |
||||
if (len == 0) return; |
||||
|
||||
zmemcpy(strm->next_out, strm->state->pending_out, len); |
||||
strm->next_out += len; |
||||
strm->state->pending_out += len; |
||||
strm->total_out += len; |
||||
strm->avail_out -= len; |
||||
strm->state->pending -= len; |
||||
if (strm->state->pending == 0) { |
||||
strm->state->pending_out = strm->state->pending_buf; |
||||
} |
||||
} |
||||
|
||||
/* ========================================================================= */ |
||||
int deflate (strm, flush) |
||||
z_stream *strm; |
||||
int flush; |
||||
{ |
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
||||
|
||||
if (strm->next_out == Z_NULL || strm->next_in == Z_NULL) { |
||||
ERR_RETURN(strm, Z_STREAM_ERROR); |
||||
} |
||||
if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); |
||||
|
||||
strm->state->strm = strm; /* just in case */ |
||||
|
||||
/* Write the zlib header */ |
||||
if (strm->state->status == INIT_STATE) { |
||||
|
||||
uInt header = (DEFLATED + ((strm->state->w_bits-8)<<4)) << 8; |
||||
uInt level_flags = (strm->state->level-1) >> 1; |
||||
|
||||
if (level_flags > 3) level_flags = 3; |
||||
header |= (level_flags << 6); |
||||
header += 31 - (header % 31); |
||||
|
||||
strm->state->status = BUSY_STATE; |
||||
putShortMSB(strm->state, header); |
||||
} |
||||
|
||||
/* Flush as much pending output as possible */ |
||||
if (strm->state->pending != 0) { |
||||
flush_pending(strm); |
||||
if (strm->avail_out == 0) return Z_OK; |
||||
} |
||||
|
||||
/* User must not provide more input after the first FINISH: */ |
||||
if (strm->state->status == FINISH_STATE && strm->avail_in != 0) { |
||||
ERR_RETURN(strm, Z_BUF_ERROR); |
||||
} |
||||
|
||||
/* Start a new block or continue the current one.
|
||||
*/ |
||||
if (strm->avail_in != 0 || |
||||
(flush == Z_FINISH && strm->state->status != FINISH_STATE)) { |
||||
|
||||
if (flush == Z_FINISH) { |
||||
strm->state->status = FINISH_STATE; |
||||
} |
||||
if (strm->state->level <= 3) { |
||||
if (deflate_fast(strm->state, flush)) return Z_OK; |
||||
} else { |
||||
if (deflate_slow(strm->state, flush)) return Z_OK; |
||||
} |
||||
} |
||||
Assert(strm->avail_out > 0, "bug2"); |
||||
|
||||
if (flush != Z_FINISH || strm->state->noheader) return Z_OK; |
||||
|
||||
/* Write the zlib trailer (adler32) */ |
||||
putShortMSB(strm->state, strm->state->adler >> 16); |
||||
putShortMSB(strm->state, strm->state->adler & 0xffff); |
||||
flush_pending(strm); |
||||
/* If avail_out is zero, the application will call deflate again
|
||||
* to flush the rest. |
||||
*/ |
||||
strm->state->noheader = 1; /* write the trailer only once! */ |
||||
return Z_OK; |
||||
} |
||||
|
||||
/* ========================================================================= */ |
||||
int deflateEnd (strm) |
||||
z_stream *strm; |
||||
{ |
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
||||
|
||||
TRY_FREE(strm, strm->state->window); |
||||
TRY_FREE(strm, strm->state->prev); |
||||
TRY_FREE(strm, strm->state->head); |
||||
TRY_FREE(strm, strm->state->pending_buf); |
||||
|
||||
ZFREE(strm, strm->state); |
||||
strm->state = Z_NULL; |
||||
|
||||
return Z_OK; |
||||
} |
||||
|
||||
/* ========================================================================= */ |
||||
int deflateCopy (dest, source) |
||||
z_stream *dest; |
||||
z_stream *source; |
||||
{ |
||||
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { |
||||
return Z_STREAM_ERROR; |
||||
} |
||||
*dest = *source; |
||||
return Z_STREAM_ERROR; /* to be implemented */ |
||||
#if 0 |
||||
dest->state = (struct internal_state *) |
||||
(*dest->zalloc)(1, sizeof(deflate_state)); |
||||
if (dest->state == Z_NULL) return Z_MEM_ERROR; |
||||
|
||||
*(dest->state) = *(source->state); |
||||
return Z_OK; |
||||
#endif |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Read a new buffer from the current input stream, update the adler32 |
||||
* and total number of bytes read. |
||||
*/ |
||||
local int read_buf(strm, buf, size) |
||||
z_stream *strm; |
||||
char *buf; |
||||
unsigned size; |
||||
{ |
||||
unsigned len = strm->avail_in; |
||||
|
||||
if (len > size) len = size; |
||||
if (len == 0) return 0; |
||||
|
||||
strm->avail_in -= len; |
||||
|
||||
if (!strm->state->noheader) { |
||||
strm->state->adler = adler32(strm->state->adler, strm->next_in, len); |
||||
} |
||||
zmemcpy(buf, strm->next_in, len); |
||||
strm->next_in += len; |
||||
strm->total_in += len; |
||||
|
||||
return (int)len; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Initialize the "longest match" routines for a new zlib stream |
||||
*/ |
||||
local void lm_init (s) |
||||
deflate_state *s; |
||||
{ |
||||
register unsigned j; |
||||
|
||||
s->window_size = (ulg)2L*s->w_size; |
||||
|
||||
|
||||
/* Initialize the hash table (avoiding 64K overflow for 16 bit systems).
|
||||
* prev[] will be initialized on the fly. |
||||
*/ |
||||
s->head[s->hash_size-1] = NIL; |
||||
zmemzero((char*)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); |
||||
|
||||
/* Set the default configuration parameters:
|
||||
*/ |
||||
s->max_lazy_match = configuration_table[s->level].max_lazy; |
||||
s->good_match = configuration_table[s->level].good_length; |
||||
s->nice_match = configuration_table[s->level].nice_length; |
||||
s->max_chain_length = configuration_table[s->level].max_chain; |
||||
|
||||
s->strstart = 0; |
||||
s->block_start = 0L; |
||||
s->lookahead = 0; |
||||
s->match_length = MIN_MATCH-1; |
||||
s->match_available = 0; |
||||
#ifdef ASMV |
||||
match_init(); /* initialize the asm code */ |
||||
#endif |
||||
|
||||
s->ins_h = 0; |
||||
for (j=0; j<MIN_MATCH-1; j++) UPDATE_HASH(s, s->ins_h, s->window[j]); |
||||
/* If lookahead < MIN_MATCH, ins_h is garbage, but this is
|
||||
* not important since only literal bytes will be emitted. |
||||
*/ |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Set match_start to the longest match starting at the given string and |
||||
* return its length. Matches shorter or equal to prev_length are discarded, |
||||
* in which case the result is equal to prev_length and match_start is |
||||
* garbage. |
||||
* IN assertions: cur_match is the head of the hash chain for the current |
||||
* string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 |
||||
*/ |
||||
#ifndef ASMV |
||||
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
|
||||
* match.S. The code will be functionally equivalent. |
||||
*/ |
||||
local int longest_match(s, cur_match) |
||||
deflate_state *s; |
||||
IPos cur_match; /* current match */ |
||||
{ |
||||
unsigned chain_length = s->max_chain_length;/* max hash chain length */ |
||||
register Byte *scan = s->window + s->strstart; /* current string */ |
||||
register Byte *match; /* matched string */ |
||||
register int len; /* length of current match */ |
||||
int best_len = s->prev_length; /* best match length so far */ |
||||
IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
||||
s->strstart - (IPos)MAX_DIST(s) : NIL; |
||||
/* Stop when cur_match becomes <= limit. To simplify the code,
|
||||
* we prevent matches with the string of window index 0. |
||||
*/ |
||||
|
||||
#ifdef UNALIGNED_OK |
||||
/* Compare two bytes at a time. Note: this is not always beneficial.
|
||||
* Try with and without -DUNALIGNED_OK to check. |
||||
*/ |
||||
register Byte *strend = s->window + s->strstart + MAX_MATCH - 1; |
||||
register ush scan_start = *(ush*)scan; |
||||
register ush scan_end = *(ush*)(scan+best_len-1); |
||||
#else |
||||
register Byte *strend = s->window + s->strstart + MAX_MATCH; |
||||
register Byte scan_end1 = scan[best_len-1]; |
||||
register Byte scan_end = scan[best_len]; |
||||
#endif |
||||
|
||||
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
||||
* It is easy to get rid of this optimization if necessary. |
||||
*/ |
||||
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); |
||||
|
||||
/* Do not waste too much time if we already have a good match: */ |
||||
if (s->prev_length >= s->good_match) { |
||||
chain_length >>= 2; |
||||
} |
||||
Assert(s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); |
||||
|
||||
do { |
||||
Assert(cur_match < s->strstart, "no future"); |
||||
match = s->window + cur_match; |
||||
|
||||
/* Skip to next match if the match length cannot increase
|
||||
* or if the match length is less than 2: |
||||
*/ |
||||
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) |
||||
/* This code assumes sizeof(unsigned short) == 2. Do not use
|
||||
* UNALIGNED_OK if your compiler uses a different size. |
||||
*/ |
||||
if (*(ush*)(match+best_len-1) != scan_end || |
||||
*(ush*)match != scan_start) continue; |
||||
|
||||
/* It is not necessary to compare scan[2] and match[2] since they are
|
||||
* always equal when the other bytes match, given that the hash keys |
||||
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at |
||||
* strstart+3, +5, ... up to strstart+257. We check for insufficient |
||||
* lookahead only every 4th comparison; the 128th check will be made |
||||
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is |
||||
* necessary to put more guard bytes at the end of the window, or |
||||
* to check more often for insufficient lookahead. |
||||
*/ |
||||
scan++, match++; |
||||
do { |
||||
} while (*(ush*)(scan+=2) == *(ush*)(match+=2) && |
||||
*(ush*)(scan+=2) == *(ush*)(match+=2) && |
||||
*(ush*)(scan+=2) == *(ush*)(match+=2) && |
||||
*(ush*)(scan+=2) == *(ush*)(match+=2) && |
||||
scan < strend); |
||||
/* The funny "do {}" generates better code on most compilers */ |
||||
|
||||
/* Here, scan <= window+strstart+257 */ |
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
||||
if (*scan == *match) scan++; |
||||
|
||||
len = (MAX_MATCH - 1) - (int)(strend-scan); |
||||
scan = strend - (MAX_MATCH-1); |
||||
|
||||
#else /* UNALIGNED_OK */ |
||||
|
||||
if (match[best_len] != scan_end || |
||||
match[best_len-1] != scan_end1 || |
||||
*match != *scan || |
||||
*++match != scan[1]) continue; |
||||
|
||||
/* The check at best_len-1 can be removed because it will be made
|
||||
* again later. (This heuristic is not always a win.) |
||||
* It is not necessary to compare scan[2] and match[2] since they |
||||
* are always equal when the other bytes match, given that |
||||
* the hash keys are equal and that HASH_BITS >= 8. |
||||
*/ |
||||
scan += 2, match++; |
||||
|
||||
/* We check for insufficient lookahead only every 8th comparison;
|
||||
* the 256th check will be made at strstart+258. |
||||
*/ |
||||
do { |
||||
} while (*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
scan < strend); |
||||
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
||||
|
||||
len = MAX_MATCH - (int)(strend - scan); |
||||
scan = strend - MAX_MATCH; |
||||
|
||||
#endif /* UNALIGNED_OK */ |
||||
|
||||
if (len > best_len) { |
||||
s->match_start = cur_match; |
||||
best_len = len; |
||||
if (len >= s->nice_match) break; |
||||
#ifdef UNALIGNED_OK |
||||
scan_end = *(ush*)(scan+best_len-1); |
||||
#else |
||||
scan_end1 = scan[best_len-1]; |
||||
scan_end = scan[best_len]; |
||||
#endif |
||||
} |
||||
} while ((cur_match = s->prev[cur_match & s->w_mask]) > limit |
||||
&& --chain_length != 0); |
||||
|
||||
return best_len; |
||||
} |
||||
#endif /* ASMV */ |
||||
|
||||
#ifdef DEBUG |
||||
/* ===========================================================================
|
||||
* Check that the match at match_start is indeed a match. |
||||
*/ |
||||
local void check_match(s, start, match, length) |
||||
deflate_state *s; |
||||
IPos start, match; |
||||
int length; |
||||
{ |
||||
/* check that the match is indeed a match */ |
||||
if (memcmp((char*)s->window + match, |
||||
(char*)s->window + start, length) != EQUAL) { |
||||
fprintf(stderr, |
||||
" start %d, match %d, length %d\n", |
||||
start, match, length); |
||||
z_error("invalid match"); |
||||
} |
||||
if (verbose > 1) { |
||||
fprintf(stderr,"\\[%d,%d]", start-match, length); |
||||
do { putc(s->window[start++], stderr); } while (--length != 0); |
||||
} |
||||
} |
||||
#else |
||||
# define check_match(s, start, match, length) |
||||
#endif |
||||
|
||||
/* ===========================================================================
|
||||
* Fill the window when the lookahead becomes insufficient. |
||||
* Updates strstart and lookahead. |
||||
* |
||||
* IN assertion: lookahead < MIN_LOOKAHEAD |
||||
* OUT assertions: strstart <= window_size-MIN_LOOKAHEAD |
||||
* At least one byte has been read, or avail_in == 0; reads are |
||||
* performed for at least two bytes (required for the zip translate_eol |
||||
* option -- not supported here). |
||||
*/ |
||||
local void fill_window(s) |
||||
deflate_state *s; |
||||
{ |
||||
register unsigned n, m; |
||||
unsigned more; /* Amount of free space at the end of the window. */ |
||||
|
||||
do { |
||||
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); |
||||
|
||||
/* Deal with !@#$% 64K limit: */ |
||||
if (more == 0 && s->strstart == 0 && s->lookahead == 0) { |
||||
more = s->w_size; |
||||
} else if (more == (unsigned)(-1)) { |
||||
/* Very unlikely, but possible on 16 bit machine if strstart == 0
|
||||
* and lookahead == 1 (input done one byte at time) |
||||
*/ |
||||
more--; |
||||
|
||||
/* If the window is almost full and there is insufficient lookahead,
|
||||
* move the upper half to the lower one to make room in the upper half. |
||||
*/ |
||||
} else if (s->strstart >= s->w_size+MAX_DIST(s)) { |
||||
|
||||
/* By the IN assertion, the window is not empty so we can't confuse
|
||||
* more == 0 with more == 64K on a 16 bit machine. |
||||
*/ |
||||
memcpy((char*)s->window, (char*)s->window+s->w_size, |
||||
(unsigned)s->w_size); |
||||
s->match_start -= s->w_size; |
||||
s->strstart -= s->w_size; /* we now have strstart >= MAX_DIST */ |
||||
|
||||
s->block_start -= (long) s->w_size; |
||||
|
||||
for (n = 0; n < s->hash_size; n++) { |
||||
m = s->head[n]; |
||||
s->head[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL); |
||||
} |
||||
for (n = 0; n < s->w_size; n++) { |
||||
m = s->prev[n]; |
||||
s->prev[n] = (Pos)(m >= s->w_size ? m-s->w_size : NIL); |
||||
/* If n is not on any hash chain, prev[n] is garbage but
|
||||
* its value will never be used. |
||||
*/ |
||||
} |
||||
more += s->w_size; |
||||
} |
||||
if (s->strm->avail_in == 0) return; |
||||
|
||||
/* If there was no sliding:
|
||||
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && |
||||
* more == window_size - lookahead - strstart |
||||
* => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) |
||||
* => more >= window_size - 2*WSIZE + 2 |
||||
* In the BIG_MEM or MMAP case (not yet supported), |
||||
* window_size == input_size + MIN_LOOKAHEAD && |
||||
* strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. |
||||
* Otherwise, window_size == 2*WSIZE so more >= 2. |
||||
* If there was sliding, more >= WSIZE. So in all cases, more >= 2. |
||||
*/ |
||||
Assert(more >= 2, "more < 2"); |
||||
|
||||
n = read_buf(s->strm, (char*)s->window + s->strstart + s->lookahead, |
||||
more); |
||||
s->lookahead += n; |
||||
|
||||
} while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Flush the current block, with given end-of-file flag. |
||||
* IN assertion: strstart is set to the end of the current match. |
||||
*/ |
||||
#define FLUSH_BLOCK_ONLY(s, eof) { \ |
||||
ct_flush_block(s, (s->block_start >= 0L ? \
|
||||
(char*)&s->window[(unsigned)s->block_start] : \
|
||||
(char*)Z_NULL), (long)s->strstart - s->block_start, (eof)); \
|
||||
s->block_start = s->strstart; \
|
||||
flush_pending(s->strm); \
|
||||
} |
||||
|
||||
/* Same but force premature exit if necessary. */ |
||||
#define FLUSH_BLOCK(s, eof) { \ |
||||
FLUSH_BLOCK_ONLY(s, eof); \
|
||||
if (s->strm->avail_out == 0) return 1; \
|
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Compress as much as possible from the input stream, return true if |
||||
* processing was terminated prematurely (no more input or output space). |
||||
* This function does not perform lazy evaluationof matches and inserts |
||||
* new strings in the dictionary only for unmatched strings or for short |
||||
* matches. It is used only for the fast compression options. |
||||
*/ |
||||
local int deflate_fast(s, flush) |
||||
deflate_state *s; |
||||
int flush; |
||||
{ |
||||
IPos hash_head; /* head of the hash chain */ |
||||
int bflush; /* set if current block must be flushed */ |
||||
|
||||
s->prev_length = MIN_MATCH-1; |
||||
|
||||
for (;;) { |
||||
/* Make sure that we always have enough lookahead, except
|
||||
* at the end of the input file. We need MAX_MATCH bytes |
||||
* for the next match, plus MIN_MATCH bytes to insert the |
||||
* string following the next match. |
||||
*/ |
||||
if (s->lookahead < MIN_LOOKAHEAD) { |
||||
fill_window(s); |
||||
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1; |
||||
|
||||
if (s->lookahead == 0) break; /* flush the current block */ |
||||
} |
||||
|
||||
/* Insert the string window[strstart .. strstart+2] in the
|
||||
* dictionary, and set hash_head to the head of the hash chain: |
||||
*/ |
||||
INSERT_STRING(s, s->strstart, hash_head); |
||||
|
||||
/* Find the longest match, discarding those <= prev_length.
|
||||
* At this point we have always match_length < MIN_MATCH |
||||
*/ |
||||
if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { |
||||
/* To simplify the code, we prevent matches with the string
|
||||
* of window index 0 (in particular we have to avoid a match |
||||
* of the string with itself at the start of the input file). |
||||
*/ |
||||
if (s->strategy != Z_HUFFMAN_ONLY) { |
||||
s->match_length = longest_match (s, hash_head); |
||||
} |
||||
/* longest_match() sets match_start */ |
||||
|
||||
if (s->match_length > s->lookahead) s->match_length = s->lookahead; |
||||
} |
||||
if (s->match_length >= MIN_MATCH) { |
||||
check_match(s, s->strstart, s->match_start, s->match_length); |
||||
|
||||
bflush = ct_tally(s, s->strstart - s->match_start, |
||||
s->match_length - MIN_MATCH); |
||||
|
||||
s->lookahead -= s->match_length; |
||||
|
||||
/* Insert new strings in the hash table only if the match length
|
||||
* is not too large. This saves time but degrades compression. |
||||
*/ |
||||
if (s->match_length <= s->max_insert_length) { |
||||
s->match_length--; /* string at strstart already in hash table */ |
||||
do { |
||||
s->strstart++; |
||||
INSERT_STRING(s, s->strstart, hash_head); |
||||
/* strstart never exceeds WSIZE-MAX_MATCH, so there are
|
||||
* always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH |
||||
* these bytes are garbage, but it does not matter since |
||||
* the next lookahead bytes will be emitted as literals. |
||||
*/ |
||||
} while (--s->match_length != 0); |
||||
s->strstart++;
|
||||
} else { |
||||
s->strstart += s->match_length; |
||||
s->match_length = 0; |
||||
s->ins_h = s->window[s->strstart]; |
||||
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); |
||||
#if MIN_MATCH != 3 |
||||
Call UPDATE_HASH() MIN_MATCH-3 more times |
||||
#endif |
||||
} |
||||
} else { |
||||
/* No match, output a literal byte */ |
||||
Tracevv((stderr,"%c", s->window[s->strstart])); |
||||
bflush = ct_tally (s, 0, s->window[s->strstart]); |
||||
s->lookahead--; |
||||
s->strstart++;
|
||||
} |
||||
if (bflush) FLUSH_BLOCK(s, 0); |
||||
} |
||||
FLUSH_BLOCK(s, flush == Z_FINISH); |
||||
return 0; /* normal exit */ |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Same as above, but achieves better compression. We use a lazy |
||||
* evaluation for matches: a match is finally adopted only if there is |
||||
* no better match at the next window position. |
||||
*/ |
||||
local int deflate_slow(s, flush) |
||||
deflate_state *s; |
||||
int flush; |
||||
{ |
||||
IPos hash_head; /* head of hash chain */ |
||||
int bflush; /* set if current block must be flushed */ |
||||
|
||||
/* Process the input block. */ |
||||
for (;;) { |
||||
/* Make sure that we always have enough lookahead, except
|
||||
* at the end of the input file. We need MAX_MATCH bytes |
||||
* for the next match, plus MIN_MATCH bytes to insert the |
||||
* string following the next match. |
||||
*/ |
||||
if (s->lookahead < MIN_LOOKAHEAD) { |
||||
fill_window(s); |
||||
if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) return 1; |
||||
|
||||
if (s->lookahead == 0) break; /* flush the current block */ |
||||
} |
||||
|
||||
/* Insert the string window[strstart .. strstart+2] in the
|
||||
* dictionary, and set hash_head to the head of the hash chain: |
||||
*/ |
||||
INSERT_STRING(s, s->strstart, hash_head); |
||||
|
||||
/* Find the longest match, discarding those <= prev_length.
|
||||
*/ |
||||
s->prev_length = s->match_length, s->prev_match = s->match_start; |
||||
s->match_length = MIN_MATCH-1; |
||||
|
||||
if (hash_head != NIL && s->prev_length < s->max_lazy_match && |
||||
s->strstart - hash_head <= MAX_DIST(s)) { |
||||
/* To simplify the code, we prevent matches with the string
|
||||
* of window index 0 (in particular we have to avoid a match |
||||
* of the string with itself at the start of the input file). |
||||
*/ |
||||
if (s->strategy != Z_HUFFMAN_ONLY) { |
||||
s->match_length = longest_match (s, hash_head); |
||||
} |
||||
/* longest_match() sets match_start */ |
||||
if (s->match_length > s->lookahead) s->match_length = s->lookahead; |
||||
|
||||
if (s->match_length <= 5 && (s->strategy == Z_FILTERED || |
||||
(s->match_length == MIN_MATCH && |
||||
s->strstart - s->match_start > TOO_FAR))) { |
||||
|
||||
/* If prev_match is also MIN_MATCH, match_start is garbage
|
||||
* but we will ignore the current match anyway. |
||||
*/ |
||||
s->match_length = MIN_MATCH-1; |
||||
} |
||||
} |
||||
/* If there was a match at the previous step and the current
|
||||
* match is not better, output the previous match: |
||||
*/ |
||||
if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { |
||||
|
||||
check_match(s, s->strstart-1, s->prev_match, s->prev_length); |
||||
|
||||
bflush = ct_tally(s, s->strstart -1 - s->prev_match, |
||||
s->prev_length - MIN_MATCH); |
||||
|
||||
/* Insert in hash table all strings up to the end of the match.
|
||||
* strstart-1 and strstart are already inserted. |
||||
*/ |
||||
s->lookahead -= s->prev_length-1; |
||||
s->prev_length -= 2; |
||||
do { |
||||
s->strstart++; |
||||
INSERT_STRING(s, s->strstart, hash_head); |
||||
/* strstart never exceeds WSIZE-MAX_MATCH, so there are
|
||||
* always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH |
||||
* these bytes are garbage, but it does not matter since the |
||||
* next lookahead bytes will always be emitted as literals. |
||||
*/ |
||||
} while (--s->prev_length != 0); |
||||
s->match_available = 0; |
||||
s->match_length = MIN_MATCH-1; |
||||
s->strstart++; |
||||
|
||||
if (bflush) FLUSH_BLOCK(s, 0); |
||||
|
||||
} else if (s->match_available) { |
||||
/* If there was no match at the previous position, output a
|
||||
* single literal. If there was a match but the current match |
||||
* is longer, truncate the previous match to a single literal. |
||||
*/ |
||||
Tracevv((stderr,"%c", s->window[s->strstart-1])); |
||||
if (ct_tally (s, 0, s->window[s->strstart-1])) { |
||||
FLUSH_BLOCK_ONLY(s, 0); |
||||
} |
||||
s->strstart++; |
||||
s->lookahead--; |
||||
if (s->strm->avail_out == 0) return 1; |
||||
} else { |
||||
/* There is no previous match to compare with, wait for
|
||||
* the next step to decide. |
||||
*/ |
||||
s->match_available = 1; |
||||
s->strstart++; |
||||
s->lookahead--; |
||||
} |
||||
} |
||||
if (s->match_available) ct_tally (s, 0, s->window[s->strstart-1]); |
||||
|
||||
FLUSH_BLOCK(s, flush == Z_FINISH); |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,270 @@ |
||||
/* deflate.h -- internal compression state
|
||||
* Copyright (C) 1995 Jean-loup Gailly |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* $Id: deflate.h,v 1.3 1995/04/14 12:39:45 jloup Exp $ */ |
||||
|
||||
#include "zutil.h" |
||||
|
||||
/* ===========================================================================
|
||||
* Internal compression state. |
||||
*/ |
||||
|
||||
/* Data type */ |
||||
#define BINARY 0 |
||||
#define ASCII 1 |
||||
#define UNKNOWN 2 |
||||
|
||||
#define LENGTH_CODES 29 |
||||
/* number of length codes, not counting the special END_BLOCK code */ |
||||
|
||||
#define LITERALS 256 |
||||
/* number of literal bytes 0..255 */ |
||||
|
||||
#define L_CODES (LITERALS+1+LENGTH_CODES) |
||||
/* number of Literal or Length codes, including the END_BLOCK code */ |
||||
|
||||
#define D_CODES 30 |
||||
/* number of distance codes */ |
||||
|
||||
#define BL_CODES 19 |
||||
/* number of codes used to transfer the bit lengths */ |
||||
|
||||
#define HEAP_SIZE (2*L_CODES+1) |
||||
/* maximum heap size */ |
||||
|
||||
#define MAX_BITS 15 |
||||
/* All codes must not exceed MAX_BITS bits */ |
||||
|
||||
#define INIT_STATE 42 |
||||
#define BUSY_STATE 113 |
||||
#define FINISH_STATE 666 |
||||
/* Stream status */ |
||||
|
||||
|
||||
/* Data structure describing a single value and its code string. */ |
||||
typedef struct ct_data_s { |
||||
union { |
||||
ush freq; /* frequency count */ |
||||
ush code; /* bit string */ |
||||
} fc; |
||||
union { |
||||
ush dad; /* father node in Huffman tree */ |
||||
ush len; /* length of bit string */ |
||||
} dl; |
||||
} ct_data; |
||||
|
||||
#define Freq fc.freq |
||||
#define Code fc.code |
||||
#define Dad dl.dad |
||||
#define Len dl.len |
||||
|
||||
typedef struct static_tree_desc_s static_tree_desc; |
||||
|
||||
typedef struct tree_desc_s { |
||||
ct_data *dyn_tree; /* the dynamic tree */ |
||||
int max_code; /* largest code with non zero frequency */ |
||||
static_tree_desc *stat_desc; /* the corresponding static tree */ |
||||
} tree_desc; |
||||
|
||||
typedef ush Pos; |
||||
typedef unsigned IPos; |
||||
/* A Pos is an index in the character window. We use short instead of int to
|
||||
* save space in the various tables. IPos is used only for parameter passing. |
||||
*/ |
||||
|
||||
typedef struct internal_state { |
||||
z_stream *strm; /* pointer back to this zlib stream */ |
||||
int status; /* as the name implies */ |
||||
Byte *pending_buf; /* output still pending */ |
||||
Byte *pending_out; /* next pending byte to output to the stream */ |
||||
int pending; /* nb of bytes in the pending buffer */ |
||||
uLong adler; /* adler32 of uncompressed data */ |
||||
int noheader; /* suppress zlib header and adler32 */ |
||||
Byte data_type; /* UNKNOWN, BINARY or ASCII */ |
||||
Byte method; /* STORED (for zip only) or DEFLATED */ |
||||
|
||||
/* used by deflate.c: */ |
||||
|
||||
uInt w_size; /* LZ77 window size (32K by default) */ |
||||
uInt w_bits; /* log2(w_size) (8..16) */ |
||||
uInt w_mask; /* w_size - 1 */ |
||||
|
||||
Byte *window; |
||||
/* Sliding window. Input bytes are read into the second half of the window,
|
||||
* and move to the first half later to keep a dictionary of at least wSize |
||||
* bytes. With this organization, matches are limited to a distance of |
||||
* wSize-MAX_MATCH bytes, but this ensures that IO is always |
||||
* performed with a length multiple of the block size. Also, it limits |
||||
* the window size to 64K, which is quite useful on MSDOS. |
||||
* To do: use the user input buffer as sliding window. |
||||
*/ |
||||
|
||||
ulg window_size; |
||||
/* Actual size of window: 2*wSize, except when the user input buffer
|
||||
* is directly used as sliding window. |
||||
*/ |
||||
|
||||
Pos *prev; |
||||
/* Link to older string with same hash index. To limit the size of this
|
||||
* array to 64K, this link is maintained only for the last 32K strings. |
||||
* An index in this array is thus a window index modulo 32K. |
||||
*/ |
||||
|
||||
Pos *head; /* Heads of the hash chains or NIL. */ |
||||
|
||||
uInt ins_h; /* hash index of string to be inserted */ |
||||
uInt hash_size; /* number of elements in hash table */ |
||||
uInt hash_bits; /* log2(hash_size) */ |
||||
uInt hash_mask; /* hash_size-1 */ |
||||
|
||||
uInt hash_shift; |
||||
/* Number of bits by which ins_h must be shifted at each input
|
||||
* step. It must be such that after MIN_MATCH steps, the oldest |
||||
* byte no longer takes part in the hash key, that is: |
||||
* hash_shift * MIN_MATCH >= hash_bits |
||||
*/ |
||||
|
||||
long block_start; |
||||
/* Window position at the beginning of the current output block. Gets
|
||||
* negative when the window is moved backwards. |
||||
*/ |
||||
|
||||
uInt match_length; /* length of best match */ |
||||
IPos prev_match; /* previous match */ |
||||
int match_available; /* set if previous match exists */ |
||||
uInt strstart; /* start of string to insert */ |
||||
uInt match_start; /* start of matching string */ |
||||
uInt lookahead; /* number of valid bytes ahead in window */ |
||||
|
||||
uInt prev_length; |
||||
/* Length of the best match at previous step. Matches not greater than this
|
||||
* are discarded. This is used in the lazy match evaluation. |
||||
*/ |
||||
|
||||
uInt max_chain_length; |
||||
/* To speed up deflation, hash chains are never searched beyond this
|
||||
* length. A higher limit improves compression ratio but degrades the |
||||
* speed. |
||||
*/ |
||||
|
||||
uInt max_lazy_match; |
||||
/* Attempt to find a better match only when the current match is strictly
|
||||
* smaller than this value. This mechanism is used only for compression |
||||
* levels >= 4. |
||||
*/ |
||||
# define max_insert_length max_lazy_match |
||||
/* Insert new strings in the hash table only if the match length is not
|
||||
* greater than this length. This saves time but degrades compression. |
||||
* max_insert_length is used only for compression levels <= 3. |
||||
*/ |
||||
|
||||
int level; /* compression level (1..9) */ |
||||
int strategy; /* favor or force Huffman coding*/ |
||||
|
||||
uInt good_match; |
||||
/* Use a faster search when the previous match is longer than this */ |
||||
|
||||
int nice_match; /* Stop searching when current match exceeds this */ |
||||
|
||||
/* used by trees.c: */ |
||||
|
||||
ct_data dyn_ltree[HEAP_SIZE]; /* literal and length tree */ |
||||
ct_data dyn_dtree[2*D_CODES+1]; /* distance tree */ |
||||
ct_data bl_tree[2*BL_CODES+1]; /* Huffman tree for the bit lengths */ |
||||
|
||||
tree_desc l_desc; /* descriptor for literal tree */ |
||||
tree_desc d_desc; /* descriptor for distance tree */ |
||||
tree_desc bl_desc; /* descriptor for bit length tree */ |
||||
|
||||
ush bl_count[MAX_BITS+1]; |
||||
/* number of codes at each bit length for an optimal tree */ |
||||
|
||||
int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ |
||||
int heap_len; /* number of elements in the heap */ |
||||
int heap_max; /* element of largest frequency */ |
||||
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
|
||||
* The same heap array is used to build all trees. |
||||
*/ |
||||
|
||||
uch depth[2*L_CODES+1]; |
||||
/* Depth of each subtree used as tie breaker for trees of equal frequency
|
||||
*/ |
||||
|
||||
uch *l_buf; /* buffer for literals or lengths */ |
||||
|
||||
uInt lit_bufsize; |
||||
/* Size of match buffer for literals/lengths. There are 4 reasons for
|
||||
* limiting lit_bufsize to 64K: |
||||
* - frequencies can be kept in 16 bit counters |
||||
* - if compression is not successful for the first block, all input |
||||
* data is still in the window so we can still emit a stored block even |
||||
* when input comes from standard input. (This can also be done for |
||||
* all blocks if lit_bufsize is not greater than 32K.) |
||||
* - if compression is not successful for a file smaller than 64K, we can |
||||
* even emit a stored file instead of a stored block (saving 5 bytes). |
||||
* This is applicable only for zip (not gzip or zlib). |
||||
* - creating new Huffman trees less frequently may not provide fast |
||||
* adaptation to changes in the input data statistics. (Take for |
||||
* example a binary file with poorly compressible code followed by |
||||
* a highly compressible string table.) Smaller buffer sizes give |
||||
* fast adaptation but have of course the overhead of transmitting |
||||
* trees more frequently. |
||||
* - I can't count above 4 |
||||
*/ |
||||
|
||||
uInt last_lit; /* running index in l_buf */ |
||||
|
||||
ush *d_buf; |
||||
/* Buffer for distances. To simplify the code, d_buf and l_buf have
|
||||
* the same number of elements. To use different lengths, an extra flag |
||||
* array would be necessary. |
||||
*/ |
||||
|
||||
ulg opt_len; /* bit length of current block with optimal trees */ |
||||
ulg static_len; /* bit length of current block with static trees */ |
||||
ulg compressed_len; /* total bit length of compressed file */ |
||||
uInt matches; /* number of string matches in current block */ |
||||
|
||||
#ifdef DEBUG |
||||
ulg bits_sent; /* bit length of the compressed data */ |
||||
#endif |
||||
|
||||
ush bi_buf; |
||||
/* Output buffer. bits are inserted starting at the bottom (least
|
||||
* significant bits). |
||||
*/ |
||||
int bi_valid; |
||||
/* Number of valid bits in bi_buf. All bits above the last valid bit
|
||||
* are always zero. |
||||
*/ |
||||
|
||||
} deflate_state; |
||||
|
||||
|
||||
/* Output a byte on the stream.
|
||||
* IN assertion: there is enough room in pending_buf. |
||||
*/ |
||||
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} |
||||
|
||||
|
||||
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) |
||||
/* Minimum amount of lookahead, except at the end of the input file.
|
||||
* See deflate.c for comments about the MIN_MATCH+1. |
||||
*/ |
||||
|
||||
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) |
||||
/* In order to simplify the code, particularly on 16 bit machines, match
|
||||
* distances are limited to MAX_DIST instead of WSIZE. |
||||
*/ |
||||
|
||||
/* in trees.c */ |
||||
void ct_init __P((deflate_state *s)); |
||||
int ct_tally __P((deflate_state *s, int dist, int lc)); |
||||
ulg ct_flush_block __P((deflate_state *s, char *buf, ulg stored_len, int eof)); |
||||
@ -0,0 +1,201 @@ |
||||
/* example.c -- usage example of the zlib compression library
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: example.c,v 1.4 1995/04/14 13:32:49 jloup Exp $ */ |
||||
|
||||
#include <stdio.h> |
||||
#include "zlib.h" |
||||
|
||||
#define BUFLEN 4096 |
||||
|
||||
#define local static |
||||
/* For MSDOS and other systems with limitation on stack size. For Unix,
|
||||
#define local |
||||
works also. |
||||
*/ |
||||
|
||||
#define CHECK_ERR(err, msg) { \ |
||||
if (err != Z_OK) { \
|
||||
fprintf(stderr, "%s error: %d\n", msg, err); \
|
||||
exit(1); \
|
||||
} \
|
||||
} |
||||
|
||||
char *hello = "hello world"; |
||||
|
||||
/* ===========================================================================
|
||||
* Test compress() and uncompress() |
||||
*/ |
||||
void test_compress() |
||||
{ |
||||
local Byte compr[BUFLEN]; |
||||
uLong comprLen = sizeof(compr); |
||||
local Byte uncompr[BUFLEN]; |
||||
uLong uncomprLen = sizeof(uncompr); |
||||
int err; |
||||
uLong len = strlen(hello)+1; |
||||
|
||||
err = compress(compr, &comprLen, hello, len); |
||||
CHECK_ERR(err, "compress"); |
||||
|
||||
strcpy(uncompr, "garbage"); |
||||
|
||||
err = uncompress(uncompr, &uncomprLen, compr, comprLen); |
||||
CHECK_ERR(err, "uncompress"); |
||||
|
||||
if (strcmp(uncompr, hello)) { |
||||
fprintf(stderr, "bad uncompress\n"); |
||||
} else { |
||||
printf("uncompress(): %s\n", uncompr); |
||||
} |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Test read/write of .gz files |
||||
*/ |
||||
void test_gzio(out, in) |
||||
char *out; /* output file */ |
||||
char *in; /* input file */ |
||||
{ |
||||
local Byte uncompr[BUFLEN]; |
||||
uLong uncomprLen = sizeof(uncompr); |
||||
int err; |
||||
int len = strlen(hello)+1; |
||||
gzFile file; |
||||
|
||||
file = gzopen(out, "wb"); |
||||
if (file == NULL) { |
||||
fprintf(stderr, "gzopen error\n"); |
||||
exit(1); |
||||
} |
||||
|
||||
if (gzwrite(file, hello, len) != len) { |
||||
fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err)); |
||||
} |
||||
gzclose(file); |
||||
|
||||
file = gzopen(in, "rb"); |
||||
if (file == NULL) { |
||||
fprintf(stderr, "gzopen error\n"); |
||||
} |
||||
strcpy(uncompr, "garbage"); |
||||
|
||||
uncomprLen = gzread(file, uncompr, uncomprLen); |
||||
if (uncomprLen != len) { |
||||
fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); |
||||
} |
||||
gzclose(file); |
||||
|
||||
if (strcmp(uncompr, hello)) { |
||||
fprintf(stderr, "bad gzread\n"); |
||||
} else { |
||||
printf("gzread(): %s\n", uncompr); |
||||
} |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Test deflate() with small buffers, return the compressed length. |
||||
*/ |
||||
uLong test_deflate(compr) |
||||
Byte compr[]; |
||||
{ |
||||
z_stream c_stream; /* compression stream */ |
||||
int err; |
||||
int len = strlen(hello)+1; |
||||
|
||||
c_stream.zalloc = (alloc_func)0; |
||||
c_stream.zfree = (free_func)0; |
||||
|
||||
err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION); |
||||
CHECK_ERR(err, "deflateInit"); |
||||
|
||||
c_stream.next_in = (Byte*)hello; |
||||
c_stream.next_out = compr; |
||||
|
||||
while (c_stream.total_in != len) { |
||||
c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ |
||||
err = deflate(&c_stream, Z_NO_FLUSH); |
||||
CHECK_ERR(err, "deflate"); |
||||
} |
||||
/* Finish the stream, still forcing small buffers: */ |
||||
do { |
||||
c_stream.avail_out = 1; |
||||
err = deflate(&c_stream, Z_FINISH); |
||||
CHECK_ERR(err, "deflate"); |
||||
} while (c_stream.avail_out == 0); |
||||
|
||||
err = deflateEnd(&c_stream); |
||||
CHECK_ERR(err, "deflateEnd"); |
||||
|
||||
return c_stream.total_out; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Test inflate() with small buffers |
||||
*/ |
||||
void test_inflate(compr) |
||||
Byte compr[]; |
||||
{ |
||||
local Byte uncompr[BUFLEN]; |
||||
int err; |
||||
z_stream d_stream; /* decompression stream */ |
||||
|
||||
strcpy(uncompr, "garbage"); |
||||
|
||||
d_stream.zalloc = (alloc_func)0; |
||||
d_stream.zfree = (free_func)0; |
||||
|
||||
err = inflateInit(&d_stream); |
||||
CHECK_ERR(err, "inflateInit"); |
||||
|
||||
d_stream.next_in = compr; |
||||
d_stream.next_out = uncompr; |
||||
|
||||
for (;;) { |
||||
d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ |
||||
err = inflate(&d_stream, Z_NO_FLUSH); |
||||
if (err == Z_STREAM_END) break; |
||||
CHECK_ERR(err, "inflate"); |
||||
} |
||||
|
||||
err = inflateEnd(&d_stream); |
||||
CHECK_ERR(err, "inflateEnd"); |
||||
|
||||
if (strcmp(uncompr, hello)) { |
||||
fprintf(stderr, "bad inflate\n"); |
||||
} else { |
||||
printf("inflate(): %s\n", uncompr); |
||||
} |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Usage: example [output.gz [input.gz]] |
||||
*/ |
||||
|
||||
void main(argc, argv) |
||||
int argc; |
||||
char *argv[]; |
||||
{ |
||||
local Byte compr[BUFLEN]; |
||||
uLong comprLen; |
||||
|
||||
if (zlib_version[0] != ZLIB_VERSION[0]) { |
||||
fprintf(stderr, "incompatible zlib version\n"); |
||||
exit(1); |
||||
|
||||
} else if (strcmp(zlib_version, ZLIB_VERSION) != 0) { |
||||
fprintf(stderr, "warning: different zlib version\n"); |
||||
} |
||||
test_compress(); |
||||
|
||||
test_gzio((argc > 1 ? argv[1] : "foo.gz"), |
||||
(argc > 2 ? argv[2] : "foo.gz")); |
||||
|
||||
comprLen = test_deflate(compr); |
||||
|
||||
test_inflate(compr); |
||||
|
||||
exit(0); |
||||
} |
||||
@ -0,0 +1,459 @@ |
||||
/* gzio.c -- IO on .gz files
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
/* $Id: gzio.c,v 1.4 1995/04/14 14:50:52 jloup Exp $ */ |
||||
|
||||
#include <stdio.h> |
||||
|
||||
#include "zutil.h" |
||||
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */ |
||||
|
||||
#define Z_BUFSIZE 4096 |
||||
|
||||
#define ALLOC(size) zcalloc((voidp)0, 1, size) |
||||
#define TRYFREE(p) {if (p) zcfree((voidp)0, p);} |
||||
|
||||
#define GZ_MAGIC_1 0x1f |
||||
#define GZ_MAGIC_2 0x8b |
||||
|
||||
/* gzip flag byte */ |
||||
#define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ |
||||
#define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ |
||||
#define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ |
||||
#define ORIG_NAME 0x08 /* bit 3 set: original file name present */ |
||||
#define COMMENT 0x10 /* bit 4 set: file comment present */ |
||||
#define RESERVED 0xE0 /* bits 5..7: reserved */ |
||||
|
||||
#ifndef SEEK_CUR |
||||
# define SEEK_CUR 1 |
||||
#endif |
||||
|
||||
typedef struct gz_stream { |
||||
z_stream stream; |
||||
int z_err; /* error code for last stream operation */ |
||||
int z_eof; /* set if end of input file */ |
||||
FILE *file; /* .gz file */ |
||||
Byte *inbuf; /* input buffer */ |
||||
Byte *outbuf; /* output buffer */ |
||||
uLong crc; /* crc32 of uncompressed data */ |
||||
char *msg; /* error message */ |
||||
char *path; /* path name for debugging only */ |
||||
int transparent; /* 1 if input file is not a .gz file */ |
||||
char mode; /* 'w' or 'r' */ |
||||
} gz_stream; |
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* Cleanup then free the given gz_stream. Return a zlib error code. |
||||
*/ |
||||
local int destroy (s) |
||||
gz_stream *s; |
||||
{ |
||||
int err = Z_OK; |
||||
|
||||
if (!s) return Z_STREAM_ERROR; |
||||
|
||||
TRYFREE(s->inbuf); |
||||
TRYFREE(s->outbuf); |
||||
TRYFREE(s->path); |
||||
TRYFREE(s->msg); |
||||
|
||||
if (s->stream.state != NULL) { |
||||
if (s->mode == 'w') { |
||||
err = deflateEnd(&(s->stream)); |
||||
} else if (s->mode == 'r') { |
||||
err = inflateEnd(&(s->stream)); |
||||
} |
||||
} |
||||
if (s->file != NULL && fclose(s->file)) { |
||||
err = Z_ERRNO; |
||||
} |
||||
zcfree((voidp)0, s); |
||||
return s->z_err < 0 ? s->z_err : err; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Opens a gzip (.gz) file for reading or writing. The mode parameter |
||||
is as in fopen ("rb" or "wb"). The file is given either by file descritor |
||||
or path name (if fd == -1). |
||||
gz_open return NULL if the file 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). |
||||
*/ |
||||
local gzFile gz_open (path, mode, fd) |
||||
char *path; |
||||
char *mode; |
||||
int fd; |
||||
{ |
||||
int err; |
||||
char *p = mode; |
||||
gz_stream *s = (gz_stream *)ALLOC(sizeof(gz_stream)); |
||||
|
||||
if (!s) return Z_NULL; |
||||
|
||||
s->stream.zalloc = (alloc_func)0; |
||||
s->stream.zfree = (free_func)0; |
||||
s->stream.next_in = s->inbuf = Z_NULL; |
||||
s->stream.next_out = s->outbuf = Z_NULL; |
||||
s->stream.avail_in = s->stream.avail_out = 0; |
||||
s->file = NULL; |
||||
s->z_err = Z_OK; |
||||
s->z_eof = 0; |
||||
s->crc = crc32(0L, Z_NULL, 0); |
||||
s->msg = NULL; |
||||
s->transparent = 0; |
||||
|
||||
s->path = (char*)ALLOC(strlen(path)+1); |
||||
if (s->path == NULL) { |
||||
return destroy(s), (gzFile)Z_NULL; |
||||
} |
||||
strcpy(s->path, path); /* do this early for debugging */ |
||||
|
||||
s->mode = '\0'; |
||||
do { |
||||
if (*p == 'r') s->mode = 'r'; |
||||
if (*p == 'w') s->mode = 'w'; |
||||
} while (*p++); |
||||
if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; |
||||
|
||||
if (s->mode == 'w') { |
||||
err = deflateInit2(&(s->stream), Z_DEFAULT_COMPRESSION, |
||||
DEFLATED, -WBITS, MEM_LEVEL, 0); |
||||
/* windowBits is passed < 0 to suppress zlib header */ |
||||
|
||||
s->stream.next_out = s->outbuf = ALLOC(Z_BUFSIZE); |
||||
|
||||
if (err != Z_OK || s->outbuf == Z_NULL) { |
||||
return destroy(s), (gzFile)Z_NULL; |
||||
} |
||||
} else { |
||||
err = inflateInit2(&(s->stream), -WBITS); |
||||
s->stream.next_in = s->inbuf = ALLOC(Z_BUFSIZE); |
||||
|
||||
if (err != Z_OK || s->inbuf == Z_NULL) { |
||||
return destroy(s), (gzFile)Z_NULL; |
||||
} |
||||
} |
||||
s->stream.avail_out = Z_BUFSIZE; |
||||
|
||||
errno = 0; |
||||
s->file = fd < 0 ? FOPEN(path, mode) : fdopen(fd, mode); |
||||
|
||||
if (s->file == NULL) { |
||||
return destroy(s), (gzFile)Z_NULL; |
||||
} |
||||
if (s->mode == 'w') { |
||||
/* Write a very simple .gz header:
|
||||
*/ |
||||
fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2, |
||||
DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); |
||||
} else { |
||||
/* Check and skip the header:
|
||||
*/ |
||||
Byte c1 = 0, c2 = 0; |
||||
Byte method = 0; |
||||
Byte flags = 0; |
||||
Byte xflags = 0; |
||||
Byte time[4]; |
||||
Byte osCode; |
||||
int c; |
||||
|
||||
s->stream.avail_in = fread(s->inbuf, 1, 2, s->file); |
||||
if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1 |
||||
|| s->inbuf[1] != GZ_MAGIC_2) { |
||||
s->transparent = 1; |
||||
return (gzFile)s; |
||||
} |
||||
s->stream.avail_in = 0; |
||||
fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode); |
||||
|
||||
if (method != DEFLATED || feof(s->file) || (flags & RESERVED) != 0) { |
||||
s->z_err = Z_DATA_ERROR; |
||||
return (gzFile)s; |
||||
} |
||||
if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ |
||||
long len; |
||||
fscanf(s->file, "%c%c", &c1, &c2); |
||||
len = c1 + ((long)c2<<8); |
||||
fseek(s->file, len, SEEK_CUR); |
||||
} |
||||
if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ |
||||
while ((c = getc(s->file)) != 0 && c != EOF) ; |
||||
} |
||||
if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ |
||||
while ((c = getc(s->file)) != 0 && c != EOF) ; |
||||
} |
||||
if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ |
||||
fscanf(s->file, "%c%c", &c1, &c2); |
||||
} |
||||
if (feof(s->file)) { |
||||
s->z_err = Z_DATA_ERROR; |
||||
} |
||||
} |
||||
return (gzFile)s; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Opens a gzip (.gz) file for reading or writing. |
||||
*/ |
||||
gzFile gzopen (path, mode) |
||||
char *path; |
||||
char *mode; |
||||
{ |
||||
return gz_open (path, mode, -1); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Associate a gzFile with the file descriptor fd. |
||||
*/ |
||||
gzFile gzdopen (fd, mode) |
||||
int fd; |
||||
char *mode; |
||||
{ |
||||
char name[20]; |
||||
sprintf(name, "_fd:%d_", fd); /* for debugging */ |
||||
|
||||
return gz_open (name, mode, fd); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Reads the given number of uncompressed bytes from the compressed file. |
||||
gzread returns the number of bytes actually read (0 for end of file). |
||||
*/ |
||||
int gzread (file, buf, len) |
||||
gzFile file; |
||||
voidp buf; |
||||
unsigned len; |
||||
{ |
||||
gz_stream *s = (gz_stream*)file; |
||||
|
||||
if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; |
||||
|
||||
if (s->transparent) { |
||||
unsigned n = 0; |
||||
/* Copy the first two (non-magic) bytes if not done already */ |
||||
while (s->stream.avail_in > 0 && len > 0) { |
||||
*((Byte*)buf)++ = *s->stream.next_in++; |
||||
s->stream.avail_in--; |
||||
len--; n++; |
||||
} |
||||
if (len == 0) return n; |
||||
return n + fread(buf, 1, len, s->file); |
||||
} |
||||
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 */ |
||||
|
||||
s->stream.next_out = buf; |
||||
s->stream.avail_out = len; |
||||
|
||||
while (s->stream.avail_out != 0) { |
||||
|
||||
if (s->stream.avail_in == 0 && !s->z_eof) { |
||||
|
||||
errno = 0; |
||||
s->stream.avail_in = |
||||
fread(s->inbuf, 1, Z_BUFSIZE, s->file); |
||||
if (s->stream.avail_in == 0) { |
||||
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; |
||||
} |
||||
s->stream.next_in = s->inbuf; |
||||
} |
||||
s->z_err = inflate(&(s->stream), Z_NO_FLUSH); |
||||
|
||||
if (s->z_err == Z_STREAM_END || |
||||
s->z_err != Z_OK || s->z_eof) break; |
||||
} |
||||
len -= s->stream.avail_out; |
||||
s->crc = crc32(s->crc, buf, len); |
||||
return 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). |
||||
*/ |
||||
int gzwrite (file, buf, len) |
||||
gzFile file; |
||||
voidp buf; |
||||
unsigned len; |
||||
{ |
||||
gz_stream *s = (gz_stream*)file; |
||||
|
||||
if (s == NULL || s->mode != 'w') return Z_STREAM_ERROR; |
||||
|
||||
s->stream.next_in = buf; |
||||
s->stream.avail_in = len; |
||||
|
||||
while (s->stream.avail_in != 0) { |
||||
|
||||
if (s->stream.avail_out == 0) { |
||||
|
||||
s->stream.next_out = s->outbuf; |
||||
if (fwrite(s->outbuf, 1, Z_BUFSIZE, s->file) != Z_BUFSIZE) { |
||||
s->z_err = Z_ERRNO; |
||||
break; |
||||
} |
||||
s->stream.avail_out = Z_BUFSIZE; |
||||
} |
||||
s->z_err = deflate(&(s->stream), Z_NO_FLUSH); |
||||
|
||||
if (s->z_err != Z_OK) break; |
||||
} |
||||
s->crc = crc32(s->crc, buf, len); |
||||
|
||||
return len - s->stream.avail_in; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Flushes all pending output into the compressed file. The parameter |
||||
flush is as in the deflate() function. |
||||
gzflush should be called only when strictly necessary because it can |
||||
degrade compression. |
||||
*/ |
||||
int gzflush (file, flush) |
||||
gzFile file; |
||||
int flush; |
||||
{ |
||||
uInt len; |
||||
int done = 0; |
||||
gz_stream *s = (gz_stream*)file; |
||||
|
||||
if (s == NULL || s->mode != 'w') 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) { |
||||
s->z_err = Z_ERRNO; |
||||
break; |
||||
} |
||||
s->stream.next_out = s->outbuf; |
||||
s->stream.avail_out = Z_BUFSIZE; |
||||
} |
||||
if (done) break; |
||||
s->z_err = deflate(&(s->stream), flush); |
||||
|
||||
if (s->z_err != Z_OK) break; |
||||
|
||||
/* 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); |
||||
} |
||||
return s->z_err; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Outputs a long in LSB order to the given file |
||||
*/ |
||||
local void putLong (file, x) |
||||
FILE *file; |
||||
uLong x; |
||||
{ |
||||
int n; |
||||
for (n = 0; n < 4; n++) { |
||||
fputc(x & 0xff, file); |
||||
x >>= 8; |
||||
} |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Reads a long in LSB order from the given buffer |
||||
*/ |
||||
local uLong getLong (buf) |
||||
Byte *buf; |
||||
{ |
||||
uLong x = 0; |
||||
Byte *p = buf+4; |
||||
|
||||
do { |
||||
x <<= 8; |
||||
x |= *--p;
|
||||
} while (p != buf); |
||||
return x; |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Flushes all pending output if necessary, closes the compressed file |
||||
and deallocates all the (de)compression state. |
||||
*/ |
||||
int gzclose (file) |
||||
gzFile file; |
||||
{ |
||||
uInt n; |
||||
gz_stream *s = (gz_stream*)file; |
||||
|
||||
if (s == NULL) return Z_STREAM_ERROR; |
||||
|
||||
if (s->mode == 'w') { |
||||
gzflush (file, Z_FINISH); |
||||
putLong (s->file, s->crc); |
||||
putLong (s->file, s->stream.total_in); |
||||
|
||||
} 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); |
||||
s->stream.next_in = s->inbuf; |
||||
} |
||||
/* check CRC and original size */ |
||||
if (n < 8 || |
||||
getLong(s->stream.next_in) != s->crc || |
||||
getLong(s->stream.next_in + 4) != s->stream.total_out) { |
||||
|
||||
s->z_err = Z_DATA_ERROR; |
||||
} |
||||
} |
||||
return destroy(file); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
Returns the error message for the last error which occured on the |
||||
given compressed file. errnum is set to zlib error number. If an |
||||
error occured in the file system and not in the compression library, |
||||
errnum is set to Z_ERRNO and the application may consult errno |
||||
to get the exact error code. |
||||
*/ |
||||
char* gzerror (file, errnum) |
||||
gzFile file; |
||||
int *errnum; |
||||
{ |
||||
char *m; |
||||
gz_stream *s = (gz_stream*)file; |
||||
|
||||
if (s == NULL) { |
||||
*errnum = Z_STREAM_ERROR; |
||||
return z_errmsg[1-Z_STREAM_ERROR]; |
||||
} |
||||
*errnum = s->z_err; |
||||
if (*errnum == Z_OK) return ""; |
||||
|
||||
m = *errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg; |
||||
|
||||
if (m == NULL || *m == '\0') m = z_errmsg[1-s->z_err]; |
||||
|
||||
TRYFREE(s->msg); |
||||
s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3); |
||||
strcpy(s->msg, s->path); |
||||
strcat(s->msg, ": "); |
||||
strcat(s->msg, m); |
||||
return s->msg; |
||||
} |
||||
@ -0,0 +1,324 @@ |
||||
/* infblock.c -- interpret and process block types to last block
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "infblock.h" |
||||
#include "inftrees.h" |
||||
#include "infcodes.h" |
||||
#include "infutil.h" |
||||
|
||||
struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
||||
|
||||
/* Table for deflate from PKZIP's appnote.txt. */ |
||||
local uInt border[] = { /* Order of the bit length code lengths */ |
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; |
||||
|
||||
/*
|
||||
Notes beyond the 1.93a appnote.txt: |
||||
|
||||
1. Distance pointers never point before the beginning of the output |
||||
stream. |
||||
2. Distance pointers can point back across blocks, up to 32k away. |
||||
3. There is an implied maximum of 7 bits for the bit length table and |
||||
15 bits for the actual data. |
||||
4. If only one code exists, then it is encoded using one bit. (Zero |
||||
would be more efficient, but perhaps a little confusing.) If two |
||||
codes exist, they are coded using one bit each (0 and 1). |
||||
5. There is no way of sending zero distance codes--a dummy must be |
||||
sent if there are none. (History: a pre 2.0 version of PKZIP would |
||||
store blocks with no distance codes, but this was discovered to be |
||||
too harsh a criterion.) Valid only for 1.93a. 2.04c does allow |
||||
zero distance codes, which is sent as one code of zero bits in |
||||
length. |
||||
6. There are up to 286 literal/length codes. Code 256 represents the |
||||
end-of-block. Note however that the static length tree defines |
||||
288 codes just to fill out the Huffman codes. Codes 286 and 287 |
||||
cannot be used though, since there is no length base or extra bits |
||||
defined for them. Similarily, there are up to 30 distance codes. |
||||
However, static trees define 32 codes (all 5 bits) to fill out the |
||||
Huffman codes, but the last two had better not show up in the data. |
||||
7. Unzip can check dynamic Huffman blocks for complete code sets. |
||||
The exception is that a single code would not be complete (see #4). |
||||
8. The five bits following the block type is really the number of |
||||
literal codes sent minus 257. |
||||
9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits |
||||
(1+6+6). Therefore, to output three times the length, you output |
||||
three codes (1+1+1), whereas to output four times the same length, |
||||
you only need two codes (1+3). Hmm. |
||||
10. In the tree reconstruction algorithm, Code = Code + Increment |
||||
only if BitLength(i) is not zero. (Pretty obvious.) |
||||
11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) |
||||
12. Note: length code 284 can represent 227-258, but length code 285 |
||||
really is 258. The last length deserves its own, short code |
||||
since it gets used a lot in very redundant files. The length |
||||
258 is special since 258 - 3 (the min match length) is 255. |
||||
13. The literal/length and distance code bit lengths are read as a |
||||
single stream of lengths. It is possible (and advantageous) for |
||||
a repeat code (16, 17, or 18) to go across the boundary between |
||||
the two sets of lengths. |
||||
*/ |
||||
|
||||
struct inflate_blocks_state *inflate_blocks_new(z,wsize) |
||||
z_stream *z; |
||||
uInt wsize; |
||||
{ |
||||
struct inflate_blocks_state *s; |
||||
|
||||
if ((s = (struct inflate_blocks_state *)ZALLOC |
||||
(z,1,sizeof(struct inflate_blocks_state))) == Z_NULL) |
||||
return s; |
||||
if ((s->window = (Byte *)ZALLOC(z,1,wsize)) == Z_NULL) |
||||
{ |
||||
ZFREE(z, s); |
||||
return Z_NULL; |
||||
} |
||||
s->mode = TYPE; |
||||
s->bitk = 0; |
||||
s->read = s->write = s->window; |
||||
s->end = s->window + wsize; |
||||
s->check = 1; |
||||
return s; |
||||
} |
||||
|
||||
|
||||
int inflate_blocks(s, z, r) |
||||
struct inflate_blocks_state *s; |
||||
z_stream *z; |
||||
int r; |
||||
{ |
||||
uInt t; /* temporary storage */ |
||||
uLong b; /* bit buffer */ |
||||
uInt k; /* bits in bit buffer */ |
||||
Byte *p; /* input data pointer */ |
||||
uInt n; /* bytes available there */ |
||||
Byte *q; /* output window write pointer */ |
||||
uInt m; /* bytes to end of window or read pointer */ |
||||
|
||||
/* copy input/output information to locals (UPDATE macro restores) */ |
||||
LOAD |
||||
|
||||
/* process input based on current state */ |
||||
while (1) switch (s->mode) |
||||
{ |
||||
case TYPE: |
||||
NEEDBITS(3) |
||||
t = (uInt)b & 7; |
||||
s->last = t & 1; |
||||
switch (t >> 1) |
||||
{ |
||||
case 0: /* stored */ |
||||
DUMPBITS(3) |
||||
t = k & 7; /* go to byte boundary */ |
||||
DUMPBITS(t) |
||||
s->mode = LENS; /* get length of stored block */ |
||||
break; |
||||
case 1: /* fixed */ |
||||
{ |
||||
uInt bl, bd; |
||||
inflate_huft *tl, *td; |
||||
|
||||
inflate_trees_fixed(&bl, &bd, &tl, &td); |
||||
s->sub.codes = inflate_codes_new(bl, bd, tl, td, z); |
||||
if (s->sub.codes == Z_NULL) |
||||
{ |
||||
r = Z_MEM_ERROR; |
||||
LEAVE |
||||
} |
||||
} |
||||
DUMPBITS(3) |
||||
s->mode = CODES; |
||||
break; |
||||
case 2: /* dynamic */ |
||||
DUMPBITS(3) |
||||
s->mode = TABLE; |
||||
break; |
||||
case 3: /* illegal */ |
||||
DUMPBITS(3) |
||||
s->mode = ERROR; |
||||
z->msg = "invalid block type"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
break; |
||||
case LENS: |
||||
NEEDBITS(32) |
||||
if ((~b) >> 16 != (b & 0xffff)) |
||||
{ |
||||
s->mode = ERROR; |
||||
z->msg = "invalid stored block lengths"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
k = 0; /* dump bits */ |
||||
s->sub.left = (uInt)b & 0xffff; |
||||
s->mode = s->sub.left ? STORED : TYPE; |
||||
break; |
||||
case STORED: |
||||
do { |
||||
NEEDBYTE |
||||
NEEDOUT |
||||
OUTBYTE(NEXTBYTE) |
||||
} while (--s->sub.left); |
||||
s->mode = s->last ? DRY : TYPE; |
||||
break; |
||||
case TABLE: |
||||
NEEDBITS(14) |
||||
s->sub.trees.table = t = (uInt)b & 0x3fff; |
||||
#ifndef PKZIP_BUG_WORKAROUND |
||||
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) |
||||
{ |
||||
s->mode = ERROR; |
||||
z->msg = "too many length or distance symbols"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
#endif |
||||
t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f); |
||||
if (t < 19) |
||||
t = 19; |
||||
if ((s->sub.trees.blens = (uInt*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL) |
||||
{ |
||||
r = Z_MEM_ERROR; |
||||
LEAVE |
||||
} |
||||
DUMPBITS(14) |
||||
s->sub.trees.index = 0; |
||||
s->mode = BTREE; |
||||
case BTREE: |
||||
while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10)) |
||||
{ |
||||
NEEDBITS(3) |
||||
s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7; |
||||
DUMPBITS(3) |
||||
} |
||||
while (s->sub.trees.index < 19) |
||||
s->sub.trees.blens[border[s->sub.trees.index++]] = 0; |
||||
s->sub.trees.bb = 7; |
||||
t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb, |
||||
&s->sub.trees.tb, z); |
||||
if (t != Z_OK) |
||||
{ |
||||
r = t; |
||||
if (r == Z_DATA_ERROR) |
||||
s->mode = ERROR; |
||||
LEAVE |
||||
} |
||||
s->sub.trees.index = 0; |
||||
s->mode = DTREE; |
||||
case DTREE: |
||||
while (t = s->sub.trees.table, |
||||
s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)) |
||||
{ |
||||
inflate_huft *h; |
||||
uInt i, j, c; |
||||
|
||||
t = s->sub.trees.bb; |
||||
NEEDBITS(t) |
||||
h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]); |
||||
t = h->word.what.Bits; |
||||
c = h->more.Base; |
||||
if (c < 16) |
||||
{ |
||||
DUMPBITS(t) |
||||
s->sub.trees.blens[s->sub.trees.index++] = c; |
||||
} |
||||
else /* c == 16..18 */ |
||||
{ |
||||
i = c == 18 ? 7 : c - 14; |
||||
j = c == 18 ? 11 : 3; |
||||
NEEDBITS(t + i) |
||||
DUMPBITS(t) |
||||
j += (uInt)b & inflate_mask[i]; |
||||
DUMPBITS(i) |
||||
i = s->sub.trees.index; |
||||
t = s->sub.trees.table; |
||||
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || |
||||
(c == 16 && i < 1)) |
||||
{ |
||||
s->mode = ERROR; |
||||
z->msg = "invalid bit length repeat"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
c = c == 16 ? s->sub.trees.blens[i - 1] : 0; |
||||
do { |
||||
s->sub.trees.blens[i++] = c; |
||||
} while (--j); |
||||
s->sub.trees.index = i; |
||||
} |
||||
} |
||||
inflate_trees_free(s->sub.trees.tb, z); |
||||
s->sub.trees.tb = Z_NULL; |
||||
{ |
||||
uInt bl, bd; |
||||
inflate_huft *tl, *td; |
||||
struct inflate_codes_state *c; |
||||
|
||||
bl = 9; |
||||
bd = 6; |
||||
t = s->sub.trees.table; |
||||
t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), |
||||
s->sub.trees.blens, &bl, &bd, &tl, &td, z); |
||||
if (t != Z_OK) |
||||
{ |
||||
if (t == (uInt)Z_DATA_ERROR) |
||||
s->mode = ERROR; |
||||
r = t; |
||||
LEAVE |
||||
} |
||||
if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) |
||||
{ |
||||
inflate_trees_free(td, z); |
||||
inflate_trees_free(tl, z); |
||||
r = Z_MEM_ERROR; |
||||
LEAVE |
||||
} |
||||
ZFREE(z, s->sub.trees.blens); |
||||
s->sub.codes = c; |
||||
} |
||||
s->mode = CODES; |
||||
case CODES: |
||||
UPDATE |
||||
if ((r = inflate_codes(s, z, r)) != Z_STREAM_END) |
||||
return inflate_flush(s, z, r); |
||||
r = Z_OK; |
||||
inflate_codes_free(s->sub.codes, z); |
||||
LOAD |
||||
s->mode = s->last ? DRY : TYPE; |
||||
break; |
||||
case DRY: |
||||
FLUSH |
||||
if (s->read != s->write) |
||||
LEAVE |
||||
s->mode = DONE; |
||||
case DONE: |
||||
r = Z_STREAM_END; |
||||
LEAVE |
||||
case ERROR: |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
default: |
||||
r = Z_STREAM_ERROR; |
||||
LEAVE |
||||
} |
||||
} |
||||
|
||||
|
||||
int inflate_blocks_free(s, z, c, e) |
||||
struct inflate_blocks_state *s; |
||||
z_stream *z; |
||||
uLong *c; |
||||
int *e; |
||||
{ |
||||
*e = s->bitk > 7 ? (s->bitb >> (s->bitk & 7)) & 0xff : -1; |
||||
*c = s->check; |
||||
if (s->mode == BTREE || s->mode == DTREE) |
||||
ZFREE(z, s->sub.trees.blens); |
||||
if (s->mode == CODES) |
||||
inflate_codes_free(s->sub.codes, z); |
||||
ZFREE(z, s->window); |
||||
ZFREE(z, s); |
||||
return Z_OK; |
||||
} |
||||
@ -0,0 +1,26 @@ |
||||
/* infblock.h -- header to use infblock.c
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
struct inflate_blocks_state; |
||||
|
||||
extern struct inflate_blocks_state * inflate_blocks_new __P(( |
||||
z_stream *, |
||||
uInt)); /* window size */ |
||||
|
||||
extern int inflate_blocks __P(( |
||||
struct inflate_blocks_state *, |
||||
z_stream *, |
||||
int)); /* initial return code */ |
||||
|
||||
extern int inflate_blocks_free __P(( |
||||
struct inflate_blocks_state *, |
||||
z_stream *, |
||||
uLong *, /* check value on output */ |
||||
int *)); /* possible leftover byte to return */ |
||||
@ -0,0 +1,217 @@ |
||||
/* infcodes.c -- process literals and length/distance pairs
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "inftrees.h" |
||||
#include "infutil.h" |
||||
#include "infcodes.h" |
||||
|
||||
/* simplify the use of the inflate_huft type with some defines */ |
||||
#define base more.Base |
||||
#define next more.Next |
||||
#define exop word.what.Exop |
||||
#define bits word.what.Bits |
||||
|
||||
/* inflate codes private state */ |
||||
struct inflate_codes_state { |
||||
|
||||
/* mode */ |
||||
enum { /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
||||
START, /* x: set up for LEN */ |
||||
LEN, /* i: get length/literal/eob next */ |
||||
LENEXT, /* i: getting length extra (have base) */ |
||||
DIST, /* i: get distance next */ |
||||
DISTEXT, /* i: getting distance extra */ |
||||
COPY, /* o: copying bytes in window, waiting for space */ |
||||
LIT, /* o: got literal, waiting for output space */ |
||||
WASH, /* o: got eob, possibly still output waiting */ |
||||
END, /* x: got eob and all data flushed */ |
||||
BAD} /* x: got error */ |
||||
mode; /* current inflate_codes mode */ |
||||
|
||||
/* mode dependent information */ |
||||
uInt len; |
||||
union { |
||||
struct { |
||||
inflate_huft *tree; /* pointer into tree */ |
||||
uInt need; /* bits needed */ |
||||
} code; /* if LEN or DIST, where in tree */ |
||||
uInt lit; /* if LIT, literal */ |
||||
struct { |
||||
uInt get; /* bits to get for extra */ |
||||
uInt dist; /* distance back to copy from */ |
||||
} copy; /* if EXT or COPY, where and how much */ |
||||
} sub; /* submode */ |
||||
|
||||
/* mode independent information */ |
||||
Byte lbits; /* ltree bits decoded per branch */ |
||||
Byte dbits; /* dtree bits decoder per branch */ |
||||
inflate_huft *ltree; /* literal/length/eob tree */ |
||||
inflate_huft *dtree; /* distance tree */ |
||||
|
||||
}; |
||||
|
||||
|
||||
struct inflate_codes_state *inflate_codes_new(bl, bd, tl, td, z) |
||||
uInt bl, bd; |
||||
inflate_huft *tl, *td; |
||||
z_stream *z; |
||||
{ |
||||
struct inflate_codes_state *c; |
||||
|
||||
if ((c = (struct inflate_codes_state *) |
||||
ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL) |
||||
{ |
||||
c->mode = START; |
||||
c->lbits = (Byte)bl; |
||||
c->dbits = (Byte)bd; |
||||
c->ltree = tl; |
||||
c->dtree = td; |
||||
} |
||||
return c; |
||||
} |
||||
|
||||
|
||||
int inflate_codes(s, z, r) |
||||
struct inflate_blocks_state *s; |
||||
z_stream *z; |
||||
int r; |
||||
{ |
||||
uInt j; /* temporary storage */ |
||||
inflate_huft *t; /* temporary pointer */ |
||||
int e; /* extra bits or operation */ |
||||
uLong b; /* bit buffer */ |
||||
uInt k; /* bits in bit buffer */ |
||||
Byte *p; /* input data pointer */ |
||||
uInt n; /* bytes available there */ |
||||
Byte *q; /* output window write pointer */ |
||||
uInt m; /* bytes to end of window or read pointer */ |
||||
Byte *f; /* pointer to copy strings from */ |
||||
struct inflate_codes_state *c = s->sub.codes; /* codes state */ |
||||
|
||||
/* copy input/output information to locals (UPDATE macro restores) */ |
||||
LOAD |
||||
|
||||
/* process input and output based on current state */ |
||||
while (1) switch (c->mode) |
||||
{ /* waiting for "i:"=input, "o:"=output, "x:"=nothing */ |
||||
case START: /* x: set up for LEN */ |
||||
/* %%% check for avail in and out to do fast loop %%% */ |
||||
c->sub.code.need = c->lbits; |
||||
c->sub.code.tree = c->ltree; |
||||
c->mode = LEN; |
||||
case LEN: /* i: get length/literal/eob next */ |
||||
j = c->sub.code.need; |
||||
NEEDBITS(j) |
||||
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); |
||||
DUMPBITS(t->bits) |
||||
if ((e = (int)(t->exop)) < 0) |
||||
{ |
||||
if (e == -128) /* invalid code */ |
||||
{ |
||||
c->mode = BAD; |
||||
z->msg = "invalid huffman code"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
e = -e; |
||||
if (e & 64) /* end of block */ |
||||
{ |
||||
c->mode = END; |
||||
break; |
||||
} |
||||
c->sub.code.need = e; |
||||
c->sub.code.tree = t->next; |
||||
break; |
||||
} |
||||
if (e & 16) /* literal */ |
||||
{ |
||||
c->sub.lit = t->base; |
||||
c->mode = LIT; |
||||
break; |
||||
} |
||||
c->sub.copy.get = e; |
||||
c->len = t->base; |
||||
c->mode = LENEXT; |
||||
case LENEXT: /* i: getting length extra (have base) */ |
||||
j = c->sub.copy.get; |
||||
NEEDBITS(j) |
||||
c->len += (uInt)b & inflate_mask[j]; |
||||
DUMPBITS(j) |
||||
c->sub.code.need = c->dbits; |
||||
c->sub.code.tree = c->dtree; |
||||
c->mode = DIST; |
||||
case DIST: /* i: get distance next */ |
||||
j = c->sub.code.need; |
||||
NEEDBITS(j) |
||||
t = c->sub.code.tree + ((uInt)b & inflate_mask[j]); |
||||
DUMPBITS(t->bits) |
||||
if ((e = (int)(t->exop)) < 0) |
||||
{ |
||||
if (e == -128) |
||||
{ |
||||
c->mode = BAD; |
||||
z->msg = "invalid huffman code"; |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
} |
||||
c->sub.code.need = -e; |
||||
c->sub.code.tree = t->next; |
||||
break; |
||||
} |
||||
c->sub.copy.dist = t->base; |
||||
c->sub.copy.get = e; |
||||
c->mode = DISTEXT; |
||||
case DISTEXT: /* i: getting distance extra */ |
||||
j = c->sub.copy.get; |
||||
NEEDBITS(j) |
||||
c->sub.copy.dist += (uInt)b & inflate_mask[j]; |
||||
DUMPBITS(j) |
||||
c->mode = COPY; |
||||
case COPY: /* o: copying bytes in window, waiting for space */ |
||||
f = q - s->window < c->sub.copy.dist ? |
||||
s->end - (c->sub.copy.dist - (q - s->window)) : |
||||
q - c->sub.copy.dist; |
||||
while (c->len) |
||||
{ |
||||
NEEDOUT |
||||
OUTBYTE(*f++) |
||||
if (f == s->end) |
||||
f = s->window; |
||||
c->len--; |
||||
} |
||||
c->mode = START; |
||||
break; |
||||
case LIT: /* o: got literal, waiting for output space */ |
||||
NEEDOUT |
||||
OUTBYTE(c->sub.lit) |
||||
c->mode = START; |
||||
break; |
||||
case WASH: /* o: got eob, possibly more output */ |
||||
FLUSH |
||||
if (s->read != s->write) |
||||
LEAVE |
||||
c->mode = END; |
||||
case END: |
||||
r = Z_STREAM_END; |
||||
LEAVE |
||||
case BAD: /* x: got error */ |
||||
r = Z_DATA_ERROR; |
||||
LEAVE |
||||
default: |
||||
r = Z_STREAM_ERROR; |
||||
LEAVE |
||||
} |
||||
} |
||||
|
||||
|
||||
void inflate_codes_free(c, z) |
||||
struct inflate_codes_state *c; |
||||
z_stream *z; |
||||
{ |
||||
inflate_trees_free(c->dtree, z); |
||||
inflate_trees_free(c->ltree, z); |
||||
ZFREE(z, c); |
||||
} |
||||
@ -0,0 +1,25 @@ |
||||
/* infcodes.h -- header to use infcodes.c
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
struct inflate_codes_state; |
||||
|
||||
extern struct inflate_codes_state *inflate_codes_new __P(( |
||||
uInt, uInt, |
||||
inflate_huft *, inflate_huft *, |
||||
z_stream *)); |
||||
|
||||
extern int inflate_codes __P(( |
||||
struct inflate_blocks_state *, |
||||
z_stream *, |
||||
int)); |
||||
|
||||
extern void inflate_codes_free __P(( |
||||
struct inflate_codes_state *, |
||||
z_stream *)); |
||||
@ -0,0 +1,221 @@ |
||||
/* inflate.c -- zlib interface to inflate modules
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "infblock.h" |
||||
|
||||
struct inflate_blocks_state {int dummy;}; /* for buggy compilers */ |
||||
|
||||
/* inflate private state */ |
||||
struct internal_state { |
||||
|
||||
/* mode */ |
||||
enum { |
||||
METHOD, /* waiting for method byte */ |
||||
FLAG, /* waiting for flag byte */ |
||||
START, /* make new blocks state */ |
||||
BLOCKS, /* decompressing blocks */ |
||||
CHECK4, /* four check bytes to go */ |
||||
CHECK3, /* three check bytes to go */ |
||||
CHECK2, /* two check bytes to go */ |
||||
CHECK1, /* one check byte to go */ |
||||
DONE, /* finished check, done */ |
||||
ERROR} /* got an error--stay here */ |
||||
mode; /* current inflate mode */ |
||||
|
||||
int no_header; |
||||
uInt w_size; /* LZ77 window size (32K by default) */ |
||||
uInt w_bits; /* log2(w_size) (8..16) */ |
||||
|
||||
/* mode dependent information */ |
||||
union { |
||||
uInt method; /* if FLAGS, method byte */ |
||||
struct inflate_blocks_state |
||||
*blocks; /* if BLOCKS, current state */ |
||||
struct { |
||||
uLong was; /* computed check value */ |
||||
uLong need; /* stream check value */ |
||||
} check; /* if CHECK, check values to compare */ |
||||
} sub; /* submode */ |
||||
}; |
||||
|
||||
|
||||
int inflateInit (strm) |
||||
z_stream *strm; |
||||
{ |
||||
return inflateInit2(strm, WBITS); |
||||
} |
||||
|
||||
int inflateInit2(z, windowBits) |
||||
z_stream *z; |
||||
int windowBits; |
||||
{ |
||||
if (z == Z_NULL) |
||||
return Z_STREAM_ERROR; |
||||
if (z->zalloc == Z_NULL) z->zalloc = zcalloc; |
||||
if (z->zfree == Z_NULL) z->zfree = zcfree; |
||||
z->total_in = z->total_out = 0; |
||||
z->msg = Z_NULL; |
||||
if ((z->state = (struct internal_state *) |
||||
ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL) |
||||
return Z_MEM_ERROR; |
||||
z->state->mode = METHOD; |
||||
|
||||
z->state->no_header = 0; |
||||
if (windowBits < 0) { /* undocumented feature: no zlib header */ |
||||
windowBits = - windowBits; |
||||
z->state->no_header = 1; |
||||
z->state->sub.method = DEFLATED; |
||||
z->state->mode = START; |
||||
} |
||||
if (windowBits < 8 || windowBits > 15) { |
||||
inflateEnd(z); |
||||
return Z_STREAM_ERROR; |
||||
} |
||||
z->state->w_bits = windowBits; |
||||
z->state->w_size = 1<<windowBits; |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++) |
||||
|
||||
int inflate(z, f) |
||||
z_stream *z; |
||||
int f; |
||||
{ |
||||
int r; |
||||
uInt b; |
||||
uLong c; |
||||
|
||||
if (z == Z_NULL || z->next_in == Z_NULL) |
||||
return Z_STREAM_ERROR; |
||||
r = Z_BUF_ERROR; |
||||
while (1) switch (z->state->mode) |
||||
{ |
||||
case METHOD: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
if (((z->state->sub.method = NEXTBYTE) & 0xf != DEFLATED)) |
||||
{ |
||||
z->state->mode = ERROR; |
||||
z->msg = "unknown compression method"; |
||||
return Z_DATA_ERROR; |
||||
} |
||||
if ((z->state->sub.method >> 4) > z->state->w_bits) |
||||
{ |
||||
z->state->mode = ERROR; |
||||
z->msg = "invalid window size"; |
||||
return Z_DATA_ERROR; |
||||
} |
||||
z->state->mode = FLAG; |
||||
case FLAG: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
if ((b = NEXTBYTE) & 0x20) |
||||
{ |
||||
z->state->mode = ERROR; |
||||
z->msg = "invalid reserved bit"; |
||||
return Z_DATA_ERROR; |
||||
} |
||||
if (((z->state->sub.method << 8) + b) % 31) |
||||
{ |
||||
z->state->mode = ERROR; |
||||
z->msg = "incorrect header check"; |
||||
return Z_DATA_ERROR; |
||||
} |
||||
z->state->mode = START; |
||||
case START: |
||||
if ((z->state->sub.blocks = inflate_blocks_new(z,z->state->w_size)) |
||||
== Z_NULL) |
||||
return Z_MEM_ERROR; |
||||
z->state->mode = BLOCKS; |
||||
case BLOCKS: |
||||
if ((r = inflate_blocks(z->state->sub.blocks, z, r)) != Z_STREAM_END) |
||||
return r; |
||||
inflate_blocks_free(z->state->sub.blocks, z, &c, &r); |
||||
if (z->state->no_header) { |
||||
z->state->mode = DONE; |
||||
return Z_STREAM_END; |
||||
} |
||||
z->state->sub.check.was = c; |
||||
if (r != -1) |
||||
{ |
||||
z->state->sub.check.need = (uLong)r << 24; |
||||
z->state->mode = CHECK3; |
||||
r = Z_OK; |
||||
break; |
||||
} |
||||
r = Z_OK; |
||||
z->state->mode = CHECK4; |
||||
case CHECK4: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
z->state->sub.check.need = (uLong)NEXTBYTE << 24; |
||||
z->state->mode = CHECK3; |
||||
case CHECK3: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
z->state->sub.check.need += (uLong)NEXTBYTE << 16; |
||||
z->state->mode = CHECK2; |
||||
case CHECK2: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
z->state->sub.check.need += (uLong)NEXTBYTE << 8; |
||||
z->state->mode = CHECK1; |
||||
case CHECK1: |
||||
if (z->avail_in == 0) return r; r = Z_OK; |
||||
z->state->sub.check.need += (uLong)NEXTBYTE; |
||||
if (z->state->sub.check.was != z->state->sub.check.need) |
||||
{ |
||||
z->state->mode = ERROR; |
||||
z->msg = "incorrect data check"; |
||||
return Z_DATA_ERROR; |
||||
} |
||||
z->state->mode = DONE; |
||||
case DONE: |
||||
return Z_STREAM_END; |
||||
case ERROR: |
||||
return Z_DATA_ERROR; |
||||
default: |
||||
return Z_STREAM_ERROR; |
||||
} |
||||
} |
||||
|
||||
|
||||
int inflateEnd(z) |
||||
z_stream *z; |
||||
{ |
||||
uLong c; |
||||
int e; |
||||
|
||||
if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL) |
||||
return Z_STREAM_ERROR; |
||||
if (z->state->mode == BLOCKS) |
||||
inflate_blocks_free(z->state->sub.blocks, z, &c, &e); |
||||
ZFREE(z, z->state); |
||||
z->state = Z_NULL; |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
/* inflateSync not implemented yet--this just consumes input */ |
||||
int inflateSync(z) |
||||
z_stream *z; |
||||
{ |
||||
if (z == Z_NULL) return Z_STREAM_ERROR; |
||||
if (z->avail_in == 0) return Z_BUF_ERROR; |
||||
do { |
||||
z->total_in++; |
||||
} while (--z->avail_in); |
||||
return Z_DATA_ERROR; |
||||
} |
||||
|
||||
|
||||
/* inflateReset not fully implemented yet--this frees and reallocates */ |
||||
int inflateReset(z) |
||||
z_stream *z; |
||||
{ |
||||
int r; |
||||
|
||||
if ((r = inflateEnd(z)) != Z_OK) |
||||
return r; |
||||
return inflateInit(z); |
||||
} |
||||
@ -0,0 +1,22 @@ |
||||
/* temporary kludge assuming single pass decompression */ |
||||
|
||||
/* $Id: inflate.h,v 1.2 1995/04/11 14:47:32 jloup Exp $ */ |
||||
|
||||
#include <stdio.h> |
||||
|
||||
#define NEXTBYTE \ |
||||
(istrm->total_in++, istrm->avail_in-- == 0 ? \
|
||||
(z_error("too small"), 0) : *istrm->next_in++) |
||||
|
||||
#define FLUSH(n) { \ |
||||
if (istrm->avail_out < n) z_error("too big"); \
|
||||
istrm->avail_out -= n; \
|
||||
memcpy(istrm->next_out, slide, n); \
|
||||
istrm->next_out += n; \
|
||||
istrm->total_out += n; \
|
||||
} |
||||
#define WSIZE istrm->state->w_size |
||||
#define slide istrm->state->window |
||||
#define memzero(a,s) memset((a),0,(s)) |
||||
#define inflate z_inflate |
||||
#define qflag 1 |
||||
@ -0,0 +1,67 @@ |
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include "zutil.h" |
||||
|
||||
/* This test is in honor of Ed Hamrick who suggested that the interface
|
||||
to inflate be a byte at a time--this implements that, and is, of course, |
||||
monumentally slow. It has the virtue though of stressing the push-pull |
||||
interface for testing purposes. */ |
||||
|
||||
void main() |
||||
{ |
||||
int a, r; |
||||
char c; |
||||
z_stream z; |
||||
|
||||
z.zalloc = Z_NULL; |
||||
z.zfree = Z_NULL; |
||||
r = inflateInit(&z); |
||||
if (r != Z_OK) |
||||
fprintf(stderr, "init error: %s\n", z_errmsg[1 - r]); |
||||
while ((a = getchar()) != EOF) |
||||
{ |
||||
/* feed one byte of input */ |
||||
z.avail_out = 0; |
||||
c = (char)a; |
||||
z.next_in = (Byte*)&c; |
||||
z.avail_in = 1; |
||||
r = inflate(&z, 0); |
||||
if (r == Z_STREAM_END) |
||||
break; |
||||
if (r != Z_OK) |
||||
{ |
||||
fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]); |
||||
break; |
||||
} |
||||
if (z.avail_in != 0) |
||||
{ |
||||
fprintf(stderr, "inflate didn't eat byte and didn't say buf err!\n"); |
||||
break; |
||||
} |
||||
|
||||
/* empty output one byte at a time */ |
||||
while (1) |
||||
{ |
||||
z.next_out = (Byte*)&c; |
||||
z.avail_out = 1; |
||||
r = inflate(&z, 0); |
||||
if (r == Z_STREAM_END) |
||||
break; |
||||
if (r != Z_OK && r != Z_BUF_ERROR) |
||||
{ |
||||
fprintf(stderr, "inflate error: %s\n", z_errmsg[1 - r]); |
||||
break; |
||||
} |
||||
if (z.avail_out == 0) |
||||
putchar(c); |
||||
else |
||||
break; |
||||
} |
||||
if (r != Z_OK && r != Z_BUF_ERROR) |
||||
break; |
||||
} |
||||
inflateEnd(&z); |
||||
fprintf(stderr, "%d bytes in, %d bytes out\n", z.total_in, z.total_out); |
||||
if (z.msg != NULL) |
||||
fprintf(stderr, "msg is <%s>\n", z.msg); |
||||
} |
||||
@ -0,0 +1,471 @@ |
||||
/* inftrees.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "inftrees.h" |
||||
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */ |
||||
|
||||
/* simplify the use of the inflate_huft type with some defines */ |
||||
#define base more.Base |
||||
#define next more.Next |
||||
#define exop word.what.Exop |
||||
#define bits word.what.Bits |
||||
|
||||
|
||||
local int huft_build __P(( |
||||
uInt *, /* code lengths in bits */ |
||||
uInt, /* number of codes */ |
||||
uInt, /* number of "simple" codes */ |
||||
uInt *, /* list of base values for non-simple codes */ |
||||
uInt *, /* list of extra bits for non-simple codes */ |
||||
inflate_huft **, /* result: starting table */ |
||||
uInt *, /* maximum lookup bits (returns actual) */ |
||||
z_stream *)); /* for zalloc function */ |
||||
|
||||
local voidp falloc __P(( |
||||
voidp, /* opaque pointer (not used) */ |
||||
uInt, /* number of items */ |
||||
uInt)); /* size of item */ |
||||
|
||||
local void ffree __P(( |
||||
voidp q, /* opaque pointer (not used) */ |
||||
voidp p)); /* what to free (not used) */ |
||||
|
||||
/* Tables for deflate from PKZIP's appnote.txt. */ |
||||
local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */ |
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, |
||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; |
||||
/* actually lengths - 2; also see note #13 above about 258 */ |
||||
local uInt cplext[] = { /* Extra bits for literal codes 257..285 */ |
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, |
||||
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 128, 128}; /* 128==invalid */ |
||||
local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */ |
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, |
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, |
||||
8193, 12289, 16385, 24577}; |
||||
local uInt cpdext[] = { /* Extra bits for distance codes */ |
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, |
||||
7, 7, 8, 8, 9, 9, 10, 10, 11, 11, |
||||
12, 12, 13, 13}; |
||||
|
||||
/*
|
||||
Huffman code decoding is performed using a multi-level table lookup. |
||||
The fastest way to decode is to simply build a lookup table whose |
||||
size is determined by the longest code. However, the time it takes |
||||
to build this table can also be a factor if the data being decoded |
||||
is not very long. The most common codes are necessarily the |
||||
shortest codes, so those codes dominate the decoding time, and hence |
||||
the speed. The idea is you can have a shorter table that decodes the |
||||
shorter, more probable codes, and then point to subsidiary tables for |
||||
the longer codes. The time it costs to decode the longer codes is |
||||
then traded against the time it takes to make longer tables. |
||||
|
||||
This results of this trade are in the variables lbits and dbits |
||||
below. lbits is the number of bits the first level table for literal/ |
||||
length codes can decode in one step, and dbits is the same thing for |
||||
the distance codes. Subsequent tables are also less than or equal to |
||||
those sizes. These values may be adjusted either when all of the |
||||
codes are shorter than that, in which case the longest code length in |
||||
bits is used, or when the shortest code is *longer* than the requested |
||||
table size, in which case the length of the shortest code in bits is |
||||
used. |
||||
|
||||
There are two different values for the two tables, since they code a |
||||
different number of possibilities each. The literal/length table |
||||
codes 286 possible values, or in a flat code, a little over eight |
||||
bits. The distance table codes 30 possible values, or a little less |
||||
than five bits, flat. The optimum values for speed end up being |
||||
about one bit more than those, so lbits is 8+1 and dbits is 5+1. |
||||
The optimum values may differ though from machine to machine, and |
||||
possibly even between compilers. Your mileage may vary. |
||||
*/ |
||||
|
||||
|
||||
/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */ |
||||
#define BMAX 15 /* maximum bit length of any code */ |
||||
#define N_MAX 288 /* maximum number of codes in any set */ |
||||
|
||||
#ifdef DEBUG |
||||
uInt inflate_hufts; |
||||
#endif |
||||
|
||||
local int huft_build(b, n, s, d, e, t, m, zs) |
||||
uInt *b; /* code lengths in bits (all assumed <= BMAX) */ |
||||
uInt n; /* number of codes (assumed <= N_MAX) */ |
||||
uInt s; /* number of simple-valued codes (0..s-1) */ |
||||
uInt *d; /* list of base values for non-simple codes */ |
||||
uInt *e; /* list of extra bits for non-simple codes */ |
||||
inflate_huft **t; /* result: starting table */ |
||||
uInt *m; /* maximum lookup bits, returns actual */ |
||||
z_stream *zs; /* for zalloc function */ |
||||
/* Given a list of code lengths and a maximum table size, make a set of
|
||||
tables to decode that set of codes. Return Z_OK on success, Z_BUF_ERROR |
||||
if the given code set is incomplete (the tables are still built in this |
||||
case), Z_DATA_ERROR if the input is invalid (all zero length codes or an |
||||
over-subscribed set of lengths), or Z_MEM_ERROR if not enough memory. */ |
||||
{ |
||||
uInt a; /* counter for codes of length k */ |
||||
uInt c[BMAX+1]; /* bit length count table */ |
||||
uInt f; /* i repeats in table every f entries */ |
||||
int g; /* maximum code length */ |
||||
int h; /* table level */ |
||||
register uInt i; /* counter, current code */ |
||||
register uInt j; /* counter */ |
||||
register int k; /* number of bits in current code */ |
||||
int l; /* bits per table (returned in m) */ |
||||
register uInt *p; /* pointer into c[], b[], or v[] */ |
||||
register inflate_huft *q; /* points to current table */ |
||||
inflate_huft r; /* table entry for structure assignment */ |
||||
inflate_huft *u[BMAX]; /* table stack */ |
||||
uInt v[N_MAX]; /* values in order of bit length */ |
||||
register int w; /* bits before this table == (l * h) */ |
||||
uInt x[BMAX+1]; /* bit offsets, then code stack */ |
||||
uInt *xp; /* pointer into x */ |
||||
int y; /* number of dummy codes added */ |
||||
uInt z; /* number of entries in current table */ |
||||
|
||||
|
||||
/* Generate counts for each bit length */ |
||||
p = c; |
||||
#define C0 *p++ = 0; |
||||
#define C2 C0 C0 C0 C0 |
||||
#define C4 C2 C2 C2 C2 |
||||
C4 /* clear c[]--assume BMAX+1 is 16 */ |
||||
p = b; i = n; |
||||
do { |
||||
c[*p++]++; /* assume all entries <= BMAX */ |
||||
} while (--i); |
||||
if (c[0] == n) /* null input--all zero length codes */ |
||||
{ |
||||
*t = (inflate_huft *)Z_NULL; |
||||
*m = 0; |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
/* Find minimum and maximum length, bound *m by those */ |
||||
l = *m; |
||||
for (j = 1; j <= BMAX; j++) |
||||
if (c[j]) |
||||
break; |
||||
k = j; /* minimum code length */ |
||||
if ((uInt)l < j) |
||||
l = j; |
||||
for (i = BMAX; i; i--) |
||||
if (c[i]) |
||||
break; |
||||
g = i; /* maximum code length */ |
||||
if ((uInt)l > i) |
||||
l = i; |
||||
*m = l; |
||||
|
||||
|
||||
/* Adjust last length count to fill out codes, if needed */ |
||||
for (y = 1 << j; j < i; j++, y <<= 1) |
||||
if ((y -= c[j]) < 0) |
||||
return Z_DATA_ERROR; |
||||
if ((y -= c[i]) < 0) |
||||
return Z_DATA_ERROR; |
||||
c[i] += y; |
||||
|
||||
|
||||
/* Generate starting offsets into the value table for each length */ |
||||
x[1] = j = 0; |
||||
p = c + 1; xp = x + 2; |
||||
while (--i) { /* note that i == g from above */ |
||||
*xp++ = (j += *p++); |
||||
} |
||||
|
||||
|
||||
/* Make a table of values in order of bit lengths */ |
||||
p = b; i = 0; |
||||
do { |
||||
if ((j = *p++) != 0) |
||||
v[x[j]++] = i; |
||||
} while (++i < n); |
||||
|
||||
|
||||
/* Generate the Huffman codes and for each, make the table entries */ |
||||
x[0] = i = 0; /* first Huffman code is zero */ |
||||
p = v; /* grab values in bit order */ |
||||
h = -1; /* no tables yet--level -1 */ |
||||
w = -l; /* bits decoded == (l * h) */ |
||||
u[0] = (inflate_huft *)Z_NULL; /* just to keep compilers happy */ |
||||
q = (inflate_huft *)Z_NULL; /* ditto */ |
||||
z = 0; /* ditto */ |
||||
|
||||
/* go through the bit lengths (k already is bits in shortest code) */ |
||||
for (; k <= g; k++) |
||||
{ |
||||
a = c[k]; |
||||
while (a--) |
||||
{ |
||||
/* here i is the Huffman code of length k bits for value *p */ |
||||
/* make tables up to required level */ |
||||
while (k > w + l) |
||||
{ |
||||
h++; |
||||
w += l; /* previous table always l bits */ |
||||
|
||||
/* compute minimum size table less than or equal to l bits */ |
||||
z = (z = g - w) > (uInt)l ? l : z; /* table size upper limit */ |
||||
if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ |
||||
{ /* too few codes for k-w bit table */ |
||||
f -= a + 1; /* deduct codes from patterns left */ |
||||
xp = c + k; |
||||
if (j < z) |
||||
while (++j < z) /* try smaller tables up to z bits */ |
||||
{ |
||||
if ((f <<= 1) <= *++xp) |
||||
break; /* enough codes to use up j bits */ |
||||
f -= *xp; /* else deduct codes from patterns */ |
||||
} |
||||
} |
||||
z = 1 << j; /* table entries for j-bit table */ |
||||
|
||||
/* allocate and link in new table */ |
||||
if ((q = (inflate_huft *)ZALLOC |
||||
(zs,z + 1,sizeof(inflate_huft))) == Z_NULL) |
||||
{ |
||||
if (h) |
||||
inflate_trees_free(u[0], zs); |
||||
return Z_MEM_ERROR; /* not enough memory */ |
||||
} |
||||
#ifdef DEBUG |
||||
inflate_hufts += z + 1; |
||||
#endif |
||||
*t = q + 1; /* link to list for huft_free() */ |
||||
*(t = &(q->next)) = (inflate_huft *)Z_NULL; |
||||
u[h] = ++q; /* table starts after link */ |
||||
|
||||
/* connect to last table, if there is one */ |
||||
if (h) |
||||
{ |
||||
x[h] = i; /* save pattern for backing up */ |
||||
r.bits = (char)l; /* bits to dump before this table */ |
||||
r.exop = (char)(-j); /* bits in this table */ |
||||
r.next = q; /* pointer to this table */ |
||||
j = i >> (w - l); /* (get around Turbo C bug) */ |
||||
u[h-1][j] = r; /* connect to last table */ |
||||
} |
||||
} |
||||
|
||||
/* set up table entry in r */ |
||||
r.bits = (char)(k - w); |
||||
if (p >= v + n) |
||||
r.exop = -128; /* out of values--invalid code */ |
||||
else if (*p < s) |
||||
{ |
||||
r.exop = (char)(*p < 256 ? 16 : -64); /* 256 is end-of-block code */ |
||||
r.base = *p++; /* simple code is just the value */ |
||||
} |
||||
else |
||||
{ |
||||
r.exop = (char)e[*p - s]; /* non-simple--look up in lists */ |
||||
r.base = d[*p++ - s]; |
||||
} |
||||
|
||||
/* fill code-like entries with r */ |
||||
f = 1 << (k - w); |
||||
for (j = i >> w; j < z; j += f) |
||||
q[j] = r; |
||||
|
||||
/* backwards increment the k-bit code i */ |
||||
for (j = 1 << (k - 1); i & j; j >>= 1) |
||||
i ^= j; |
||||
i ^= j; |
||||
|
||||
/* backup over finished tables */ |
||||
while ((i & ((1 << w) - 1)) != x[h]) |
||||
{ |
||||
h--; /* don't need to update q */ |
||||
w -= l; |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
/* Return Z_BUF_ERROR if we were given an incomplete table */ |
||||
return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK; |
||||
} |
||||
|
||||
|
||||
int inflate_trees_bits(c, bb, tb, z) |
||||
uInt *c; /* 19 code lengths */ |
||||
uInt *bb; /* bits tree desired/actual depth */ |
||||
inflate_huft **tb; /* bits tree result */ |
||||
z_stream *z; /* for zfree function */ |
||||
{ |
||||
int r; |
||||
|
||||
r = huft_build(c, 19, 19, (uInt*)Z_NULL, (uInt*)Z_NULL, tb, bb, z); |
||||
if (r == Z_DATA_ERROR) |
||||
z->msg = "oversubscribed dynamic bit lengths tree"; |
||||
else if (r == Z_BUF_ERROR) |
||||
{ |
||||
inflate_trees_free(*tb, z); |
||||
z->msg = "incomplete dynamic bit lengths tree"; |
||||
r = Z_DATA_ERROR; |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
|
||||
int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z) |
||||
uInt nl; /* number of literal/length codes */ |
||||
uInt nd; /* number of distance codes */ |
||||
uInt *c; /* that many (total) code lengths */ |
||||
uInt *bl; /* literal desired/actual bit depth */ |
||||
uInt *bd; /* distance desired/actual bit depth */ |
||||
inflate_huft **tl; /* literal/length tree result */ |
||||
inflate_huft **td; /* distance tree result */ |
||||
z_stream *z; /* for zfree function */ |
||||
{ |
||||
int r; |
||||
|
||||
/* build literal/length tree */ |
||||
if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK) |
||||
{ |
||||
if (r == Z_DATA_ERROR) |
||||
z->msg = "oversubscribed literal/length tree"; |
||||
else if (r == Z_BUF_ERROR) |
||||
{ |
||||
inflate_trees_free(*tl, z); |
||||
z->msg = "incomplete literal/length tree"; |
||||
r = Z_DATA_ERROR; |
||||
} |
||||
return r; |
||||
} |
||||
|
||||
/* build distance tree */ |
||||
if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK) |
||||
{ |
||||
if (r == Z_DATA_ERROR) |
||||
z->msg = "oversubscribed literal/length tree"; |
||||
else if (r == Z_BUF_ERROR) { |
||||
#ifdef PKZIP_BUG_WORKAROUND |
||||
r = Z_OK; |
||||
} |
||||
#else |
||||
inflate_trees_free(*td, z); |
||||
z->msg = "incomplete literal/length tree"; |
||||
r = Z_DATA_ERROR; |
||||
} |
||||
inflate_trees_free(*tl, z); |
||||
return r; |
||||
#endif |
||||
} |
||||
|
||||
/* done */ |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
/* build fixed tables only once--keep them here */ |
||||
local int fixed_lock = 0; |
||||
local int fixed_built = 0; |
||||
#define FIXEDH 530 /* number of hufts used by fixed tables */ |
||||
local uInt fixed_left = FIXEDH; |
||||
local inflate_huft fixed_mem[FIXEDH]; |
||||
local uInt fixed_bl; |
||||
local uInt fixed_bd; |
||||
local inflate_huft *fixed_tl; |
||||
local inflate_huft *fixed_td; |
||||
|
||||
|
||||
local voidp falloc(q, n, s) |
||||
voidp q; /* opaque pointer (not used) */ |
||||
uInt n; /* number of items */ |
||||
uInt s; /* size of item */ |
||||
{ |
||||
Assert(s == sizeof(inflate_huft) && n <= fixed_left, |
||||
"inflate_trees falloc overflow"); |
||||
fixed_left -= n; |
||||
return (voidp)(fixed_mem + fixed_left); |
||||
} |
||||
|
||||
|
||||
local void ffree(q, p) |
||||
voidp q; |
||||
voidp p; |
||||
{ |
||||
Assert(0, "inflate_trees ffree called!"); |
||||
} |
||||
|
||||
|
||||
int inflate_trees_fixed(bl, bd, tl, td) |
||||
uInt *bl; /* literal desired/actual bit depth */ |
||||
uInt *bd; /* distance desired/actual bit depth */ |
||||
inflate_huft **tl; /* literal/length tree result */ |
||||
inflate_huft **td; /* distance tree result */ |
||||
{ |
||||
/* build fixed tables if not built already--lock out other instances */ |
||||
while (++fixed_lock > 1) |
||||
fixed_lock--; |
||||
if (!fixed_built) |
||||
{ |
||||
int k; /* temporary variable */ |
||||
unsigned c[288]; /* length list for huft_build */ |
||||
z_stream z; /* for falloc function */ |
||||
|
||||
/* set up fake z_stream for memory routines */ |
||||
z.zalloc = falloc; |
||||
z.zfree = ffree; |
||||
z.opaque = Z_NULL; |
||||
|
||||
/* literal table */ |
||||
for (k = 0; k < 144; k++) |
||||
c[k] = 8; |
||||
for (; k < 256; k++) |
||||
c[k] = 9; |
||||
for (; k < 280; k++) |
||||
c[k] = 7; |
||||
for (; k < 288; k++) |
||||
c[k] = 8; |
||||
fixed_bl = 7; |
||||
huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z); |
||||
|
||||
/* distance table */ |
||||
for (k = 0; k < 30; k++) |
||||
c[k] = 5; |
||||
fixed_bd = 5; |
||||
huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z); |
||||
|
||||
/* done */ |
||||
fixed_built = 1; |
||||
} |
||||
fixed_lock--; |
||||
*bl = fixed_bl; |
||||
*bd = fixed_bd; |
||||
*tl = fixed_tl; |
||||
*td = fixed_td; |
||||
return Z_OK; |
||||
} |
||||
|
||||
|
||||
int inflate_trees_free(t, z) |
||||
inflate_huft *t; /* table to free */ |
||||
z_stream *z; /* for zfree function */ |
||||
/* Free the malloc'ed tables built by huft_build(), which makes a linked
|
||||
list of the tables it made, with the links in a dummy first entry of |
||||
each table. */ |
||||
{ |
||||
register inflate_huft *p, *q; |
||||
|
||||
/* Don't free fixed trees */ |
||||
if (t >= fixed_mem && t <= fixed_mem + FIXEDH) |
||||
return Z_OK; |
||||
|
||||
/* Go through linked list, freeing from the malloced (t[-1]) address. */ |
||||
p = t; |
||||
while (p != Z_NULL) |
||||
{ |
||||
q = (--p)->next; |
||||
ZFREE(z,p); |
||||
p = q; |
||||
}
|
||||
return Z_OK; |
||||
} |
||||
@ -0,0 +1,62 @@ |
||||
/* inftrees.h -- header to use inftrees.c
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* Huffman code lookup table entry--this entry is four bytes for machines
|
||||
that have 16-bit pointers (e.g. PC's in the small or medium model). |
||||
Valid extra bits (exop) are 0..13. exop == -64 is EOB (end of block), |
||||
exop == 16 means that v is a literal, exop < 0 means that v is a pointer |
||||
to the next table, which codes -exop bits, and lastly exop == -128 |
||||
indicates an unused code. If a code with exop == -128 is looked up, |
||||
this implies an error in the data. */ |
||||
|
||||
typedef struct inflate_huft_s inflate_huft; |
||||
struct inflate_huft_s { |
||||
union { |
||||
struct { |
||||
char Exop; /* number of extra bits or operation */ |
||||
char Bits; /* number of bits in this code or subcode */ |
||||
} what; |
||||
Byte *pad; /* pad structure to a power of 2 (4 bytes for */ |
||||
} word; /* 16-bit, 8 bytes for 32-bit machines) */ |
||||
union { |
||||
uInt Base; /* literal, length base, or distance base */ |
||||
inflate_huft *Next; /* pointer to next level of table */ |
||||
} more; |
||||
}; |
||||
|
||||
#ifdef DEBUG |
||||
extern uInt inflate_hufts; |
||||
#endif |
||||
|
||||
extern int inflate_trees_bits __P(( |
||||
uInt *, /* 19 code lengths */ |
||||
uInt *, /* bits tree desired/actual depth */ |
||||
inflate_huft **, /* bits tree result */ |
||||
z_stream *)); /* for zalloc, zfree functions */ |
||||
|
||||
extern int inflate_trees_dynamic __P(( |
||||
uInt, /* number of literal/length codes */ |
||||
uInt, /* number of distance codes */ |
||||
uInt *, /* that many (total) code lengths */ |
||||
uInt *, /* literal desired/actual bit depth */ |
||||
uInt *, /* distance desired/actual bit depth */ |
||||
inflate_huft **, /* literal/length tree result */ |
||||
inflate_huft **, /* distance tree result */ |
||||
z_stream *)); /* for zalloc, zfree functions */ |
||||
|
||||
extern int inflate_trees_fixed __P(( |
||||
uInt *, /* literal desired/actual bit depth */ |
||||
uInt *, /* distance desired/actual bit depth */ |
||||
inflate_huft **, /* literal/length tree result */ |
||||
inflate_huft **)); /* distance tree result */ |
||||
|
||||
extern int inflate_trees_free __P(( |
||||
inflate_huft *, /* tables to free */ |
||||
z_stream *)); /* for zfree function */ |
||||
@ -0,0 +1,76 @@ |
||||
/* inflate_util.c -- data and routines common to blocks and codes
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
#include "zutil.h" |
||||
#include "inftrees.h" |
||||
#include "infutil.h" |
||||
|
||||
struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
||||
|
||||
/* And'ing with mask[n] masks the lower n bits */ |
||||
uInt inflate_mask[] = { |
||||
0x0000, |
||||
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, |
||||
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff |
||||
}; |
||||
|
||||
|
||||
/* copy as much as possible from the sliding window to the output area */ |
||||
int inflate_flush(s, z, r) |
||||
struct inflate_blocks_state *s; |
||||
z_stream *z; |
||||
int r; |
||||
{ |
||||
uInt n; |
||||
Byte *p, *q; |
||||
|
||||
/* local copies of source and destination pointers */ |
||||
p = z->next_out; |
||||
q = s->read; |
||||
|
||||
/* compute number of bytes to copy as far as end of window */ |
||||
n = (q <= s->write ? s->write : s->end) - q; |
||||
if (n > z->avail_out) n = z->avail_out; |
||||
if (n && r == Z_BUF_ERROR) r = Z_OK; |
||||
|
||||
/* update counters */ |
||||
z->avail_out -= n; |
||||
z->total_out += n; |
||||
|
||||
/* update check information */ |
||||
s->check = adler32(s->check, q, n); |
||||
|
||||
/* copy as far as end of window */ |
||||
while (n--) *p++ = *q++; |
||||
|
||||
/* see if more to copy at beginning of window */ |
||||
if (q == s->end) |
||||
{ |
||||
/* wrap source pointer */ |
||||
q = s->window; |
||||
|
||||
/* compute bytes to copy */ |
||||
n = s->write - q; |
||||
if (n > z->avail_out) n = z->avail_out; |
||||
if (n && r == Z_BUF_ERROR) r = Z_OK; |
||||
|
||||
/* update counters */ |
||||
z->avail_out -= n; |
||||
z->total_out += n; |
||||
|
||||
/* update check information */ |
||||
s->check = adler32(s->check, q, n); |
||||
|
||||
/* copy */ |
||||
while (n--) *p++ = *q++; |
||||
} |
||||
|
||||
/* update pointers */ |
||||
z->next_out = p; |
||||
s->read = q; |
||||
|
||||
/* done */ |
||||
return r; |
||||
} |
||||
@ -0,0 +1,86 @@ |
||||
/* infutil.h -- types and macros common to blocks and codes
|
||||
* Copyright (C) 1995 Mark Adler |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* inflate blocks semi-private state */ |
||||
struct inflate_blocks_state { |
||||
|
||||
/* mode */ |
||||
enum { |
||||
TYPE, /* get type bits (3, including end bit) */ |
||||
LENS, /* get lengths for stored */ |
||||
STORED, /* processing stored block */ |
||||
TABLE, /* get table lengths */ |
||||
BTREE, /* get bit lengths tree for a dynamic block */ |
||||
DTREE, /* get length, distance trees for a dynamic block */ |
||||
CODES, /* processing fixed or dynamic block */ |
||||
DRY, /* output remaining window bytes */ |
||||
DONE, /* finished last block, done */ |
||||
ERROR} /* got a data error--stuck here */ |
||||
mode; /* current inflate_block mode */ |
||||
|
||||
/* mode dependent information */ |
||||
union { |
||||
uInt left; /* if STORED, bytes left to copy */ |
||||
struct { |
||||
uInt table; /* table lengths (14 bits) */ |
||||
uInt index; /* index into blens (or border) */ |
||||
uInt *blens; /* bit lengths of codes */ |
||||
uInt bb; /* bit length tree depth */ |
||||
inflate_huft *tb; /* bit length decoding tree */ |
||||
} trees; /* if DTREE, decoding info for trees */ |
||||
struct inflate_codes_state |
||||
*codes; /* if CODES, current state */ |
||||
} sub; /* submode */ |
||||
uInt last; /* true if this block is the last block */ |
||||
|
||||
/* mode independent information */ |
||||
uInt bitk; /* bits in bit buffer */ |
||||
uLong bitb; /* bit buffer */ |
||||
Byte *window; /* sliding window */ |
||||
Byte *end; /* one byte after sliding window */ |
||||
Byte *read; /* window read pointer */ |
||||
Byte *write; /* window write pointer */ |
||||
uLong check; /* check on output */ |
||||
|
||||
}; |
||||
|
||||
/* defines for inflate input/output */ |
||||
/* update pointers and return */ |
||||
#define UPDBITS {s->bitb=b;s->bitk=k;} |
||||
#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;} |
||||
#define UPDOUT {s->write=q;} |
||||
#define UPDATE {UPDBITS UPDIN UPDOUT} |
||||
#define LEAVE {UPDATE return inflate_flush(s,z,r);} |
||||
/* get bytes and bits */ |
||||
#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;} |
||||
#define NEEDBYTE {if(n)r=Z_OK;else LEAVE} |
||||
#define NEXTBYTE (n--,*p++) |
||||
#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}} |
||||
#define DUMPBITS(j) {b>>=(j);k-=(j);} |
||||
/* output bytes */ |
||||
#define WAVAIL (q<s->read?s->read-q-1:s->end-q) |
||||
#define LOADOUT {q=s->write;m=WAVAIL;} |
||||
#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=WAVAIL;}} |
||||
#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} |
||||
#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} |
||||
#define OUTBYTE(a) {*q++=(Byte)(a);m--;} |
||||
/* load local pointers */ |
||||
#define LOAD {LOADIN LOADOUT} |
||||
|
||||
/* masks for lower bits */ |
||||
extern uInt inflate_mask[]; |
||||
|
||||
/* copy as much as possible from the sliding window to the output area */ |
||||
extern int inflate_flush __P(( |
||||
struct inflate_blocks_state *, |
||||
z_stream *, |
||||
int)); |
||||
|
||||
struct internal_state {int dummy;}; /* for buggy compilers */ |
||||
@ -0,0 +1,210 @@ |
||||
/* minigzip.c -- simulate gzip using the zlib compression library
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/*
|
||||
* minigzip is a minimal implementation of the gzip utility. This is |
||||
* only an example of using zlib and isn't meant to replace the |
||||
* full-featured gzip. No attempt is made to deal with file systems |
||||
* limiting names to 14 or 8+3 characters, etc... Error checking is |
||||
* very limited. So use minigzip only for testing; use gzip for the |
||||
* real thing. On MSDOS, use only on file names without extension |
||||
* or in pipe mode. |
||||
*/ |
||||
|
||||
/* $Id: minigzip.c,v 1.1 1995/04/14 13:35:59 jloup Exp $ */ |
||||
|
||||
#include <stdio.h> |
||||
#include "zlib.h" |
||||
|
||||
#ifdef MSDOS |
||||
# include <fcntl.h> |
||||
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) |
||||
#else |
||||
# define SET_BINARY_MODE(file) |
||||
#endif |
||||
|
||||
#define BUFLEN 4096 |
||||
#define MAX_NAME_LEN 1024 |
||||
|
||||
#define local static |
||||
/* For MSDOS and other systems with limitation on stack size. For Unix,
|
||||
#define local |
||||
works also. |
||||
*/ |
||||
|
||||
char *prog; |
||||
|
||||
/* ===========================================================================
|
||||
* Display error message and exit |
||||
*/ |
||||
void error(msg) |
||||
char *msg; |
||||
{ |
||||
fprintf(stderr, "%s: %s\n", prog, msg); |
||||
exit(1); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Compress input to output then close both files. |
||||
*/ |
||||
void gz_compress(in, out) |
||||
FILE *in; |
||||
gzFile out; |
||||
{ |
||||
local char buf[BUFLEN]; |
||||
int len; |
||||
int err; |
||||
|
||||
for (;;) { |
||||
len = fread(buf, 1, sizeof(buf), in); |
||||
if (ferror(in)) { |
||||
perror("fread"); |
||||
exit(1); |
||||
} |
||||
if (len == 0) break; |
||||
|
||||
if (gzwrite(out, buf, len) != len) error(gzerror(out, &err)); |
||||
} |
||||
fclose(in); |
||||
if (gzclose(out) != Z_OK) error("failed gzclose"); |
||||
} |
||||
|
||||
/* ===========================================================================
|
||||
* Uncompress input to output then close both files. |
||||
*/ |
||||
void gz_uncompress(in, out) |
||||
gzFile in; |
||||
FILE *out; |
||||
{ |
||||
local char buf[BUFLEN]; |
||||
int len; |
||||
int err; |
||||
|
||||
for (;;) { |
||||
len = gzread(in, buf, sizeof(buf)); |
||||
if (len < 0) error (gzerror(in, &err)); |
||||
if (len == 0) break; |
||||
|
||||
if (fwrite(buf, 1, len, out) != len) error("failed fwrite"); |
||||
} |
||||
if (fclose(out)) error("failed fclose"); |
||||
|
||||
if (gzclose(in) != Z_OK) error("failed gzclose"); |
||||
} |
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* Compress the given file: create a corresponding .gz file and remove the |
||||
* original. |
||||
*/ |
||||
void file_compress(file) |
||||
char *file; |
||||
{ |
||||
local char outfile[MAX_NAME_LEN]; |
||||
FILE *in; |
||||
gzFile out; |
||||
|
||||
strcpy(outfile, file); |
||||
strcat(outfile, ".gz"); |
||||
|
||||
in = fopen(file, "rb"); |
||||
if (in == NULL) { |
||||
perror(file); |
||||
exit(1); |
||||
} |
||||
out = gzopen(outfile, "wb"); |
||||
if (out == NULL) { |
||||
fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); |
||||
exit(1); |
||||
} |
||||
gz_compress(in, out); |
||||
|
||||
unlink(file); |
||||
} |
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* Uncompress the given file and remove the original. |
||||
*/ |
||||
void file_uncompress(file) |
||||
char *file; |
||||
{ |
||||
local char buf[MAX_NAME_LEN]; |
||||
char *infile, *outfile; |
||||
FILE *out; |
||||
gzFile in; |
||||
int len = strlen(file); |
||||
|
||||
strcpy(buf, file); |
||||
|
||||
if (len > 3 && strcmp(file+len-3, ".gz") == 0) { |
||||
infile = file; |
||||
outfile = buf; |
||||
outfile[len-3] = '\0'; |
||||
} else { |
||||
outfile = file; |
||||
infile = buf; |
||||
strcat(infile, ".gz"); |
||||
} |
||||
in = gzopen(infile, "rb"); |
||||
if (in == NULL) { |
||||
fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); |
||||
exit(1); |
||||
} |
||||
out = fopen(outfile, "wb"); |
||||
if (out == NULL) { |
||||
perror(file); |
||||
exit(1); |
||||
} |
||||
|
||||
gz_uncompress(in, out); |
||||
|
||||
unlink(infile); |
||||
} |
||||
|
||||
|
||||
/* ===========================================================================
|
||||
* Usage: minigzip [-d] [files...] |
||||
*/ |
||||
|
||||
void main(argc, argv) |
||||
int argc; |
||||
char *argv[]; |
||||
{ |
||||
int uncompr = 0; |
||||
gzFile file; |
||||
|
||||
prog = argv[0]; |
||||
argc--, argv++; |
||||
|
||||
if (argc > 0) { |
||||
uncompr = (strcmp(*argv, "-d") == 0); |
||||
if (uncompr) { |
||||
argc--, argv++; |
||||
} |
||||
} |
||||
if (argc == 0) { |
||||
SET_BINARY_MODE(stdin); |
||||
SET_BINARY_MODE(stdout); |
||||
if (uncompr) { |
||||
file = gzdopen(fileno(stdin), "rb"); |
||||
if (file == NULL) error("can't gzdopen stdin"); |
||||
gz_uncompress(file, stdout); |
||||
} else { |
||||
file = gzdopen(fileno(stdout), "wb"); |
||||
if (file == NULL) error("can't gzdopen stdout"); |
||||
gz_compress(stdin, file); |
||||
} |
||||
} else { |
||||
do { |
||||
if (uncompr) { |
||||
file_uncompress(*argv); |
||||
} else { |
||||
file_compress(*argv); |
||||
} |
||||
} while (argv++, --argc); |
||||
} |
||||
exit(0); |
||||
} |
||||
@ -0,0 +1,58 @@ |
||||
/* uncompr.c -- decompress a memory buffer
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: uncompr.c,v 1.4 1995/04/10 16:22:22 jloup Exp $ */ |
||||
|
||||
#include "zlib.h" |
||||
|
||||
/* ===========================================================================
|
||||
Decompresses the source buffer into the destination buffer. sourceLen is |
||||
the byte length of the source buffer. Upon entry, destLen is the total |
||||
size of the destination buffer, which must be large enough to hold the |
||||
entire uncompressed data. (The size of the uncompressed data must have |
||||
been saved previously by the compressor and transmitted to the decompressor |
||||
by some mechanism outside the scope of this compression library.) |
||||
Upon exit, destLen is the actual size of the compressed buffer. |
||||
This function can be used to decompress a whole file at once if the |
||||
input file is mmap'ed. |
||||
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output |
||||
buffer, or Z_DATA_ERROR if the input data was corrupted. |
||||
*/ |
||||
int uncompress (dest, destLen, source, sourceLen) |
||||
Byte *dest; |
||||
uLong *destLen; |
||||
Byte *source; |
||||
uLong sourceLen; |
||||
{ |
||||
z_stream stream; |
||||
int err; |
||||
|
||||
stream.next_in = source; |
||||
stream.avail_in = (uInt)sourceLen; |
||||
/* Check for source > 64K on 16-bit machine: */ |
||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
||||
|
||||
stream.next_out = dest; |
||||
stream.avail_out = (uInt)*destLen; |
||||
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; |
||||
|
||||
stream.zalloc = (alloc_func)0; |
||||
stream.zfree = (free_func)0; |
||||
|
||||
err = inflateInit(&stream); |
||||
if (err != Z_OK) return err; |
||||
|
||||
err = inflate(&stream, Z_FINISH); |
||||
if (err != Z_STREAM_END) { |
||||
inflateEnd(&stream); |
||||
return err; |
||||
} |
||||
*destLen = stream.total_out; |
||||
|
||||
err = inflateEnd(&stream); |
||||
return err; |
||||
} |
||||
@ -0,0 +1,66 @@ |
||||
/* zconf.h -- configuration of the zlib compression library
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: zconf.h,v 1.7 1995/04/12 20:42:28 jloup Exp $ */ |
||||
|
||||
#ifndef _ZCONF_H |
||||
#define _ZCONF_H |
||||
|
||||
/*
|
||||
The library does not install any signal handler. It is recommended to |
||||
add at least a handler for SIGSEGV when decompressing; the library checks |
||||
the consistency of the input data whenever possible but may go nuts |
||||
for some forms of corrupted input. |
||||
*/ |
||||
|
||||
/*
|
||||
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more |
||||
* than 64k bytes at a time (needed on systems with 16-bit int). |
||||
*/ |
||||
#if defined(_GNUC__) && !defined(__32BIT__) |
||||
# define __32BIT__ |
||||
#endif |
||||
#if defined(__MSDOS__) && !defined(MSDOS) |
||||
# define MSDOS |
||||
#endif |
||||
#if defined(MSDOS) && !defined(__32BIT__) |
||||
# define MAXSEG_64K |
||||
#endif |
||||
|
||||
#ifdef MAXSEG_64K |
||||
# define MAX_MEM_LEVEL 8 |
||||
#else |
||||
# define MAX_MEM_LEVEL 9 |
||||
#endif |
||||
|
||||
/* Type declarations */ |
||||
|
||||
#ifndef __P /* function prototypes */ |
||||
# if defined(__STDC__) || defined(MSDOS) |
||||
# define __P(args) args |
||||
# else |
||||
# define __P(args) () |
||||
# endif |
||||
#endif |
||||
|
||||
#ifndef Byte |
||||
typedef unsigned char Byte; /* 8 bits */ |
||||
#endif |
||||
#ifndef uInt |
||||
typedef unsigned int uInt; /* may be 16 or 32 bits */ |
||||
#endif |
||||
#ifndef uLong |
||||
typedef unsigned long uLong; /* 32 bits or more */ |
||||
#endif |
||||
#ifndef voidp |
||||
# if defined(__STDC__) || defined(MSDOS) |
||||
typedef void *voidp; |
||||
# else |
||||
typedef Byte *voidp; |
||||
# endif |
||||
#endif |
||||
|
||||
#endif /* _ZCONF_H */ |
||||
|
||||
@ -0,0 +1,604 @@ |
||||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 0.7 April 14th, 1995. |
||||
|
||||
Copyright (C) 1995 Jean-loup Gailly and Mark Adler |
||||
|
||||
This software is provided 'as-is', without any express or implied |
||||
warranty. In no event will the authors be held liable for any damages |
||||
arising from the use of this software. |
||||
|
||||
Permission is granted to anyone to use this software for any purpose, |
||||
including commercial applications, and to alter it and redistribute it |
||||
freely, subject to the following restrictions: |
||||
|
||||
1. The origin of this software must not be misrepresented; you must not |
||||
claim that you wrote the original software. If you use this software |
||||
in a product, an acknowledgment in the product documentation would be |
||||
appreciated but is not required. |
||||
2. Altered source versions must be plainly marked as such, and must not be |
||||
misrepresented as being the original software. |
||||
3. This notice may not be removed or altered from any source distribution. |
||||
|
||||
Jean-loup Gailly Mark Adler |
||||
gzip@prep.ai.mit.edu madler@cco.caltech.edu |
||||
*/ |
||||
|
||||
#ifndef _ZLIB_H |
||||
#define _ZLIB_H |
||||
|
||||
#include "zconf.h" |
||||
|
||||
#define ZLIB_VERSION "0.7" |
||||
|
||||
/*
|
||||
The 'zlib' compression library provides in-memory compression and |
||||
decompression functions, including integrity checks of the uncompressed |
||||
data. This version of the library supports only one compression method |
||||
(deflation) but other algorithms may be added later and will have the same |
||||
stream interface. |
||||
|
||||
For compression the application must provide the output buffer and |
||||
may optionally provide the input buffer for optimization. For decompression, |
||||
the application must provide the input buffer and may optionally provide |
||||
the output buffer for optimization. |
||||
|
||||
Compression can be done in a single step if the buffers are large |
||||
enough (for example if an input file is mmap'ed), or can be done by |
||||
repeated calls of the compression function. In the latter case, the |
||||
application must provide more input and/or consume the output |
||||
(providing more output space) before each call. |
||||
*/ |
||||
|
||||
typedef voidp (*alloc_func) __P((voidp opaque, uInt items, uInt size)); |
||||
typedef void (*free_func) __P((voidp opaque, voidp address)); |
||||
|
||||
struct internal_state; |
||||
|
||||
typedef struct z_stream_s { |
||||
Byte *next_in; /* next input byte */ |
||||
uInt avail_in; /* number of bytes available at next_in */ |
||||
uLong total_in; /* total nb of input bytes read so far */ |
||||
|
||||
Byte *next_out; /* next output byte should be put there */ |
||||
uInt avail_out; /* remaining free space at next_out */ |
||||
uLong total_out; /* total nb of bytes output so far */ |
||||
|
||||
char *msg; /* last error message, NULL if no error */ |
||||
struct internal_state *state; /* not visible by applications */ |
||||
|
||||
alloc_func zalloc; /* used to allocate the internal state */ |
||||
free_func zfree; /* used to free the internal state */ |
||||
voidp opaque; /* private data object passed to zalloc and zfree */ |
||||
|
||||
Byte data_type; /* best guess about the data type: ascii or binary */ |
||||
|
||||
} z_stream; |
||||
|
||||
/*
|
||||
The application must update next_in and avail_in when avail_in has |
||||
dropped to zero. It must update next_out and avail_out when avail_out |
||||
has dropped to zero. The application must initialize zalloc, zfree and |
||||
opaque before calling the init function. All other fields are set by the |
||||
compression library and must not be updated by the application. |
||||
|
||||
The opaque value provided by the application will be passed as first |
||||
parameter for calls of zalloc and zfree. This can be useful for custom |
||||
memory management. The compression library attaches no meaning to the |
||||
opaque value. |
||||
|
||||
zalloc must return Z_NULL if there is not enough memory for the object. |
||||
On 16-bit systems, the functions zalloc and zfree must be able to allocate |
||||
exactly 65536 bytes, but will not be require to allocate more than this |
||||
if the symbol MAXSEG_64K is defined (see zconf.h). |
||||
|
||||
The fields total_in and total_out can be used for statistics or |
||||
progress reports. After compression, total_in holds the total size of |
||||
the uncompressed data and may be saved for use in the decompressor |
||||
(particularly if the decompressor wants to decompress everything in |
||||
a single step). |
||||
*/ |
||||
|
||||
/* constants */ |
||||
|
||||
#define Z_NO_FLUSH 0 |
||||
#define Z_PARTIAL_FLUSH 1 |
||||
#define Z_FULL_FLUSH 2 |
||||
#define Z_FINISH 4 |
||||
/* See deflate() below for the usage of these constants */ |
||||
|
||||
#define Z_OK 0 |
||||
#define Z_STREAM_END 1 |
||||
#define Z_ERRNO (-1) |
||||
#define Z_STREAM_ERROR (-2) |
||||
#define Z_DATA_ERROR (-3) |
||||
#define Z_MEM_ERROR (-4) |
||||
#define Z_BUF_ERROR (-5) |
||||
/* error codes for the compression/decompression functions */ |
||||
|
||||
#define Z_BEST_SPEED 1 |
||||
#define Z_BEST_COMPRESSION 9 |
||||
#define Z_DEFAULT_COMPRESSION (-1) |
||||
/* compression levels */ |
||||
|
||||
#define Z_FILTERED 1 |
||||
#define Z_HUFFMAN_ONLY 2 |
||||
#define Z_DEFAULT_STRATEGY 0 |
||||
|
||||
#define Z_BINARY 0 |
||||
#define Z_ASCII 1 |
||||
#define Z_UNKNOWN 2 |
||||
/* Used to set the data_type field */ |
||||
|
||||
#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
||||
|
||||
extern char *zlib_version; |
||||
/* The application can compare zlib_version and ZLIB_VERSION for consistency.
|
||||
If the first character differs, the library code actually used is |
||||
not compatible with the zlib.h header file used by the application. |
||||
*/ |
||||
|
||||
/* basic functions */ |
||||
|
||||
extern int deflateInit __P((z_stream *strm, int level)); |
||||
/*
|
||||
Initializes the internal stream state for compression. The fields |
||||
zalloc, zfree and opaque must be initialized before by the caller. |
||||
If zalloc and zfree are set to Z_NULL, deflateInit updates them to |
||||
use default allocation functions. |
||||
|
||||
The compression level must be Z_DEFAULT_COMPRESSION, or between 1 and 9: |
||||
1 gives best speed, 9 gives best compression. Z_DEFAULT_COMPRESSION requests |
||||
a default compromise between speed and compression (currently equivalent |
||||
to level 6). |
||||
|
||||
deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_STREAM_ERROR if the stream state was inconsistent (such |
||||
as zalloc being NULL). msg is set to null if there is no error message. |
||||
deflateInit does not perform any compression: this will be done by |
||||
deflate(). */ |
||||
|
||||
|
||||
extern int deflate __P((z_stream *strm, int flush)); |
||||
/*
|
||||
Performs one or both of the following actions: |
||||
|
||||
- Compress more input starting at next_in and update next_in and avail_in |
||||
accordingly. If not all input can be processed (because there is not |
||||
enough room in the output buffer), next_in is updated and processing |
||||
will resume at this point for the next call of deflate(). |
||||
|
||||
- Provide more output starting at next_out and update next_out and avail_out |
||||
accordingly. This action is forced if the parameter flush is non zero. |
||||
Forcing flush frequently degrades the compression ratio, so this parameter |
||||
should be set only when necessary (in interactive applications). |
||||
Some output may be provided even if flush is not set. |
||||
|
||||
Before the call of deflate(), the application should ensure that at least |
||||
one of the actions is possible, by providing more input and/or consuming |
||||
more output, and updating avail_in or avail_out accordingly. |
||||
The application can consume the compressed output when the output |
||||
buffer is full (avail_out == 0), or after each call of deflate(). |
||||
|
||||
If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression |
||||
block is byte aligned and flushed to the output buffer so that the |
||||
decompressor can get all input data available so far; if the compression |
||||
method is 8 (deflate without partial flush capability), the current block |
||||
is terminated. If flush is set to Z_FULL_FLUSH, the compression block is |
||||
terminated, a special marker is output and the compression dictionary is |
||||
discarded; this is useful to allow the decompressor to synchronize if one |
||||
compressed block has been damaged. |
||||
Flushing degrades compression and so should be used only when necessary. |
||||
Using Z_FULL_FLUSH too often can seriously degrade the compression. |
||||
|
||||
If the parameter flush is set to Z_FINISH, all pending input is |
||||
processed and all pending output is flushed. The next operation on this |
||||
stream must be another call of deflate with Z_FINISH but no more input data |
||||
(unchanged avail_in) if this call returned with avail_out equal to zero, |
||||
or a call of deflateEnd to deallocate the compression state. Z_FINISH can |
||||
be used immediately after deflateInit if all the compression is to be |
||||
done in a single step. In this case, avail_out must be at least 0.1% |
||||
larger than avail_in plus 8 bytes. |
||||
|
||||
deflate() may update strm->data_type if it can make a good guess about |
||||
the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered |
||||
binary. This field is only for information purposes and does not affect |
||||
the compression algorithm in any manner. |
||||
|
||||
deflate() return Z_OK if some progress has been made (more input processed |
||||
or more output produced), Z_STREAM_ERROR if the stream state was |
||||
inconsistent (for example if next_in or next_out was NULL), Z_BUF_ERROR if |
||||
no progress is possible or if there was not enough room in the output buffer |
||||
when Z_FINISH is used. |
||||
*/ |
||||
|
||||
|
||||
extern int deflateEnd __P((z_stream *strm)); |
||||
/*
|
||||
All dynamically allocated data structures for this stream are freed. |
||||
This function discards any unprocessed input and does not flush any |
||||
pending output. |
||||
|
||||
deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
||||
stream state was inconsistent. In the error case, msg may be set |
||||
but then points to a static string (which must not be deallocated). |
||||
*/ |
||||
|
||||
|
||||
extern int inflateInit __P((z_stream *strm)); |
||||
/*
|
||||
Initializes the internal stream state for decompression. The fields |
||||
zalloc and zfree must be initialized before by the caller. If zalloc and |
||||
zfree are set to Z_NULL, deflateInit updates them to use default allocation |
||||
functions. |
||||
|
||||
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_STREAM_ERROR if the stream state was inconsistent (such |
||||
as zalloc being NULL). msg is set to null if there is no error message. |
||||
inflateInit does not perform any decompression: this will be done by |
||||
inflate(). |
||||
*/ |
||||
|
||||
|
||||
extern int inflate __P((z_stream *strm, int flush)); |
||||
/*
|
||||
Performs one or both of the following actions: |
||||
|
||||
- Decompress more input starting at next_in and update next_in and avail_in |
||||
accordingly. If not all input can be processed (because there is not |
||||
enough room in the output buffer), next_in is updated and processing |
||||
will resume at this point for the next call of inflate(). |
||||
|
||||
- Provide more output starting at next_out and update next_out and avail_out |
||||
accordingly. inflate() always provides as much output as possible |
||||
(until no more input data or no more space in the output buffer). |
||||
|
||||
Before the call of inflate(), the application should ensure that at least |
||||
one of the actions is possible, by providing more input and/or consuming |
||||
more output, and updating the next_* and avail_* values accordingly. |
||||
The application can consume the uncompressed output when the output |
||||
buffer is full (avail_out == 0), or after each call of inflate(). |
||||
|
||||
If the parameter flush is set to Z_PARTIAL_FLUSH, inflate flushes as much |
||||
output as possible to the output buffer. The flushing behavior of inflate is |
||||
not specified for values of the flush paramater other than Z_PARTIAL_FLUSH |
||||
and Z_FINISH, but the current implementation actually flushes as much output |
||||
as possible anyway. |
||||
|
||||
inflate() should normally be called until it returns Z_STREAM_END or an |
||||
error. However if all decompression is to be performed in a single step |
||||
(a single call of inflate), the parameter flush should be set to |
||||
Z_FINISH. In this case all pending input is processed and all pending |
||||
output is flushed; avail_out must be large enough to hold all the |
||||
uncompressed data. (The size of the uncompressed data may have been saved |
||||
by the compressor for this purpose.) The next operation on this stream must |
||||
be inflateEnd to deallocate the decompression state. |
||||
|
||||
inflate() returns Z_OK if some progress has been made (more input |
||||
processed or more output produced), Z_STREAM_END if the end of the |
||||
compressed data has been reached, Z_DATA_ERROR if the input data was |
||||
corrupted, Z_STREAM_ERROR if the stream structure was inconsistent (for |
||||
example if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough |
||||
memory, Z_BUF_ERROR if no progress is possible or if there was not enough |
||||
room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR case, |
||||
the application may then call inflateSync to look for a good compression |
||||
block. |
||||
*/ |
||||
|
||||
|
||||
extern int inflateEnd __P((z_stream *strm)); |
||||
/*
|
||||
All dynamically allocated data structures for this stream are freed. |
||||
This function discards any unprocessed input and does not flush any |
||||
pending output. |
||||
|
||||
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state |
||||
was inconsistent. In the error case, msg may be set but then points to a |
||||
static string (which must not be deallocated). |
||||
*/ |
||||
|
||||
/* advanced functions */ |
||||
|
||||
/*
|
||||
The following functions are needed only in some special applications. |
||||
*/ |
||||
|
||||
extern int deflateInit2 __P((z_stream *strm, |
||||
int level, |
||||
int method, |
||||
int windowBits, |
||||
int memLevel, |
||||
int strategy)); |
||||
/*
|
||||
This is another version of deflateInit with more compression options. The |
||||
fields next_in, zalloc and zfree must be initialized before by the caller. |
||||
|
||||
The method parameter is the compression method. It must be 8 in this |
||||
version of the library. (Method 9 will allow a 64K history buffer and |
||||
partial block flushes.) |
||||
|
||||
The windowBits parameter is the base two logarithm of the window size |
||||
(the size of the history buffer). It should be in the range 8..15 for this |
||||
version of the library (the value 16 will be allowed soon). Larger values |
||||
of this parameter result in better compression at the expense of memory |
||||
usage. The default value is 15 if deflateInit is used instead. |
||||
|
||||
The memLevel parameter specifies how much memory should be allocated |
||||
for the internal compression state. memLevel=1 uses minimum memory but |
||||
is slow and reduces compression ratio; memLevel=9 uses maximum memory |
||||
for optimal speed. The default value is 8. |
||||
|
||||
The strategy parameter is used to tune the compression algorithm. Use |
||||
the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data |
||||
produced by a filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman |
||||
encoding only (no string match). Filtered data consists mostly of small |
||||
values with a somewhat random distribution. In this case, the |
||||
compression algorithm is tuned to compress them better. The strategy |
||||
parameter only affects the compression ratio but not the correctness of |
||||
the compressed output even if it is not set appropriately. |
||||
|
||||
If next_in is not null, the library will use this buffer to hold also |
||||
some history information; the buffer must either hold the entire input |
||||
data, or have at least (1<<windowBits) bytes and be writable. If next_in is |
||||
null, the library will allocate its own history buffer (and leave next_in |
||||
null). next_out need not be provided here but must be provided by the |
||||
application for the next call of deflate(). |
||||
|
||||
If the history buffer is provided by the application, next_in must |
||||
must never be changed by the application since the compressor maintains |
||||
information inside this buffer from call to call; the application |
||||
must provide more input only by increasing avail_in. next_in is always |
||||
reset by the library in this case. |
||||
|
||||
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was |
||||
not enough memory, Z_STREAM_ERROR if the stream state was inconsistent |
||||
(such as zalloc being NULL) or the parameters are invalid (such as |
||||
an invalid method). msg is set to null if there is no error message. |
||||
deflateInit2 does not perform any compression: this will be done by |
||||
deflate(). |
||||
*/ |
||||
|
||||
extern int deflateCopy __P((z_stream *dest, |
||||
z_stream *source)); |
||||
/*
|
||||
Sets the destination stream as a complete copy of the source stream. If |
||||
the source stream is using an application-supplied history buffer, a new |
||||
buffer is allocated for the destination stream. The compressed output |
||||
buffer is always application-supplied. It's the responsability of the |
||||
application to provide the correct values of next_out and avail_out for the |
||||
next call of deflate. |
||||
|
||||
This function is useful when several compression strategies will be |
||||
tried, for example when there are several ways of pre-processing the input |
||||
data with a filter. The streams that will be discarded should then be freed |
||||
by calling deflateEnd. Note that deflateCopy duplicates the internal |
||||
compression state which can be quite large, so this strategy is slow and |
||||
can consume lots of memory. |
||||
|
||||
deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
||||
(such as zalloc being NULL). msg is left unchanged in both source and |
||||
destination. |
||||
*/ |
||||
|
||||
extern int deflateReset __P((z_stream *strm)); |
||||
/*
|
||||
This function is equivalent to deflateEnd followed by deflateInit, |
||||
but does not free and reallocate all the internal compression state. |
||||
The stream will keep the same compression level and any other attributes |
||||
that may have been set by deflateInit2. |
||||
|
||||
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
||||
stream state was inconsistent (such as zalloc or state being NULL). |
||||
*/ |
||||
|
||||
extern int inflateInit2 __P((z_stream *strm, |
||||
int windowBits)); |
||||
/*
|
||||
This is another version of inflateInit with more compression options. The |
||||
fields next_out, zalloc and zfree must be initialized before by the caller. |
||||
|
||||
The windowBits parameter is the base two logarithm of the maximum window |
||||
size (the size of the history buffer). It should be in the range 8..15 for |
||||
this version of the library (the value 16 will be allowed soon). The |
||||
default value is 15 if inflateInit is used instead. If a compressed stream |
||||
with a larger window size is given as input, inflate() will return with |
||||
the error code Z_DATA_ERROR instead of trying to allocate a larger window. |
||||
|
||||
If next_out is not null, the library will use this buffer for the history |
||||
buffer; the buffer must either be large enough to hold the entire output |
||||
data, or have at least 1<<(windowBits-1) bytes. If next_out is null, the |
||||
library will allocate its own buffer (and leave next_out null). next_in |
||||
need not be provided here but must be provided by the application for the |
||||
next call of inflate(). |
||||
|
||||
If the history buffer is provided by the application, next_out must |
||||
never be changed by the application since the decompressor maintains |
||||
history information inside this buffer from call to call; the application |
||||
can only reset next_out to the beginning of the history buffer when |
||||
avail_out is zero and all output has been consumed. |
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was |
||||
not enough memory, Z_STREAM_ERROR if the stream state was inconsistent |
||||
(such as zalloc being NULL) or the parameters are invalid (such as |
||||
windowBits < 9). msg is set to null if there is no error message. |
||||
inflateInit2 does not perform any compression: this will be done by |
||||
inflate(). |
||||
*/ |
||||
|
||||
extern int inflateSync __P((z_stream *strm)); |
||||
/*
|
||||
Skips invalid compressed data until the special marker and a valid block |
||||
can be found, or until all available input is skipped. No output is provided. |
||||
|
||||
inflateSync returns Z_OK if a valid block has been found, Z_BUF_ERROR if |
||||
no more input was provided, Z_DATA_ERROR if not valid block has been found, |
||||
Z_STREAM_ERROR if the stream structure was inconsistent. In the success |
||||
case, the application may save the current current value of total_in which |
||||
indicates where valid compressed data was found. In the error case, the |
||||
application may repeatedly call inflateSync, providing more input each time, |
||||
until success or end of the input data. |
||||
*/ |
||||
|
||||
extern int inflateReset __P((z_stream *strm)); |
||||
/*
|
||||
This function is equivalent to inflateEnd followed by inflateInit, |
||||
but does not free and reallocate all the internal decompression state. |
||||
The stream will keep attributes that may have been set by inflateInit2. |
||||
|
||||
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source |
||||
stream state was inconsistent (such as zalloc or state being NULL). |
||||
*/ |
||||
|
||||
|
||||
/* utility functions */ |
||||
|
||||
/*
|
||||
The following utility functions are implemented on top of the |
||||
basic stream-oriented functions. To simplify the interface, some |
||||
default options are assumed (compression level, window size, |
||||
standard memory allocation functions). The source code of these |
||||
utility functions can easily be modified if you need special options. |
||||
*/ |
||||
|
||||
extern int compress __P((Byte *dest, uLong *destLen, |
||||
Byte *source, uLong sourceLen)); |
||||
/*
|
||||
Compresses the source buffer into the destination buffer. sourceLen is |
||||
the byte length of the source buffer. Upon entry, destLen is the total |
||||
size of the destination buffer, which must be at least 0.1% larger than |
||||
sourceLen plus 8 bytes. Upon exit, destLen is the actual size of the |
||||
compressed buffer. |
||||
This function can be used to compress a whole file at once if the |
||||
input file is mmap'ed. |
||||
compress returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output |
||||
buffer. |
||||
*/ |
||||
|
||||
extern int uncompress __P((Byte *dest, uLong *destLen, |
||||
Byte *source, uLong sourceLen)); |
||||
/*
|
||||
Decompresses the source buffer into the destination buffer. sourceLen is |
||||
the byte length of the source buffer. Upon entry, destLen is the total |
||||
size of the destination buffer, which must be large enough to hold the |
||||
entire uncompressed data. (The size of the uncompressed data must have |
||||
been saved previously by the compressor and transmitted to the decompressor |
||||
by some mechanism outside the scope of this compression library.) |
||||
Upon exit, destLen is the actual size of the compressed buffer. |
||||
This function can be used to decompress a whole file at once if the |
||||
input file is mmap'ed. |
||||
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
||||
enough memory, Z_BUF_ERROR if there was not enough room in the output |
||||
buffer, or Z_DATA_ERROR if the input data was corrupted. |
||||
*/ |
||||
|
||||
|
||||
typedef voidp gzFile; |
||||
|
||||
extern gzFile gzopen __P((char *path, char *mode)); |
||||
/*
|
||||
Opens a gzip (.gz) file for reading or writing. The mode parameter |
||||
is as in fopen ("rb" or "wb"). gzopen can also be used to read a file |
||||
which is not in gzip format; in this case gzread will directly read from |
||||
the file without decompression. |
||||
gzopen return NULL if the file 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). |
||||
*/ |
||||
|
||||
extern gzFile gzdopen __P((int fd, char *mode)); |
||||
/*
|
||||
gzdopen() associates a gzFile with the file descriptor fd. File |
||||
descriptors are obtained from calls like open, dup, creat, or pipe. |
||||
The mode parameter is as in fopen ("rb" or "wb"). |
||||
gzdopen return NULL if there was insufficient memory to allocate |
||||
the (de)compression state. |
||||
*/ |
||||
|
||||
extern int gzread __P((gzFile file, voidp 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). */ |
||||
|
||||
extern int gzwrite __P((gzFile file, voidp buf, unsigned len)); |
||||
/*
|
||||
Writes the given number of uncompressed bytes into the compressed file. |
||||
gzwrite returns the number of uncompressed bytes actually written |
||||
(0 in case of error). |
||||
*/ |
||||
|
||||
extern int gzflush __P((gzFile file, int 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 should be called only when strictly necessary because it can |
||||
degrade compression. |
||||
*/ |
||||
|
||||
extern int gzclose __P((gzFile file)); |
||||
/*
|
||||
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). |
||||
*/ |
||||
|
||||
extern char* gzerror __P((gzFile file, int *errnum)); |
||||
/*
|
||||
Returns the error message for the last error which occurred on the |
||||
given compressed file. errnum is set to zlib error number. If an |
||||
error occurred in the file system and not in the compression library, |
||||
errnum is set to Z_ERRNO and the application may consult errno |
||||
to get the exact error code. |
||||
*/ |
||||
|
||||
/* checksum functions */ |
||||
|
||||
/*
|
||||
These functions are not related to compression but are exported |
||||
anyway because they might be useful in applications using the |
||||
compression library. |
||||
*/ |
||||
|
||||
extern uLong adler32 __P((uLong adler, Byte *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 cheksum is almost as reliable as a CRC32 but can be computed |
||||
much faster. Usage example: |
||||
|
||||
uLong adler = adler32(0L, Z_NULL, 0); |
||||
|
||||
while (read_buffer(buffer, length) != EOF) { |
||||
adler = adler32(adler, buffer, length); |
||||
} |
||||
if (adler != original_adler) error(); |
||||
*/ |
||||
|
||||
extern uLong crc32 __P((uLong crc, Byte *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 (0). Pre- and post-conditioning (one's complement) is performed |
||||
within this function so it shouldn't be done by the application. |
||||
Usage example: |
||||
|
||||
uLong crc = crc32(0L, Z_NULL, 0); |
||||
|
||||
while (read_buffer(buffer, length) != EOF) { |
||||
crc = crc32(crc, buffer, length); |
||||
} |
||||
if (crc != original_crc) error(); |
||||
*/ |
||||
|
||||
#ifndef _Z_UTIL_H |
||||
struct internal_state {int dummy;}; /* hack for buggy compilers */ |
||||
#endif |
||||
|
||||
#endif /* _ZLIB_H */ |
||||
@ -0,0 +1,164 @@ |
||||
/* zutil.c -- target dependent utility functions for the compression library
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/ |
||||
|
||||
/* $Id: zutil.c,v 1.3 1995/04/10 09:52:26 jloup Exp $ */ |
||||
|
||||
#include <stdio.h> |
||||
|
||||
#include "zutil.h" |
||||
|
||||
char *zlib_version = ZLIB_VERSION; |
||||
|
||||
char *z_errmsg[] = { |
||||
"stream end", /* Z_STREAM_END 1 */ |
||||
"", /* Z_OK 0 */ |
||||
"file error", /* Z_ERRNO (-1) */ |
||||
"stream error", /* Z_STREAM_ERROR (-2) */ |
||||
"data error", /* Z_DATA_ERROR (-3) */ |
||||
"insufficient memory", /* Z_MEM_ERROR (-4) */ |
||||
"buffer error", /* Z_BUF_ERROR (-5) */ |
||||
""}; |
||||
|
||||
|
||||
void z_error (m) |
||||
char *m; |
||||
{ |
||||
fprintf(stderr, "%s\n", m); |
||||
exit(1); |
||||
} |
||||
|
||||
#ifndef HAVE_MEMCPY |
||||
|
||||
void zmemcpy(dest, source, len) |
||||
Byte* dest; |
||||
Byte* source; |
||||
uInt len; |
||||
{ |
||||
if (len == 0) return; |
||||
do { |
||||
*dest++ = *source++; /* ??? to be unrolled */ |
||||
} while (--len != 0); |
||||
} |
||||
|
||||
void zmemzero(dest, len) |
||||
Byte* dest; |
||||
uInt len; |
||||
{ |
||||
if (len == 0) return; |
||||
do { |
||||
*dest++ = 0; /* ??? to be unrolled */ |
||||
} while (--len != 0); |
||||
} |
||||
#endif |
||||
|
||||
#if defined(MSDOS) && !defined(USE_CALLOC) |
||||
# ifdef __TURBOC__ |
||||
|
||||
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
|
||||
* and farmalloc(64K) returns a pointer with an offset of 8, so we |
||||
* must fix the pointer. Warning: the pointer must be put back to its |
||||
* original form in order to free it, use zcfree(). |
||||
*/ |
||||
|
||||
#define MAX_PTR 10 |
||||
/* 10*64K = 640K */ |
||||
|
||||
local int next_ptr = 0; |
||||
|
||||
typedef struct ptr_table_s { |
||||
voidp org_ptr; |
||||
voidp new_ptr; |
||||
} ptr_table; |
||||
|
||||
local ptr_table table[MAX_PTR]; |
||||
/* This table is used to remember the original form of pointers
|
||||
* to large buffers (64K). Such pointers are normalized with a zero offset. |
||||
* Since MSDOS is not a preemptive multitasking OS, this table is not |
||||
* protected from concurrent access. This hack doesn't work anyway on |
||||
* a protected system like OS/2. Use Microsoft C instead. |
||||
*/ |
||||
|
||||
voidp zcalloc (voidp opaque, unsigned items, unsigned size) |
||||
{ |
||||
voidp buf; |
||||
ulg bsize = (ulg)items*size; |
||||
|
||||
if (bsize < 65536L) { |
||||
buf = farmalloc(bsize); |
||||
if (*(ush*)&buf != 0) return buf; |
||||
} else { |
||||
buf = farmalloc(bsize + 16L); |
||||
} |
||||
if (buf == NULL || next_ptr >= MAX_PTR) return NULL; |
||||
table[next_ptr].org_ptr = buf; |
||||
|
||||
/* Normalize the pointer to seg:0 */ |
||||
*((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; |
||||
*(ush*)&buf = 0; |
||||
table[next_ptr++].new_ptr = buf; |
||||
return buf; |
||||
} |
||||
|
||||
void zcfree (voidp opaque, voidp ptr) |
||||
{ |
||||
int n; |
||||
if (*(ush*)&ptr != 0) { /* object < 64K */ |
||||
farfree(ptr); |
||||
return; |
||||
} |
||||
/* Find the original pointer */ |
||||
for (n = 0; n < next_ptr; n++) { |
||||
if (ptr != table[n].new_ptr) continue; |
||||
|
||||
farfree(table[n].org_ptr); |
||||
while (++n < next_ptr) { |
||||
table[n-1] = table[n]; |
||||
} |
||||
next_ptr--; |
||||
return; |
||||
} |
||||
z_error("zcfree: ptr not found"); |
||||
} |
||||
|
||||
# else /* MSC */ |
||||
|
||||
#if (!defined(_MSC_VER) || (_MSC_VER < 600)) |
||||
# define _halloc halloc |
||||
# define _hfree hfree |
||||
#endif |
||||
|
||||
voidp zcalloc (voidp opaque, unsigned items, unsigned size) |
||||
{ |
||||
return _halloc((long)items, size); |
||||
} |
||||
|
||||
void zcfree (voidp opaque, voidp ptr) |
||||
{ |
||||
return _hfree(ptr); |
||||
} |
||||
|
||||
# endif /* __TURBOC__ ? */ |
||||
|
||||
#else /* !MSDOS */ |
||||
|
||||
extern voidp calloc __P((uInt items, uInt size)); |
||||
extern void free __P((voidp ptr)); |
||||
|
||||
voidp zcalloc (opaque, items, size) |
||||
voidp opaque; |
||||
unsigned items; |
||||
unsigned size; |
||||
{ |
||||
return calloc(items, size); |
||||
} |
||||
|
||||
void zcfree (opaque, ptr) |
||||
voidp opaque; |
||||
voidp ptr; |
||||
{ |
||||
free(ptr); |
||||
} |
||||
|
||||
#endif /* MSDOS */ |
||||
@ -0,0 +1,166 @@ |
||||
/* zutil.h -- internal interface and configuration of the compression library
|
||||
* Copyright (C) 1995 Jean-loup Gailly. |
||||
* For conditions of distribution and use, see copyright notice in zlib.h |
||||
*/ |
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is |
||||
subject to change. Applications should only use zlib.h. |
||||
*/ |
||||
|
||||
/* $Id: zutil.h,v 1.4 1995/04/14 10:22:17 jloup Exp $ */ |
||||
|
||||
#ifndef _Z_UTIL_H |
||||
#define _Z_UTIL_H |
||||
|
||||
#include "zlib.h" |
||||
|
||||
#ifdef MSDOS |
||||
# include <stddef.h> |
||||
#else |
||||
extern int errno; |
||||
#endif |
||||
|
||||
#ifndef local |
||||
# define local static |
||||
#endif |
||||
/* compile with -Dlocal if your debugger can't find static symbols */ |
||||
|
||||
typedef unsigned char uch; |
||||
typedef unsigned short ush; |
||||
typedef unsigned long ulg; |
||||
|
||||
extern char *z_errmsg[]; /* indexed by 1-zlib_error */ |
||||
|
||||
#define ERR_RETURN(strm,err) return (strm->msg=z_errmsg[1-err], err) |
||||
/* To be used only when the state is known to be valid */ |
||||
|
||||
/* common constants */ |
||||
|
||||
#define DEFLATED 8 |
||||
|
||||
#ifndef WBITS |
||||
# define WBITS 15 /* 32K window */ |
||||
#endif |
||||
|
||||
#ifndef MEM_LEVEL |
||||
# define MEM_LEVEL 8 |
||||
#endif |
||||
|
||||
#define STORED_BLOCK 0 |
||||
#define STATIC_TREES 1 |
||||
#define DYN_TREES 2 |
||||
/* The three kinds of block type */ |
||||
|
||||
#define MIN_MATCH 3 |
||||
#define MAX_MATCH 258 |
||||
/* The minimum and maximum match lengths */ |
||||
|
||||
/* target dependencies */ |
||||
|
||||
#ifdef MSDOS |
||||
# define OS_CODE 0x00 |
||||
# ifdef __TURBOC__ |
||||
# include <alloc.h> |
||||
# define exit(n) _exit(n) |
||||
# else /* MSC */ |
||||
# include <malloc.h> |
||||
# endif |
||||
#endif |
||||
|
||||
#ifdef OS2 |
||||
# define OS_CODE 0x06 |
||||
#endif |
||||
|
||||
#ifdef WIN32 /* Windows NT */ |
||||
# define OS_CODE 0x0b |
||||
#endif |
||||
|
||||
#if defined(VAXC) || defined(VMS) |
||||
# define OS_CODE 0x02 |
||||
# define FOPEN(name, mode) \ |
||||
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512") |
||||
#endif |
||||
|
||||
#ifdef AMIGA |
||||
# define OS_CODE 0x01 |
||||
#endif |
||||
|
||||
#if defined(ATARI) || defined(atarist) |
||||
# define OS_CODE 0x05 |
||||
#endif |
||||
|
||||
#ifdef MACOS |
||||
# define OS_CODE 0x07 |
||||
#endif |
||||
|
||||
#ifdef __50SERIES /* Prime/PRIMOS */ |
||||
# define OS_CODE 0x0F |
||||
#endif |
||||
|
||||
#ifdef TOPS20 |
||||
# define OS_CODE 0x0a |
||||
#endif |
||||
|
||||
/* Common defaults */ |
||||
|
||||
#ifndef OS_CODE |
||||
# define OS_CODE 0x03 /* assume Unix */ |
||||
#endif |
||||
|
||||
#ifndef FOPEN |
||||
# define FOPEN(name, mode) fopen((name), (mode)) |
||||
#endif |
||||
|
||||
/* functions */ |
||||
|
||||
#ifdef HAVE_STRERROR |
||||
extern char *strerror __P((int)); |
||||
# define zstrerror(errnum) strerror(errnum) |
||||
#else |
||||
# define zstrerror(errnum) "" |
||||
#endif |
||||
|
||||
#if defined(__STDC__) && !defined(HAVE_MEMCPY) |
||||
# define HAVE_MEMCPY |
||||
#endif |
||||
#ifdef HAVE_MEMCPY |
||||
# define zmemcpy memcpy |
||||
# define zmemzero(dest, len) memset(dest, 0, len) |
||||
#else |
||||
extern void zmemcpy __P((Byte* dest, Byte* source, uInt len)); |
||||
extern void zmemzero __P((Byte* dest, uInt len)); |
||||
#endif |
||||
|
||||
/* Diagnostic functions */ |
||||
#ifdef DEBUG |
||||
# include <stdio.h> |
||||
# ifndef verbose |
||||
# define verbose 0 |
||||
# endif |
||||
# define Assert(cond,msg) {if(!(cond)) z_error(msg);} |
||||
# define Trace(x) fprintf x |
||||
# define Tracev(x) {if (verbose) fprintf x ;} |
||||
# define Tracevv(x) {if (verbose>1) fprintf x ;} |
||||
# define Tracec(c,x) {if (verbose && (c)) fprintf x ;} |
||||
# define Tracecv(c,x) {if (verbose>1 && (c)) fprintf x ;} |
||||
#else |
||||
# define Assert(cond,msg) |
||||
# define Trace(x) |
||||
# define Tracev(x) |
||||
# define Tracevv(x) |
||||
# define Tracec(c,x) |
||||
# define Tracecv(c,x) |
||||
#endif |
||||
|
||||
|
||||
extern void z_error __P((char *m)); |
||||
|
||||
voidp zcalloc __P((voidp opaque, unsigned items, unsigned size)); |
||||
void zcfree __P((voidp opaque, voidp ptr)); |
||||
|
||||
#define ZALLOC(strm, items, size) (*strm->zalloc)(strm->opaque, items, size) |
||||
#define ZFREE(strm, addr) (*strm->zfree) (strm->opaque, (voidp)addr) |
||||
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} |
||||
|
||||
#endif /* _Z_UTIL_H */ |
||||
Loading…
Reference in new issue