ChangeLog file for zlib
-Changes in 0.79 (28 April 95)
-- add fast inflate (inffast.c)
+Changes in 0.8 (29 April 95)
+- added fast inflate (inffast.c)
+- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
+ is incompatible with previous versions of zlib which returned Z_OK.
+- work around a TurboC compiler bug (bad code for b << 0, see infutil.h)
+- gzread no longer reads one extra byte in certain cases
- In gzio destroy(), don't reference a freed structure
- avoid many warnings for MSDOS
+- avoid the ERROR symbol which is used by MS Windows
Changes in 0.71 (14 April 95)
- Fixed more MSDOS compilation problems :( There is still a bug with
-zlib 0.79 is a beta version of a general purpose compression library.
+zlib 0.8 is a beta version of a general purpose compression library.
+This is the first version with no known bugs. (There may still be
+problem on SGI, to be checked.)
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
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.79 are documented in the file ChangeLog.
+The changes made in version 0.8 are documented in the file ChangeLog.
The main changes since 0.71 are:
-- add fast inflate (inffast.c)
-- In gzio destroy(), don't reference a freed structure
-
-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.
+- added fast inflate (inffast.c)
+- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
+ is incompatible with previous versions of zlib which returned Z_OK.
+- work around a nasty TurboC compiler bug
+
+On MSDOS, this version works in both large and small model. However
+small model compression works only for small values of MEM_LEVEL and
+WBITS (see zutil.h). Small model decompression should work up to WBITS=15.
+This version of zlib does not yet support small or medium model with
+far allocation of big objects.
Copyright (C) 1995 Jean-loup Gailly and Mark Adler
* 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 $ */
+/* $Id: compress.c,v 1.5 1995/04/29 17:18:43 jloup Exp $ */
#include "zlib.h"
if (err != Z_OK) return err;
err = deflate(&stream, Z_FINISH);
- if (err != Z_OK) {
+ if (err != Z_STREAM_END) {
deflateEnd(&stream);
- return err;
+ return err == Z_OK ? Z_BUF_ERROR : err;
}
*destLen = stream.total_out;
*
*/
-/* $Id: deflate.c,v 1.4 1995/04/14 19:49:46 jloup Exp $ */
+/* $Id: deflate.c,v 1.5 1995/04/29 16:52:05 jloup Exp $ */
#include "deflate.h"
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));
+local void putShortMSB __P((deflate_state *s, uInt b));
+local void flush_pending __P((z_stream *strm));
+local int read_buf __P((z_stream *strm, char *buf, unsigned size));
#ifdef ASMV
void match_init __P((void)); /* asm code initialization */
#endif
s->level = level;
s->strategy = strategy;
- s->method = method;
+ s->method = (Byte)method;
return deflateReset(strm);
}
deflate_state *s;
uInt b;
{
- put_byte(s, b >> 8);
- put_byte(s, b & 0xff);
+ put_byte(s, (Byte)(b >> 8));
+ put_byte(s, (Byte)(b & 0xff));
}
/* =========================================================================
}
Assert(strm->avail_out > 0, "bug2");
- if (flush != Z_FINISH || strm->state->noheader) return Z_OK;
+ if (flush != Z_FINISH) return Z_OK;
+ if (strm->state->noheader) return Z_STREAM_END;
/* Write the zlib trailer (adler32) */
- putShortMSB(strm->state, strm->state->adler >> 16);
- putShortMSB(strm->state, strm->state->adler & 0xffff);
+ putShortMSB(strm->state, (uInt)(strm->state->adler >> 16));
+ putShortMSB(strm->state, (uInt)(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;
+ return strm->state->pending != 0 ? Z_OK : Z_STREAM_END;
}
/* ========================================================================= */
* For conditions of distribution and use, see copyright notice in zlib.h
*/
-/* $Id: example.c,v 1.5 1995/04/14 20:35:56 jloup Exp $ */
+/* $Id: example.c,v 1.6 1995/04/29 16:53:46 jloup Exp $ */
#include <stdio.h>
#include "zlib.h"
+#ifdef STDC
+# include <string.h>
+#endif
+
+extern void exit __P((int));
+
#define BUFLEN 4096
#define local static
char *hello = "hello world";
+void test_compress __P((void));
+void test_gzio __P((char *out, char *in));
+void test_deflate __P((Byte compr[]));
+void test_inflate __P((Byte compr[]));
+void main __P((int argc, char *argv[]));
+
/* ===========================================================================
* Test compress() and uncompress()
*/
int err;
uLong len = strlen(hello)+1;
- err = compress(compr, &comprLen, hello, len);
+ err = compress(compr, &comprLen, (Byte*)hello, len);
CHECK_ERR(err, "compress");
- strcpy(uncompr, "garbage");
+ strcpy((char*)uncompr, "garbage");
err = uncompress(uncompr, &uncomprLen, compr, comprLen);
CHECK_ERR(err, "uncompress");
- if (strcmp(uncompr, hello)) {
+ if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad uncompress\n");
} else {
printf("uncompress(): %s\n", uncompr);
if (file == NULL) {
fprintf(stderr, "gzopen error\n");
}
- strcpy(uncompr, "garbage");
+ strcpy((char*)uncompr, "garbage");
uncomprLen = gzread(file, uncompr, uncomprLen);
if (uncomprLen != len) {
}
gzclose(file);
- if (strcmp(uncompr, hello)) {
+ if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad gzread\n");
} else {
printf("gzread(): %s\n", uncompr);
}
/* ===========================================================================
- * Test deflate() with small buffers, return the compressed length.
+ * Test deflate() with small buffers
*/
-uLong test_deflate(compr)
+void test_deflate(compr)
Byte compr[];
{
z_stream c_stream; /* compression stream */
CHECK_ERR(err, "deflate");
}
/* Finish the stream, still forcing small buffers: */
- do {
+ for (;;) {
c_stream.avail_out = 1;
err = deflate(&c_stream, Z_FINISH);
+ if (err == Z_STREAM_END) break;
CHECK_ERR(err, "deflate");
- } while (c_stream.avail_out == 0);
+ }
err = deflateEnd(&c_stream);
CHECK_ERR(err, "deflateEnd");
-
- return c_stream.total_out;
}
/* ===========================================================================
int err;
z_stream d_stream; /* decompression stream */
- strcpy(uncompr, "garbage");
+ strcpy((char*)uncompr, "garbage");
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
err = inflateEnd(&d_stream);
CHECK_ERR(err, "inflateEnd");
- if (strcmp(uncompr, hello)) {
+ if (strcmp((char*)uncompr, hello)) {
fprintf(stderr, "bad inflate\n");
} else {
printf("inflate(): %s\n", uncompr);
char *argv[];
{
local Byte compr[BUFLEN];
- uLong comprLen;
if (zlib_version[0] != ZLIB_VERSION[0]) {
fprintf(stderr, "incompatible zlib version\n");
test_gzio((argc > 1 ? argv[1] : "foo.gz"),
(argc > 2 ? argv[2] : "foo.gz"));
- comprLen = test_deflate(compr);
+ test_deflate(compr);
test_inflate(compr);
* 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 $ */
+/* $Id: gzio.c,v 1.5 1995/04/29 17:13:56 jloup Exp $ */
#include <stdio.h>
} gz_stream;
-/* ===========================================================================
+local int destroy __P((gz_stream *s));
+local gzFile gz_open __P((char *path, char *mode, int fd));
+local void putLong __P((FILE *file, uLong x));
+local uLong getLong __P((Byte *buf));
+
+ /* ===========================================================================
* Cleanup then free the given gz_stream. Return a zlib error code.
*/
local int destroy (s)
if (len != 0) {
if (fwrite(s->outbuf, 1, len, s->file) != len) {
s->z_err = Z_ERRNO;
- break;
+ return Z_ERRNO;
}
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
+ /* 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);
+ done = (s->stream.avail_out != 0 || s->z_err == Z_STREAM_END);
+
+ if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) break;
}
- return s->z_err;
+ return s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
}
/* ===========================================================================
gzFile file;
{
uInt n;
+ int err;
gz_stream *s = (gz_stream*)file;
if (s == NULL) return Z_STREAM_ERROR;
if (s->mode == 'w') {
- gzflush (file, Z_FINISH);
+ err = gzflush (file, Z_FINISH);
+ if (err != Z_OK) return destroy(file);
+
putLong (s->file, s->crc);
putLong (s->file, s->stream.total_in);
break;
case 3: /* illegal */
DUMPBITS(3)
- s->mode = ERROR;
+ s->mode = INF_ERROR;
z->msg = "invalid block type";
r = Z_DATA_ERROR;
LEAVE
NEEDBITS(32)
if ((~b) >> 16 != (b & 0xffff))
{
- s->mode = ERROR;
+ s->mode = INF_ERROR;
z->msg = "invalid stored block lengths";
r = Z_DATA_ERROR;
LEAVE
#ifndef PKZIP_BUG_WORKAROUND
if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
{
- s->mode = ERROR;
+ s->mode = INF_ERROR;
z->msg = "too many length or distance symbols";
r = Z_DATA_ERROR;
LEAVE
{
r = t;
if (r == Z_DATA_ERROR)
- s->mode = ERROR;
+ s->mode = INF_ERROR;
LEAVE
}
s->sub.trees.index = 0;
if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
(c == 16 && i < 1))
{
- s->mode = ERROR;
+ s->mode = INF_ERROR;
z->msg = "invalid bit length repeat";
r = Z_DATA_ERROR;
LEAVE
if (t != Z_OK)
{
if (t == (uInt)Z_DATA_ERROR)
- s->mode = ERROR;
+ s->mode = INF_ERROR;
r = t;
LEAVE
}
r = Z_OK;
inflate_codes_free(s->sub.codes, z);
LOAD
- s->mode = s->last ? DRY : TYPE;
+ if (!s->last)
+ {
+ s->mode = TYPE;
break;
+ }
+ if (k > 7) /* return unused byte, if any */
+ {
+ Assert(k < 16, "inflate_codes grabbed too many bytes")
+ k -= 8;
+ n++;
+ p--; /* can always return one */
+ }
+ s->mode = DRY;
case DRY:
FLUSH
if (s->read != s->write)
case DONE:
r = Z_STREAM_END;
LEAVE
- case ERROR:
+ case INF_ERROR:
r = Z_DATA_ERROR;
LEAVE
default:
}
-int inflate_blocks_free(s, z, c, e)
+int inflate_blocks_free(s, z, c)
struct inflate_blocks_state *s;
z_stream *z;
uLong *c;
-int *e;
{
- *e = (int)(s->bitk > 7 ? (s->bitb >> (s->bitk & 7)) & 0xff : -1);
if (s->checkfn != Z_NULL)
*c = s->check;
if (s->mode == BTREE || s->mode == DTREE)
struct inflate_blocks_state;
extern struct inflate_blocks_state * inflate_blocks_new __P((
- z_stream *,
- check_func checkfn, /* check function */
- uInt)); /* window size */
+ z_stream *z,
+ check_func c, /* check function */
+ uInt w)); /* window size */
extern int inflate_blocks __P((
struct inflate_blocks_state *,
extern int inflate_blocks_free __P((
struct inflate_blocks_state *,
z_stream *,
- uLong *, /* check value on output */
- int *)); /* possible leftover byte to return */
+ uLong *)); /* check value on output */
#include "infutil.h"
#include "inffast.h"
+struct inflate_codes_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
+++ /dev/null
-/* 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 */
-
- /* 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 */
-
- /* mode independent information */
- int nowrap; /* flag for no wrapper */
- uInt wbits; /* log2(window size) (8..15, defaults to 15) */
-
-};
-
-
-int inflateInit(z)
-z_stream *z;
-{
- return inflateInit2(z, WBITS);
-}
-
-
-int inflateInit2(z, w)
-z_stream *z;
-int w;
-{
- /* initialize state */
- 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;
-
- /* handle undocumented nowrap option (no zlib header or check) */
- z->state->nowrap = 0;
- if (w < 0)
- {
- w = - w;
- z->state->nowrap = 1;
- z->state->mode = START;
- }
-
- /* set window size */
- if (w < 8 || w > 15)
- {
- inflateEnd(z);
- return Z_STREAM_ERROR;
- }
- z->state->wbits = w;
- 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->wbits)
- {
- 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,1<< z->state->wbits)) == 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->nowrap)
- {
- if (r != -1)
- z->msg = "inflate bug--took one too many bytes";
- z->state->mode = r == -1 ? DONE : ERROR;
- break;
- }
- 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);
-}
CHECK2, /* two check bytes to go */
CHECK1, /* one check byte to go */
DONE, /* finished check, done */
- ERROR} /* got an error--stay here */
+ INF_ERROR}/* got an error--stay here */
mode; /* current inflate mode */
/* mode dependent information */
z_stream *z;
int f;
{
- int r;
+ int r = f; /* to avoid warning about unused f */
uInt b;
uLong c;
if (z->avail_in == 0) return r; r = Z_OK;
if (((z->state->sub.method = NEXTBYTE) & 0xf != DEFLATED))
{
- z->state->mode = ERROR;
+ z->state->mode = INF_ERROR;
z->msg = "unknown compression method";
return Z_DATA_ERROR;
}
if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
{
- z->state->mode = ERROR;
+ z->state->mode = INF_ERROR;
z->msg = "invalid window size";
return Z_DATA_ERROR;
}
if (z->avail_in == 0) return r; r = Z_OK;
if ((b = NEXTBYTE) & 0x20)
{
- z->state->mode = ERROR;
+ z->state->mode = INF_ERROR;
z->msg = "invalid reserved bit";
return Z_DATA_ERROR;
}
if (((z->state->sub.method << 8) + b) % 31)
{
- z->state->mode = ERROR;
+ z->state->mode = INF_ERROR;
z->msg = "incorrect header check";
return Z_DATA_ERROR;
}
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);
+ inflate_blocks_free(z->state->sub.blocks, z, &c);
if (z->state->nowrap)
{
- if (r != -1)
- z->msg = "inflate bug--took one too many bytes";
- z->state->mode = r == -1 ? DONE : ERROR;
+ z->state->mode = DONE;
break;
}
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;
if (z->state->sub.check.was != z->state->sub.check.need)
{
- z->state->mode = ERROR;
+ z->state->mode = INF_ERROR;
z->msg = "incorrect data check";
return Z_DATA_ERROR;
}
z->state->mode = DONE;
case DONE:
return Z_STREAM_END;
- case ERROR:
+ case INF_ERROR:
return Z_DATA_ERROR;
default:
return Z_STREAM_ERROR;
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);
+ inflate_blocks_free(z->state->sub.blocks, z, &c);
ZFREE(z, z->state);
z->state = Z_NULL;
return Z_OK;
#include <stdlib.h>
#include "zutil.h"
+void main __P((void));
+
/* 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
break;
}
inflateEnd(&z);
- fprintf(stderr, "%d bytes in, %d bytes out\n", z.total_in, z.total_out);
+ fprintf(stderr, "%ld bytes in, %ld bytes out\n", z.total_in, z.total_out);
if (z.msg != NULL)
fprintf(stderr, "msg is <%s>\n", z.msg);
}
{
Assert(s == sizeof(inflate_huft) && n <= fixed_left,
"inflate_trees falloc overflow");
+ if (q) s++; /* to make some compilers happy */
fixed_left -= n;
return (voidp)(fixed_mem + fixed_left);
}
voidp p;
{
Assert(0, "inflate_trees ffree called!");
+ if (q) q = p; /* to make some compilers happy */
}
q = s->read;
/* compute number of bytes to copy as far as end of window */
- n = (q <= s->write ? s->write : s->end) - q;
+ n = (uInt)((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;
s->write = s->window;
/* compute bytes to copy */
- n = s->write - q;
+ n = (uInt)(s->write - q);
if (n > z->avail_out) n = z->avail_out;
if (n && r == Z_BUF_ERROR) r = Z_OK;
CODES, /* processing fixed or dynamic block */
DRY, /* output remaining window bytes */
DONE, /* finished last block, done */
- ERROR} /* got a data error--stuck here */
+ INF_ERROR}/* got a data error--stuck here */
mode; /* current inflate_block mode */
/* mode dependent information */
#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;}}
+#ifdef __TURBOC__ /* bug in TurboC compiler, bad code for b << 0 */
+# define NEEDBITS(j) {\
+ while(k<(j)){NEEDBYTE;b=k?b|(((uLong)NEXTBYTE)<<k):NEXTBYTE;k+=8;}\
+}
+#else
+# define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
+#endif
#define DUMPBITS(j) {b>>=(j);k-=(j);}
/* output bytes */
#define WAVAIL (q<s->read?s->read-q-1:s->end-q)
* or in pipe mode.
*/
-/* $Id: minigzip.c,v 1.2 1995/04/14 20:03:12 jloup Exp $ */
+/* $Id: minigzip.c,v 1.3 1995/04/29 14:27:21 jloup Exp $ */
#include <stdio.h>
#include "zlib.h"
-extern void exit __P((int));
+extern void exit __P((int));
+extern int unlink __P((const char *));
+
+#ifdef STDC
+# include <string.h>
+#endif
#ifdef MSDOS
-# include <fcntl.h> /* ??? find where setmode declared */
+# include <fcntl.h>
+# include <io.h>
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
# define SET_BINARY_MODE(file)
char *prog;
+void error __P((char *msg));
+void gz_compress __P((FILE *in, gzFile out));
+void gz_uncompress __P((gzFile in, FILE *out));
+void file_compress __P((char *file));
+void file_uncompress __P((char *file));
+void main __P((int argc, char *argv[]));
+
/* ===========================================================================
* Display error message and exit
*/
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
*/
-/* $Id: trees.c,v 1.2 1995/04/10 16:21:44 jloup Exp $ */
+/* $Id: trees.c,v 1.3 1995/04/29 13:49:46 jloup Exp $ */
#include "deflate.h"
while (n < 7) bin_freq += s->dyn_ltree[n++].Freq;
while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq;
while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq;
- s->data_type = bin_freq > (ascii_freq >> 2) ? BINARY : ASCII;
+ s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? BINARY : ASCII);
}
/* ===========================================================================
* For conditions of distribution and use, see copyright notice in zlib.h
*/
-/* $Id: zconf.h,v 1.8 1995/04/14 20:59:22 jloup Exp $ */
+/* $Id: zconf.h,v 1.9 1995/04/29 12:02:14 jloup Exp $ */
#ifndef _ZCONF_H
#define _ZCONF_H
#if defined(MSDOS) && !defined(__32BIT__)
# define MAXSEG_64K
#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(__STDC__))
+# define STDC
+#endif
#ifdef MAXSEG_64K
# define MAX_MEM_LEVEL 8
/* Type declarations */
#ifndef __P /* function prototypes */
-# if defined(__STDC__) || defined(MSDOS)
+# ifdef STDC
# define __P(args) args
# else
# define __P(args) ()
typedef unsigned long uLong; /* 32 bits or more */
#endif
#ifndef voidp
-# if defined(__STDC__) || defined(MSDOS)
+# ifdef STDC
typedef void *voidp;
# else
typedef Byte *voidp;
/* zlib.h -- interface of the 'zlib' general purpose compression library
- version 0.79 April 28th, 1995.
+ version 0.8 April 29th, 1995.
Copyright (C) 1995 Jean-loup Gailly and Mark Adler
#include "zconf.h"
-#define ZLIB_VERSION "0.79"
+#define ZLIB_VERSION "0.8"
/*
The 'zlib' compression library provides in-memory 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 12 bytes.
+ If the parameter flush is set to Z_FINISH, all pending input is processed,
+ all pending output is flushed and deflate returns with Z_STREAM_END if there
+ was enough output space; if deflate returns with Z_OK, this function must be
+ called again with Z_FINISH and more output space (updated avail_out) but no
+ more input data, until it returns with Z_STREAM_END or an error. After
+ deflate has returned Z_STREAM_END, the only possible operations on the
+ stream are deflateReset or deflateEnd.
+
+ 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 12 bytes. If deflate does not return
+ Z_STREAM_END, then it must be called again as described above.
deflate() may update 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() returns 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. ??? to be changed (use Z_STEAM_END) */
+ deflate() returns Z_OK if some progress has been made (more input
+ processed or more output produced), Z_STREAM_END if all input has been
+ consumed and all output has been produced (only when flush is set to
+ Z_FINISH), 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.
+*/
extern int deflateEnd __P((z_stream *strm));
/*
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).
+ error number (see function gzerror below). gzflush returns Z_OK if
+ the flush parameter is Z_FINISH and all output could be flushed.
gzflush should be called only when strictly necessary because it can
degrade compression.
*/
* For conditions of distribution and use, see copyright notice in zlib.h
*/
-/* $Id: zutil.c,v 1.5 1995/04/14 21:30:23 jloup Exp $ */
+/* $Id: zutil.c,v 1.6 1995/04/29 14:54:02 jloup Exp $ */
#include <stdio.h>
}
#endif
-#if defined(MSDOS) && !defined(USE_CALLOC)
+#if defined(MSDOS) && !defined(__SMALL__) && !defined(M_I86SM)
# ifdef __TURBOC__
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
voidp zcalloc (voidp opaque, unsigned items, unsigned size)
{
- voidp buf;
+ voidp buf = opaque; /* just to make some compilers happy */
ulg bsize = (ulg)items*size;
if (bsize < 65536L) {
next_ptr--;
return;
}
+ ptr = opaque; /* just to make some compilers happy */
z_error("zcfree: ptr not found");
}
voidp zcalloc (voidp opaque, unsigned items, unsigned size)
{
+ if (opaque) opaque = 0; /* to make compiler happy */
return _halloc((long)items, size);
}
void zcfree (voidp opaque, voidp ptr)
{
+ if (opaque) opaque = 0; /* to make compiler happy */
_hfree(ptr);
}
subject to change. Applications should only use zlib.h.
*/
-/* $Id: zutil.h,v 1.5 1995/04/14 21:22:38 jloup Exp $ */
+/* $Id: zutil.h,v 1.6 1995/04/29 15:52:16 jloup Exp $ */
#ifndef _Z_UTIL_H
#define _Z_UTIL_H
#else
extern int errno;
#endif
-#ifdef __STDC__
+#ifdef STDC
# include <string.h>
-# include <memory.h>
#endif
#ifndef local
# define OS_CODE 0x00
# ifdef __TURBOC__
# include <alloc.h>
-# define exit(n) _exit(n)
# else /* MSC */
# include <malloc.h>
# endif
# define zstrerror(errnum) ""
#endif
-#if defined(__STDC__) && !defined(HAVE_MEMCPY)
+#if defined(STDC) && !defined(HAVE_MEMCPY)
# define HAVE_MEMCPY
#endif
#ifdef HAVE_MEMCPY
projects / zlib.git / commitdiff