zlib 0.95
diff --git a/ChangeLog b/ChangeLog
index d6733c5..4c69f88 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,6 +1,16 @@
ChangeLog file for zlib
+Changes in 0.95 (16 Aug 95)
+- fix MSDOS small and medium model (now easier to adapt to any compiler)
+- inlined send_bits
+- fix the final (:-) bug for deflate with flush (output was correct but
+ not completely flushed in rare occasions).
+- default window size is same for compression and decompression
+ (it's now sufficient to set MAX_WBITS in zconf.h).
+- voidp -> voidpf and voidnp -> voidp (for consistency with other
+ typedefs and because voidnp was not near in large model).
+
Changes in 0.94 (13 Aug 95)
- support MSDOS medium model
- fix deflate with flush (could sometimes generate bad output)
@@ -10,6 +20,7 @@
- gzflush now calls fflush
- For deflate with flush, flush even if no more input is provided.
- rename libgz.a as libz.a
+- avoid complex expression in infcodes.c triggering Turbo C bug
- work around a problem with gcc on Alpha (in INSERT_STRING)
- don't use inline functions (problem with some gcc versions)
- allow renaming of Byte, uInt, etc... with #define.
diff --git a/Makefile.bor b/Makefile.bor
index 3a823d0..536b76d 100644
--- a/Makefile.bor
+++ b/Makefile.bor
@@ -2,6 +2,7 @@
# Borland C++ ************ UNTESTED ***********
# To use, do "make -fmakefile.bor"
+# To compile in small model, set below: MODEL=-ms
# WARNING: the small model is supported but only for small values of
# MAX_WBITS and MAX_MEM_LEVEL. For example:
diff --git a/Makefile.msc b/Makefile.msc
index 335a4e1..3b7aabd 100644
--- a/Makefile.msc
+++ b/Makefile.msc
@@ -2,6 +2,7 @@
# Microsoft C 5.1 or later
# To use, do "make makefile.msc"
+# To compile in small model, set below: MODEL=-AS
# If you wish to reduce the memory requirements (default 256K for big
# objects plus a few K), you can add to CFLAGS below:
diff --git a/Makefile.tc b/Makefile.tc
index ceed87d..a46ce73 100644
--- a/Makefile.tc
+++ b/Makefile.tc
@@ -2,10 +2,11 @@
# TurboC 2.0
# To use, do "make -fmakefile.tc"
+# To compile in small model, set below: MODEL=-ms
# WARNING: the small model is supported but only for small values of
# MAX_WBITS and MAX_MEM_LEVEL. For example:
-# -DMAX_WBITS=11 -DDEF_WBITS=11 -DMAX_MEM_LEVEL=3
+# -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
# If you wish to reduce the memory requirements (default 256K for big
# objects plus a few K), you can add to CFLAGS below:
# -DMAX_MEM_LEVEL=7 -DMAX_WBITS=14
@@ -13,6 +14,7 @@
# ------------- Turbo C 2.0 -------------
MODEL=-ml
+# CFLAGS=-O2 -G -Z $(MODEL) -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
CFLAGS=-O2 -G -Z $(MODEL)
CC=tcc -I\tc\include
LD=tcc -L\tc\lib
diff --git a/README b/README
index 1cbd6be..1810978 100644
--- a/README
+++ b/README
@@ -1,6 +1,7 @@
-zlib 0.94 is a beta version of a general purpose compression library.
-Unless new bugs are found it will be released again as the first official
-version (1.0). This version has no known bugs.
+zlib 0.95 is a beta version of a general purpose compression library.
+This should be the last version before the first official
+version (1.0), so please test it now. (At least compile and run it with
+"make test"). This version has no known bugs.
The data format used by the zlib library is described in the
files zlib-3.1.doc, deflate-1.1.doc and gzip-4.1.doc, available
@@ -8,31 +9,29 @@
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.
+which also tests that the library is working correctly. Another
+example is given in the file minigzip.c.
To compile all files and run the test program, just type: make test
-(For MSDOS, use one of the special makefiles such as Makefile.msc.)
+(For MSDOS, use one of the special makefiles such as Makefile.msc;
+for VMS, use Make_vms.com or descrip.mms.)
To install the zlib library (libz.a) in /usr/local/lib, type: make install
To install in a different directory, use for example:
make install prefix=$HOME
This will install in $HOME/lib instead of /usr/local/lib.
-The changes made in version 0.94 are documented in the file ChangeLog.
-The main changes since 0.93 are:
-- support MSDOS small and medium model
-- fix deflate with flush (could sometimes generate bad output)
-- fix deflateReset (zlib header was incorrectly suppressed)
-- added support for VMS
-- allow a compression level in gzopen()
-- gzflush now calls fflush
-- For deflate with flush, flush even if no more input is provided.
-- rename libgz.a as libz.a
+The changes made in version 0.95 are documented in the file ChangeLog.
+The main changes since 0.94 are:
+- fix MSDOS small and medium model (now easier to adapt to any compiler)
+- inlined send_bits
+- fix the final (:-) bug for deflate with flush (output was correct but
+ not completely flushed in rare occasions).
-For MSDOS, the small and medium models are supported only for Microsoft C.
-(It should be easy to support them for Borland C also, but I don't have
-a recent Borland compiler to test with.) The small model currently works
-for Turbo/Borland C but only with reduced performance to avoid any far
-allocation (tested with -DMAX_WBITS=11 -DDEF_WBITS=11 -DMAX_MEM_LEVEL=3).
+For MSDOS, the small and medium models have been tested only with Microsoft C.
+(This should now work for Borland C also, but I don't have a recent Borland
+compiler to test with.) The small model was tested with Turbo C but only with
+reduced performance to avoid any far allocation; it was tested with
+ -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3
(C) 1995 Jean-loup Gailly and Mark Adler
diff --git a/deflate.c b/deflate.c
index 70095e6..c531856 100644
--- a/deflate.c
+++ b/deflate.c
@@ -524,8 +524,8 @@
* Try with and without -DUNALIGNED_OK to check.
*/
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
- register ush scan_start = *(ush*)scan;
- register ush scan_end = *(ush*)(scan+best_len-1);
+ register ush scan_start = *(ushf*)scan;
+ register ush scan_end = *(ushf*)(scan+best_len-1);
#else
register Bytef *strend = s->window + s->strstart + MAX_MATCH;
register Byte scan_end1 = scan[best_len-1];
@@ -554,8 +554,8 @@
/* 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;
+ if (*(ushf*)(match+best_len-1) != scan_end ||
+ *(ushf*)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
@@ -569,10 +569,10 @@
Assert(scan[2] == match[2], "scan[2]?");
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) &&
+ } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+ *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
scan < strend);
/* The funny "do {}" generates better code on most compilers */
@@ -621,7 +621,7 @@
best_len = len;
if (len >= s->nice_match) break;
#ifdef UNALIGNED_OK
- scan_end = *(ush*)(scan+best_len-1);
+ scan_end = *(ushf*)(scan+best_len-1);
#else
scan_end1 = scan[best_len-1];
scan_end = scan[best_len];
diff --git a/deflate.h b/deflate.h
index eada3ba..f3b4c38 100644
--- a/deflate.h
+++ b/deflate.h
@@ -233,6 +233,7 @@
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 */
+ int last_eob_len; /* bit length of EOB code for last block */
#ifdef DEBUG
ulg bits_sent; /* bit length of the compressed data */
diff --git a/example.c b/example.c
index d362c7a..c18a583 100644
--- a/example.c
+++ b/example.c
@@ -277,7 +277,7 @@
fprintf(stderr, "incompatible zlib version\n");
exit(1);
- } else if (zstrcmp(zlib_version, ZLIB_VERSION) != 0) {
+ } else if (strcmp(zlib_version, ZLIB_VERSION) != 0) {
fprintf(stderr, "warning: different zlib version\n");
}
test_compress();
diff --git a/gzio.c b/gzio.c
index 1f0f9fc..cd932d3 100644
--- a/gzio.c
+++ b/gzio.c
@@ -234,7 +234,7 @@
*/
int gzread (file, buf, len)
gzFile file;
- voidnp buf;
+ voidp buf;
unsigned len;
{
gz_stream *s = (gz_stream*)file;
@@ -292,7 +292,7 @@
*/
int gzwrite (file, buf, len)
gzFile file;
- voidnp buf;
+ voidp buf;
unsigned len;
{
gz_stream *s = (gz_stream*)file;
diff --git a/inftrees.c b/inftrees.c
index 7a45e92..ab9d74f 100644
--- a/inftrees.c
+++ b/inftrees.c
@@ -25,14 +25,14 @@
uIntf *, /* maximum lookup bits (returns actual) */
z_stream *)); /* for zalloc function */
-local voidp falloc OF((
- voidp, /* opaque pointer (not used) */
+local voidpf falloc OF((
+ voidpf, /* opaque pointer (not used) */
uInt, /* number of items */
uInt)); /* size of item */
local void ffree OF((
- voidp q, /* opaque pointer (not used) */
- voidp p)); /* what to free (not used) */
+ voidpf q, /* opaque pointer (not used) */
+ voidpf p)); /* what to free (not used) */
/* Tables for deflate from PKZIP's appnote.txt. */
local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */
@@ -377,8 +377,8 @@
local inflate_huft *fixed_td;
-local voidp falloc(q, n, s)
-voidp q; /* opaque pointer (not used) */
+local voidpf falloc(q, n, s)
+voidpf q; /* opaque pointer (not used) */
uInt n; /* number of items */
uInt s; /* size of item */
{
@@ -386,13 +386,13 @@
"inflate_trees falloc overflow");
if (q) s++; /* to make some compilers happy */
fixed_left -= n;
- return (voidp)(fixed_mem + fixed_left);
+ return (voidpf)(fixed_mem + fixed_left);
}
local void ffree(q, p)
-voidp q;
-voidp p;
+voidpf q;
+voidpf p;
{
Assert(0, "inflate_trees ffree called!");
if (q) q = p; /* to make some compilers happy */
diff --git a/trees.c b/trees.c
index f6b97ff..4cb5454 100644
--- a/trees.c
+++ b/trees.c
@@ -143,9 +143,9 @@
local void compress_block OF((deflate_state *s, ct_data *ltree,
ct_data *dtree));
local void set_data_type OF((deflate_state *s));
-local void send_bits OF((deflate_state *s, int value, int length));
local unsigned bi_reverse OF((unsigned value, int length));
local void bi_windup OF((deflate_state *s));
+local void bi_flush OF((deflate_state *s));
local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
int header));
@@ -166,6 +166,63 @@
* used.
*/
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+ put_byte(s, (uch)((w) & 0xff)); \
+ put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef DEBUG
+local void send_bits OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+ deflate_state *s;
+ int value; /* value to send */
+ int length; /* number of bits */
+{
+ Tracev((stderr," l %2d v %4x ", length, value));
+ Assert(length > 0 && length <= 15, "invalid length");
+ s->bits_sent += (ulg)length;
+
+ /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+ * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+ * unused bits in value.
+ */
+ if (s->bi_valid > (int)Buf_size - length) {
+ s->bi_buf |= (value << s->bi_valid);
+ put_short(s, s->bi_buf);
+ s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+ s->bi_valid += length - Buf_size;
+ } else {
+ s->bi_buf |= value << s->bi_valid;
+ s->bi_valid += length;
+ }
+}
+#else /* !DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+ if (s->bi_valid > (int)Buf_size - len) {\
+ int val = value;\
+ s->bi_buf |= (val << s->bi_valid);\
+ put_short(s, s->bi_buf);\
+ s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+ s->bi_valid += len - Buf_size;\
+ } else {\
+ s->bi_buf |= (value) << s->bi_valid;\
+ s->bi_valid += len;\
+ }\
+}
+#endif /* DEBUG */
+
+
#define MAX(a,b) (a >= b ? a : b)
/* the arguments must not have side effects */
@@ -259,6 +316,7 @@
s->bi_buf = 0;
s->bi_valid = 0;
+ s->last_eob_len = 8; /* enough lookahead for inflate */
#ifdef DEBUG
s->bits_sent = 0L;
#endif
@@ -739,7 +797,12 @@
}
/* ===========================================================================
- * Send one empty static block to give enough lookahead for inflate
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ * The current inflate code requires 9 bits of lookahead. If the EOB
+ * code for the previous block was coded on 5 bits or less, inflate
+ * may have only 5+3 bits of lookahead to decode this EOB.
+ * (There are no problems if the previous block is stored or fixed.)
*/
void ct_align(s)
deflate_state *s;
@@ -747,6 +810,18 @@
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+ bi_flush(s);
+ /* Of the 10 bits for the empty block, we have already sent
+ * (10 - bi_valid) bits. The lookahead for the EOB of the previous
+ * block was thus its length plus what we have just sent.
+ */
+ if (s->last_eob_len + 10 - s->bi_valid < 9) {
+ send_bits(s, STATIC_TREES<<1, 3);
+ send_code(s, END_BLOCK, static_ltree);
+ s->compressed_len += 10L;
+ bi_flush(s);
+ }
+ s->last_eob_len = 7;
}
/* ===========================================================================
@@ -950,6 +1025,7 @@
} while (lx < s->last_lit);
send_code(s, END_BLOCK, ltree);
+ s->last_eob_len = ltree[END_BLOCK].Len;
}
/* ===========================================================================
@@ -971,44 +1047,6 @@
}
/* ===========================================================================
- * Output a short LSB first on the stream.
- * IN assertion: there is enough room in pendingBuf.
- */
-#define put_short(s, w) { \
- put_byte(s, (uch)((w) & 0xff)); \
- put_byte(s, (uch)((ush)(w) >> 8)); \
-}
-
-/* ===========================================================================
- * Send a value on a given number of bits.
- * IN assertion: length <= 16 and value fits in length bits.
- */
-local void send_bits(s, value, length)
- deflate_state *s;
- int value; /* value to send */
- int length; /* number of bits */
-{
-#ifdef DEBUG
- Tracev((stderr," l %2d v %4x ", length, value));
- Assert(length > 0 && length <= 15, "invalid length");
- s->bits_sent += (ulg)length;
-#endif
- /* If not enough room in bi_buf, use (valid) bits from bi_buf and
- * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
- * unused bits in value.
- */
- if (s->bi_valid > (int)Buf_size - length) {
- s->bi_buf |= (value << s->bi_valid);
- put_short(s, s->bi_buf);
- s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
- s->bi_valid += length - Buf_size;
- } else {
- s->bi_buf |= value << s->bi_valid;
- s->bi_valid += length;
- }
-}
-
-/* ===========================================================================
* Reverse the first len bits of a code, using straightforward code (a faster
* method would use a table)
* IN assertion: 1 <= len <= 15
@@ -1026,7 +1064,24 @@
}
/* ===========================================================================
- * Write out any remaining bits in an incomplete byte.
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+ deflate_state *s;
+{
+ if (s->bi_valid == 16) {
+ put_short(s, s->bi_buf);
+ s->bi_buf = 0;
+ s->bi_valid = 0;
+ } else if (s->bi_valid >= 8) {
+ put_byte(s, (Byte)s->bi_buf);
+ s->bi_buf >>= 8;
+ s->bi_valid -= 8;
+ }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
*/
local void bi_windup(s)
deflate_state *s;
@@ -1053,7 +1108,8 @@
unsigned len; /* its length */
int header; /* true if block header must be written */
{
- bi_windup(s); /* align on byte boundary */
+ bi_windup(s); /* align on byte boundary */
+ s->last_eob_len = 8; /* enough lookahead for inflate */
if (header) {
put_short(s, (ush)len);
diff --git a/zconf.h b/zconf.h
index 92fdbbc..3898094 100644
--- a/zconf.h
+++ b/zconf.h
@@ -85,37 +85,42 @@
# endif
#endif
-#if defined(M_I86SM) || defined(M_I86MM) /* model independent MSC functions */
-# define zstrcpy _fstrcpy
-# define zstrcat _fstrcat
-# define zstrlen _fstrlen
-# define zstrcmp _fstrcmp
-# define FAR __far
-#else
-# define zstrcpy strcpy
-# define zstrcat strcat
-# define zstrlen strlen
-# define zstrcmp strcmp
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */
+# ifdef _MSC_VER
+# define FAR __far
+# else
+# define FAR far
+# endif
+#endif
+#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
+# define FAR __far /* completely untested, just a best guess */
+#endif
+#ifndef FAR
# define FAR
#endif
-
+
typedef unsigned char Byte; /* 8 bits */
typedef unsigned int uInt; /* 16 bits or more */
typedef unsigned long uLong; /* 32 bits or more */
-typedef Byte FAR Bytef;
-typedef char FAR charf;
+typedef Byte FAR Bytef;
+typedef char FAR charf;
typedef int FAR intf;
typedef uInt FAR uIntf;
typedef uLong FAR uLongf;
#ifdef STDC
- typedef void FAR *voidp;
- typedef void *voidnp;
+ typedef void FAR *voidpf;
+ typedef void *voidp;
#else
- typedef Byte FAR *voidp;
- typedef Byte *voidnp;
+ typedef Byte FAR *voidpf;
+ typedef Byte *voidp;
#endif
#endif /* _ZCONF_H */
-
diff --git a/zlib.h b/zlib.h
index 56ad7f7..73185ec 100644
--- a/zlib.h
+++ b/zlib.h
@@ -1,5 +1,5 @@
/* zlib.h -- interface of the 'zlib' general purpose compression library
- version 0.94, Aug 13th, 1995.
+ version 0.95, Aug 16th, 1995.
Copyright (C) 1995 Jean-loup Gailly and Mark Adler
@@ -28,7 +28,7 @@
#include "zconf.h"
-#define ZLIB_VERSION "0.94"
+#define ZLIB_VERSION "0.95"
/*
The 'zlib' compression library provides in-memory compression and
@@ -49,8 +49,8 @@
(providing more output space) before each call.
*/
-typedef voidp (*alloc_func) OF((voidp opaque, uInt items, uInt size));
-typedef void (*free_func) OF((voidp opaque, voidp address));
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void (*free_func) OF((voidpf opaque, voidpf address));
struct internal_state;
@@ -510,7 +510,7 @@
*/
-typedef voidnp gzFile;
+typedef voidp gzFile;
extern gzFile gzopen OF((char *path, char *mode));
/*
@@ -533,7 +533,7 @@
the (de)compression state.
*/
-extern int gzread OF((gzFile file, voidnp buf, unsigned len));
+extern int gzread OF((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
@@ -541,7 +541,7 @@
gzread returns the number of uncompressed bytes actually read (0 for
end of file, -1 for error). */
-extern int gzwrite OF((gzFile file, voidnp buf, unsigned len));
+extern int gzwrite OF((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
diff --git a/zutil.c b/zutil.c
index 1dce6fb..67c4e54 100644
--- a/zutil.c
+++ b/zutil.c
@@ -38,8 +38,8 @@
#ifndef HAVE_MEMCPY
void zmemcpy(dest, source, len)
- Byte* dest;
- Byte* source;
+ Bytef* dest;
+ Bytef* source;
uInt len;
{
if (len == 0) return;
@@ -49,7 +49,7 @@
}
void zmemzero(dest, len)
- Byte* dest;
+ Bytef* dest;
uInt len;
{
if (len == 0) return;
@@ -59,8 +59,10 @@
}
#endif
-#if defined(__TURBOC__) && !defined(__SMALL__)
-
+#if defined( __TURBOC__) && !defined(__SMALL__) && !defined(__MEDIUM__)
+/* Small and medium model are for now limited to near allocation with
+ * reduced MAX_WBITS and MAX_MEM_LEVEL
+ */
# define MY_ZCALLOC
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
@@ -75,8 +77,8 @@
local int next_ptr = 0;
typedef struct ptr_table_s {
- voidp org_ptr;
- voidp new_ptr;
+ voidpf org_ptr;
+ voidpf new_ptr;
} ptr_table;
local ptr_table table[MAX_PTR];
@@ -87,9 +89,9 @@
* a protected system like OS/2. Use Microsoft C instead.
*/
-voidp zcalloc (voidp opaque, unsigned items, unsigned size)
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
{
- voidp buf = opaque; /* just to make some compilers happy */
+ voidpf buf = opaque; /* just to make some compilers happy */
ulg bsize = (ulg)items*size;
if (bsize < 65536L) {
@@ -108,7 +110,7 @@
return buf;
}
-void zcfree (voidp opaque, voidp ptr)
+void zcfree (voidpf opaque, voidpf ptr)
{
int n;
if (*(ush*)&ptr != 0) { /* object < 64K */
@@ -131,7 +133,8 @@
}
#endif /* __TURBOC__ */
-#if defined(MSDOS) && !defined(__TURBOC__) /* MSC */
+#if defined(M_I86SM)||defined(M_I86MM)||defined(M_I86CM)||defined(M_I86LM)
+/* Microsoft C */
# define MY_ZCALLOC
@@ -140,13 +143,13 @@
# define _hfree hfree
#endif
-voidp zcalloc (voidp opaque, unsigned items, unsigned size)
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
{
if (opaque) opaque = 0; /* to make compiler happy */
return _halloc((long)items, size);
}
-void zcfree (voidp opaque, voidp ptr)
+void zcfree (voidpf opaque, voidpf ptr)
{
if (opaque) opaque = 0; /* to make compiler happy */
_hfree(ptr);
@@ -158,21 +161,21 @@
#ifndef MY_ZCALLOC /* Any system without a special alloc function */
#ifndef __GO32__
-extern voidp calloc OF((uInt items, uInt size));
-extern void free OF((voidp ptr));
+extern voidp calloc OF((uInt items, uInt size));
+extern void free OF((voidpf ptr));
#endif
-voidp zcalloc (opaque, items, size)
- voidp opaque;
+voidpf zcalloc (opaque, items, size)
+ voidpf opaque;
unsigned items;
unsigned size;
{
- return calloc(items, size);
+ return (voidpf)calloc(items, size);
}
void zcfree (opaque, ptr)
- voidp opaque;
- voidp ptr;
+ voidpf opaque;
+ voidpf ptr;
{
free(ptr);
}
diff --git a/zutil.h b/zutil.h
index 053eb8c..4d1b59e 100644
--- a/zutil.h
+++ b/zutil.h
@@ -46,7 +46,7 @@
#define DEFLATED 8
#ifndef DEF_WBITS
-# define DEF_WBITS 15
+# define DEF_WBITS MAX_WBITS
#endif
/* default windowBits for decompression. MAX_WBITS is for compression only */
@@ -72,7 +72,7 @@
# define OS_CODE 0x00
# ifdef __TURBOC__
# include <alloc.h>
-# else /* MSC */
+# else /* MSC or DJGPP */
# include <malloc.h>
# endif
#endif
@@ -130,23 +130,29 @@
# define zstrerror(errnum) ""
#endif
-#if defined(pyr) && !defined(NO_MEMCPY)
+#if defined(pyr)
+# define NO_MEMCPY
+#endif
+#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(_MSC_VER)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+ * You may have to use the same strategy for Borland C (untested).
+ */
# define NO_MEMCPY
#endif
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
# define HAVE_MEMCPY
#endif
#ifdef HAVE_MEMCPY
-# ifdef M_I86MM /* MSC medium model */
+# if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */
# define zmemcpy _fmemcpy
# define zmemzero(dest, len) _fmemset(dest, 0, len)
-# else
+# else
# define zmemcpy memcpy
# define zmemzero(dest, len) memset(dest, 0, len)
# endif
#else
- extern void zmemcpy OF((Byte* dest, Byte* source, uInt len));
- extern void zmemzero OF((Byte* dest, uInt len));
+ extern void zmemcpy OF((Bytef* dest, Bytef* source, uInt len));
+ extern void zmemzero OF((Bytef* dest, uInt len));
#endif
/* Diagnostic functions */
@@ -175,12 +181,12 @@
extern void z_error OF((char *m));
-voidp zcalloc OF((voidp opaque, unsigned items, unsigned size));
-void zcfree OF((voidp opaque, voidp ptr));
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void zcfree OF((voidpf opaque, voidpf ptr));
#define ZALLOC(strm, items, size) \
(*((strm)->zalloc))((strm)->opaque, (items), (size))
-#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidp)(addr))
+#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
#endif /* _Z_UTIL_H */
