mirror of
https://github.com/GRRLIB/GRRLIB.git
synced 2024-11-26 08:42:19 +00:00
Update zlib to version 1.2.11
Configure was called with this line: CHOST=powerpc-eabi ./configure --static --prefix=$DEVKITPRO/portlibs/ppc
This commit is contained in:
Crayon2000
parent
d1804e489c
commit
963592548f
20 changed files with 1608 additions and 989 deletions
|
|
@ -1,5 +1,5 @@
|
||||||
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||||
* Copyright (C) 1995-2011 Mark Adler
|
* Copyright (C) 1995-2011, 2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -7,11 +7,9 @@
|
||||||
|
|
||||||
#include "zutil.h"
|
#include "zutil.h"
|
||||||
|
|
||||||
#define local static
|
|
||||||
|
|
||||||
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
||||||
|
|
||||||
#define BASE 65521 /* largest prime smaller than 65536 */
|
#define BASE 65521U /* largest prime smaller than 65536 */
|
||||||
#define NMAX 5552
|
#define NMAX 5552
|
||||||
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
||||||
|
|
||||||
|
|
@ -62,10 +60,10 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
uLong ZEXPORT adler32(adler, buf, len)
|
uLong ZEXPORT adler32_z(adler, buf, len)
|
||||||
uLong adler;
|
uLong adler;
|
||||||
const Bytef *buf;
|
const Bytef *buf;
|
||||||
uInt len;
|
z_size_t len;
|
||||||
{
|
{
|
||||||
unsigned long sum2;
|
unsigned long sum2;
|
||||||
unsigned n;
|
unsigned n;
|
||||||
|
|
@ -132,6 +130,15 @@ uLong ZEXPORT adler32(adler, buf, len)
|
||||||
return adler | (sum2 << 16);
|
return adler | (sum2 << 16);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
uLong ZEXPORT adler32(adler, buf, len)
|
||||||
|
uLong adler;
|
||||||
|
const Bytef *buf;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
return adler32_z(adler, buf, len);
|
||||||
|
}
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
local uLong adler32_combine_(adler1, adler2, len2)
|
local uLong adler32_combine_(adler1, adler2, len2)
|
||||||
uLong adler1;
|
uLong adler1;
|
||||||
|
|
@ -156,7 +163,7 @@ local uLong adler32_combine_(adler1, adler2, len2)
|
||||||
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
||||||
if (sum1 >= BASE) sum1 -= BASE;
|
if (sum1 >= BASE) sum1 -= BASE;
|
||||||
if (sum1 >= BASE) sum1 -= BASE;
|
if (sum1 >= BASE) sum1 -= BASE;
|
||||||
if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
|
if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
|
||||||
if (sum2 >= BASE) sum2 -= BASE;
|
if (sum2 >= BASE) sum2 -= BASE;
|
||||||
return sum1 | (sum2 << 16);
|
return sum1 | (sum2 << 16);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* compress.c -- compress a memory buffer
|
/* compress.c -- compress a memory buffer
|
||||||
* Copyright (C) 1995-2005 Jean-loup Gailly.
|
* Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -28,16 +28,11 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
||||||
{
|
{
|
||||||
z_stream stream;
|
z_stream stream;
|
||||||
int err;
|
int err;
|
||||||
|
const uInt max = (uInt)-1;
|
||||||
|
uLong left;
|
||||||
|
|
||||||
stream.next_in = (z_const Bytef *)source;
|
left = *destLen;
|
||||||
stream.avail_in = (uInt)sourceLen;
|
*destLen = 0;
|
||||||
#ifdef MAXSEG_64K
|
|
||||||
/* Check for source > 64K on 16-bit machine: */
|
|
||||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
|
|
||||||
#endif
|
|
||||||
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.zalloc = (alloc_func)0;
|
||||||
stream.zfree = (free_func)0;
|
stream.zfree = (free_func)0;
|
||||||
|
|
@ -46,15 +41,26 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
||||||
err = deflateInit(&stream, level);
|
err = deflateInit(&stream, level);
|
||||||
if (err != Z_OK) return err;
|
if (err != Z_OK) return err;
|
||||||
|
|
||||||
err = deflate(&stream, Z_FINISH);
|
stream.next_out = dest;
|
||||||
if (err != Z_STREAM_END) {
|
stream.avail_out = 0;
|
||||||
deflateEnd(&stream);
|
stream.next_in = (z_const Bytef *)source;
|
||||||
return err == Z_OK ? Z_BUF_ERROR : err;
|
stream.avail_in = 0;
|
||||||
}
|
|
||||||
*destLen = stream.total_out;
|
|
||||||
|
|
||||||
err = deflateEnd(&stream);
|
do {
|
||||||
return err;
|
if (stream.avail_out == 0) {
|
||||||
|
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||||
|
left -= stream.avail_out;
|
||||||
|
}
|
||||||
|
if (stream.avail_in == 0) {
|
||||||
|
stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
|
||||||
|
sourceLen -= stream.avail_in;
|
||||||
|
}
|
||||||
|
err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
|
||||||
|
} while (err == Z_OK);
|
||||||
|
|
||||||
|
*destLen = stream.total_out;
|
||||||
|
deflateEnd(&stream);
|
||||||
|
return err == Z_STREAM_END ? Z_OK : err;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* crc32.c -- compute the CRC-32 of a data stream
|
/* crc32.c -- compute the CRC-32 of a data stream
|
||||||
* Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
|
* Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*
|
*
|
||||||
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
|
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
|
||||||
|
|
@ -30,17 +30,15 @@
|
||||||
|
|
||||||
#include "zutil.h" /* for STDC and FAR definitions */
|
#include "zutil.h" /* for STDC and FAR definitions */
|
||||||
|
|
||||||
#define local static
|
|
||||||
|
|
||||||
/* Definitions for doing the crc four data bytes at a time. */
|
/* Definitions for doing the crc four data bytes at a time. */
|
||||||
#if !defined(NOBYFOUR) && defined(Z_U4)
|
#if !defined(NOBYFOUR) && defined(Z_U4)
|
||||||
# define BYFOUR
|
# define BYFOUR
|
||||||
#endif
|
#endif
|
||||||
#ifdef BYFOUR
|
#ifdef BYFOUR
|
||||||
local unsigned long crc32_little OF((unsigned long,
|
local unsigned long crc32_little OF((unsigned long,
|
||||||
const unsigned char FAR *, unsigned));
|
const unsigned char FAR *, z_size_t));
|
||||||
local unsigned long crc32_big OF((unsigned long,
|
local unsigned long crc32_big OF((unsigned long,
|
||||||
const unsigned char FAR *, unsigned));
|
const unsigned char FAR *, z_size_t));
|
||||||
# define TBLS 8
|
# define TBLS 8
|
||||||
#else
|
#else
|
||||||
# define TBLS 1
|
# define TBLS 1
|
||||||
|
|
@ -201,10 +199,10 @@ const z_crc_t FAR * ZEXPORT get_crc_table()
|
||||||
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
|
#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
unsigned long ZEXPORT crc32(crc, buf, len)
|
unsigned long ZEXPORT crc32_z(crc, buf, len)
|
||||||
unsigned long crc;
|
unsigned long crc;
|
||||||
const unsigned char FAR *buf;
|
const unsigned char FAR *buf;
|
||||||
uInt len;
|
z_size_t len;
|
||||||
{
|
{
|
||||||
if (buf == Z_NULL) return 0UL;
|
if (buf == Z_NULL) return 0UL;
|
||||||
|
|
||||||
|
|
@ -235,8 +233,29 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
||||||
return crc ^ 0xffffffffUL;
|
return crc ^ 0xffffffffUL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
unsigned long ZEXPORT crc32(crc, buf, len)
|
||||||
|
unsigned long crc;
|
||||||
|
const unsigned char FAR *buf;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
return crc32_z(crc, buf, len);
|
||||||
|
}
|
||||||
|
|
||||||
#ifdef BYFOUR
|
#ifdef BYFOUR
|
||||||
|
|
||||||
|
/*
|
||||||
|
This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
|
||||||
|
integer pointer type. This violates the strict aliasing rule, where a
|
||||||
|
compiler can assume, for optimization purposes, that two pointers to
|
||||||
|
fundamentally different types won't ever point to the same memory. This can
|
||||||
|
manifest as a problem only if one of the pointers is written to. This code
|
||||||
|
only reads from those pointers. So long as this code remains isolated in
|
||||||
|
this compilation unit, there won't be a problem. For this reason, this code
|
||||||
|
should not be copied and pasted into a compilation unit in which other code
|
||||||
|
writes to the buffer that is passed to these routines.
|
||||||
|
*/
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
#define DOLIT4 c ^= *buf4++; \
|
#define DOLIT4 c ^= *buf4++; \
|
||||||
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
|
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
|
||||||
|
|
@ -247,7 +266,7 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
||||||
local unsigned long crc32_little(crc, buf, len)
|
local unsigned long crc32_little(crc, buf, len)
|
||||||
unsigned long crc;
|
unsigned long crc;
|
||||||
const unsigned char FAR *buf;
|
const unsigned char FAR *buf;
|
||||||
unsigned len;
|
z_size_t len;
|
||||||
{
|
{
|
||||||
register z_crc_t c;
|
register z_crc_t c;
|
||||||
register const z_crc_t FAR *buf4;
|
register const z_crc_t FAR *buf4;
|
||||||
|
|
@ -278,7 +297,7 @@ local unsigned long crc32_little(crc, buf, len)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
#define DOBIG4 c ^= *++buf4; \
|
#define DOBIG4 c ^= *buf4++; \
|
||||||
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
|
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
|
||||||
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
|
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
|
||||||
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
|
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
|
||||||
|
|
@ -287,7 +306,7 @@ local unsigned long crc32_little(crc, buf, len)
|
||||||
local unsigned long crc32_big(crc, buf, len)
|
local unsigned long crc32_big(crc, buf, len)
|
||||||
unsigned long crc;
|
unsigned long crc;
|
||||||
const unsigned char FAR *buf;
|
const unsigned char FAR *buf;
|
||||||
unsigned len;
|
z_size_t len;
|
||||||
{
|
{
|
||||||
register z_crc_t c;
|
register z_crc_t c;
|
||||||
register const z_crc_t FAR *buf4;
|
register const z_crc_t FAR *buf4;
|
||||||
|
|
@ -300,7 +319,6 @@ local unsigned long crc32_big(crc, buf, len)
|
||||||
}
|
}
|
||||||
|
|
||||||
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
|
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
|
||||||
buf4--;
|
|
||||||
while (len >= 32) {
|
while (len >= 32) {
|
||||||
DOBIG32;
|
DOBIG32;
|
||||||
len -= 32;
|
len -= 32;
|
||||||
|
|
@ -309,7 +327,6 @@ local unsigned long crc32_big(crc, buf, len)
|
||||||
DOBIG4;
|
DOBIG4;
|
||||||
len -= 4;
|
len -= 4;
|
||||||
}
|
}
|
||||||
buf4++;
|
|
||||||
buf = (const unsigned char FAR *)buf4;
|
buf = (const unsigned char FAR *)buf4;
|
||||||
|
|
||||||
if (len) do {
|
if (len) do {
|
||||||
|
|
|
||||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,5 +1,5 @@
|
||||||
/* deflate.h -- internal compression state
|
/* deflate.h -- internal compression state
|
||||||
* Copyright (C) 1995-2012 Jean-loup Gailly
|
* Copyright (C) 1995-2016 Jean-loup Gailly
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -51,13 +51,16 @@
|
||||||
#define Buf_size 16
|
#define Buf_size 16
|
||||||
/* size of bit buffer in bi_buf */
|
/* size of bit buffer in bi_buf */
|
||||||
|
|
||||||
#define INIT_STATE 42
|
#define INIT_STATE 42 /* zlib header -> BUSY_STATE */
|
||||||
#define EXTRA_STATE 69
|
#ifdef GZIP
|
||||||
#define NAME_STATE 73
|
# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
|
||||||
#define COMMENT_STATE 91
|
#endif
|
||||||
#define HCRC_STATE 103
|
#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
|
||||||
#define BUSY_STATE 113
|
#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
|
||||||
#define FINISH_STATE 666
|
#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
|
||||||
|
#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
|
||||||
|
#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
|
||||||
|
#define FINISH_STATE 666 /* stream complete */
|
||||||
/* Stream status */
|
/* Stream status */
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -83,7 +86,7 @@ typedef struct static_tree_desc_s static_tree_desc;
|
||||||
typedef struct tree_desc_s {
|
typedef struct tree_desc_s {
|
||||||
ct_data *dyn_tree; /* the dynamic tree */
|
ct_data *dyn_tree; /* the dynamic tree */
|
||||||
int max_code; /* largest code with non zero frequency */
|
int max_code; /* largest code with non zero frequency */
|
||||||
static_tree_desc *stat_desc; /* the corresponding static tree */
|
const static_tree_desc *stat_desc; /* the corresponding static tree */
|
||||||
} FAR tree_desc;
|
} FAR tree_desc;
|
||||||
|
|
||||||
typedef ush Pos;
|
typedef ush Pos;
|
||||||
|
|
@ -100,10 +103,10 @@ typedef struct internal_state {
|
||||||
Bytef *pending_buf; /* output still pending */
|
Bytef *pending_buf; /* output still pending */
|
||||||
ulg pending_buf_size; /* size of pending_buf */
|
ulg pending_buf_size; /* size of pending_buf */
|
||||||
Bytef *pending_out; /* next pending byte to output to the stream */
|
Bytef *pending_out; /* next pending byte to output to the stream */
|
||||||
uInt pending; /* nb of bytes in the pending buffer */
|
ulg pending; /* nb of bytes in the pending buffer */
|
||||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||||
gz_headerp gzhead; /* gzip header information to write */
|
gz_headerp gzhead; /* gzip header information to write */
|
||||||
uInt gzindex; /* where in extra, name, or comment */
|
ulg gzindex; /* where in extra, name, or comment */
|
||||||
Byte method; /* can only be DEFLATED */
|
Byte method; /* can only be DEFLATED */
|
||||||
int last_flush; /* value of flush param for previous deflate call */
|
int last_flush; /* value of flush param for previous deflate call */
|
||||||
|
|
||||||
|
|
@ -249,7 +252,7 @@ typedef struct internal_state {
|
||||||
uInt matches; /* number of string matches in current block */
|
uInt matches; /* number of string matches in current block */
|
||||||
uInt insert; /* bytes at end of window left to insert */
|
uInt insert; /* bytes at end of window left to insert */
|
||||||
|
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
|
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
|
||||||
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
|
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -275,7 +278,7 @@ typedef struct internal_state {
|
||||||
/* Output a byte on the stream.
|
/* Output a byte on the stream.
|
||||||
* IN assertion: there is enough room in pending_buf.
|
* IN assertion: there is enough room in pending_buf.
|
||||||
*/
|
*/
|
||||||
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
|
#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
|
||||||
|
|
||||||
|
|
||||||
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
||||||
|
|
@ -309,7 +312,7 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
|
||||||
* used.
|
* used.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifndef DEBUG
|
#ifndef ZLIB_DEBUG
|
||||||
/* Inline versions of _tr_tally for speed: */
|
/* Inline versions of _tr_tally for speed: */
|
||||||
|
|
||||||
#if defined(GEN_TREES_H) || !defined(STDC)
|
#if defined(GEN_TREES_H) || !defined(STDC)
|
||||||
|
|
@ -328,8 +331,8 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
|
||||||
flush = (s->last_lit == s->lit_bufsize-1); \
|
flush = (s->last_lit == s->lit_bufsize-1); \
|
||||||
}
|
}
|
||||||
# define _tr_tally_dist(s, distance, length, flush) \
|
# define _tr_tally_dist(s, distance, length, flush) \
|
||||||
{ uch len = (length); \
|
{ uch len = (uch)(length); \
|
||||||
ush dist = (distance); \
|
ush dist = (ush)(distance); \
|
||||||
s->d_buf[s->last_lit] = dist; \
|
s->d_buf[s->last_lit] = dist; \
|
||||||
s->l_buf[s->last_lit++] = len; \
|
s->l_buf[s->last_lit++] = len; \
|
||||||
dist--; \
|
dist--; \
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* gzguts.h -- zlib internal header definitions for gz* operations
|
/* gzguts.h -- zlib internal header definitions for gz* operations
|
||||||
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
|
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -25,6 +25,10 @@
|
||||||
# include <stdlib.h>
|
# include <stdlib.h>
|
||||||
# include <limits.h>
|
# include <limits.h>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifndef _POSIX_SOURCE
|
||||||
|
# define _POSIX_SOURCE
|
||||||
|
#endif
|
||||||
#include <fcntl.h>
|
#include <fcntl.h>
|
||||||
|
|
||||||
#ifdef _WIN32
|
#ifdef _WIN32
|
||||||
|
|
@ -35,6 +39,10 @@
|
||||||
# include <io.h>
|
# include <io.h>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
||||||
|
# define WIDECHAR
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifdef WINAPI_FAMILY
|
#ifdef WINAPI_FAMILY
|
||||||
# define open _open
|
# define open _open
|
||||||
# define read _read
|
# define read _read
|
||||||
|
|
@ -95,18 +103,19 @@
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* unlike snprintf (which is required in C99, yet still not supported by
|
/* unlike snprintf (which is required in C99), _snprintf does not guarantee
|
||||||
Microsoft more than a decade later!), _snprintf does not guarantee null
|
null termination of the result -- however this is only used in gzlib.c where
|
||||||
termination of the result -- however this is only used in gzlib.c where
|
|
||||||
the result is assured to fit in the space provided */
|
the result is assured to fit in the space provided */
|
||||||
#ifdef _MSC_VER
|
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||||
# define snprintf _snprintf
|
# define snprintf _snprintf
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef local
|
#ifndef local
|
||||||
# define local static
|
# define local static
|
||||||
#endif
|
#endif
|
||||||
/* compile with -Dlocal if your debugger can't find static symbols */
|
/* since "static" is used to mean two completely different things in C, we
|
||||||
|
define "local" for the non-static meaning of "static", for readability
|
||||||
|
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||||
|
|
||||||
/* gz* functions always use library allocation functions */
|
/* gz* functions always use library allocation functions */
|
||||||
#ifndef STDC
|
#ifndef STDC
|
||||||
|
|
@ -170,7 +179,7 @@ typedef struct {
|
||||||
char *path; /* path or fd for error messages */
|
char *path; /* path or fd for error messages */
|
||||||
unsigned size; /* buffer size, zero if not allocated yet */
|
unsigned size; /* buffer size, zero if not allocated yet */
|
||||||
unsigned want; /* requested buffer size, default is GZBUFSIZE */
|
unsigned want; /* requested buffer size, default is GZBUFSIZE */
|
||||||
unsigned char *in; /* input buffer */
|
unsigned char *in; /* input buffer (double-sized when writing) */
|
||||||
unsigned char *out; /* output buffer (double-sized when reading) */
|
unsigned char *out; /* output buffer (double-sized when reading) */
|
||||||
int direct; /* 0 if processing gzip, 1 if transparent */
|
int direct; /* 0 if processing gzip, 1 if transparent */
|
||||||
/* just for reading */
|
/* just for reading */
|
||||||
|
|
|
||||||
|
|
@ -1,11 +1,11 @@
|
||||||
/* gzlib.c -- zlib functions common to reading and writing gzip files
|
/* gzlib.c -- zlib functions common to reading and writing gzip files
|
||||||
* Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler
|
* Copyright (C) 2004-2017 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "gzguts.h"
|
#include "gzguts.h"
|
||||||
|
|
||||||
#if defined(_WIN32) && !defined(__BORLANDC__)
|
#if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
|
||||||
# define LSEEK _lseeki64
|
# define LSEEK _lseeki64
|
||||||
#else
|
#else
|
||||||
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
|
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
|
||||||
|
|
@ -94,7 +94,7 @@ local gzFile gz_open(path, fd, mode)
|
||||||
const char *mode;
|
const char *mode;
|
||||||
{
|
{
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
size_t len;
|
z_size_t len;
|
||||||
int oflag;
|
int oflag;
|
||||||
#ifdef O_CLOEXEC
|
#ifdef O_CLOEXEC
|
||||||
int cloexec = 0;
|
int cloexec = 0;
|
||||||
|
|
@ -188,10 +188,10 @@ local gzFile gz_open(path, fd, mode)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* save the path name for error messages */
|
/* save the path name for error messages */
|
||||||
#ifdef _WIN32
|
#ifdef WIDECHAR
|
||||||
if (fd == -2) {
|
if (fd == -2) {
|
||||||
len = wcstombs(NULL, path, 0);
|
len = wcstombs(NULL, path, 0);
|
||||||
if (len == (size_t)-1)
|
if (len == (z_size_t)-1)
|
||||||
len = 0;
|
len = 0;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
|
|
@ -202,7 +202,7 @@ local gzFile gz_open(path, fd, mode)
|
||||||
free(state);
|
free(state);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
#ifdef _WIN32
|
#ifdef WIDECHAR
|
||||||
if (fd == -2)
|
if (fd == -2)
|
||||||
if (len)
|
if (len)
|
||||||
wcstombs(state->path, path, len + 1);
|
wcstombs(state->path, path, len + 1);
|
||||||
|
|
@ -211,7 +211,7 @@ local gzFile gz_open(path, fd, mode)
|
||||||
else
|
else
|
||||||
#endif
|
#endif
|
||||||
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
snprintf(state->path, len + 1, "%s", (const char *)path);
|
(void)snprintf(state->path, len + 1, "%s", (const char *)path);
|
||||||
#else
|
#else
|
||||||
strcpy(state->path, path);
|
strcpy(state->path, path);
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -239,7 +239,7 @@ local gzFile gz_open(path, fd, mode)
|
||||||
|
|
||||||
/* open the file with the appropriate flags (or just use fd) */
|
/* open the file with the appropriate flags (or just use fd) */
|
||||||
state->fd = fd > -1 ? fd : (
|
state->fd = fd > -1 ? fd : (
|
||||||
#ifdef _WIN32
|
#ifdef WIDECHAR
|
||||||
fd == -2 ? _wopen(path, oflag, 0666) :
|
fd == -2 ? _wopen(path, oflag, 0666) :
|
||||||
#endif
|
#endif
|
||||||
open((const char *)path, oflag, 0666));
|
open((const char *)path, oflag, 0666));
|
||||||
|
|
@ -248,8 +248,10 @@ local gzFile gz_open(path, fd, mode)
|
||||||
free(state);
|
free(state);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
if (state->mode == GZ_APPEND)
|
if (state->mode == GZ_APPEND) {
|
||||||
|
LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
|
||||||
state->mode = GZ_WRITE; /* simplify later checks */
|
state->mode = GZ_WRITE; /* simplify later checks */
|
||||||
|
}
|
||||||
|
|
||||||
/* save the current position for rewinding (only if reading) */
|
/* save the current position for rewinding (only if reading) */
|
||||||
if (state->mode == GZ_READ) {
|
if (state->mode == GZ_READ) {
|
||||||
|
|
@ -291,7 +293,7 @@ gzFile ZEXPORT gzdopen(fd, mode)
|
||||||
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
|
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
|
||||||
return NULL;
|
return NULL;
|
||||||
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */
|
(void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
|
||||||
#else
|
#else
|
||||||
sprintf(path, "<fd:%d>", fd); /* for debugging */
|
sprintf(path, "<fd:%d>", fd); /* for debugging */
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -301,7 +303,7 @@ gzFile ZEXPORT gzdopen(fd, mode)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* -- see zlib.h -- */
|
/* -- see zlib.h -- */
|
||||||
#ifdef _WIN32
|
#ifdef WIDECHAR
|
||||||
gzFile ZEXPORT gzopen_w(path, mode)
|
gzFile ZEXPORT gzopen_w(path, mode)
|
||||||
const wchar_t *path;
|
const wchar_t *path;
|
||||||
const char *mode;
|
const char *mode;
|
||||||
|
|
@ -329,6 +331,8 @@ int ZEXPORT gzbuffer(file, size)
|
||||||
return -1;
|
return -1;
|
||||||
|
|
||||||
/* check and set requested size */
|
/* check and set requested size */
|
||||||
|
if ((size << 1) < size)
|
||||||
|
return -1; /* need to be able to double it */
|
||||||
if (size < 2)
|
if (size < 2)
|
||||||
size = 2; /* need two bytes to check magic header */
|
size = 2; /* need two bytes to check magic header */
|
||||||
state->want = size;
|
state->want = size;
|
||||||
|
|
@ -604,14 +608,13 @@ void ZLIB_INTERNAL gz_error(state, err, msg)
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
|
(void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
|
||||||
"%s%s%s", state->path, ": ", msg);
|
"%s%s%s", state->path, ": ", msg);
|
||||||
#else
|
#else
|
||||||
strcpy(state->msg, state->path);
|
strcpy(state->msg, state->path);
|
||||||
strcat(state->msg, ": ");
|
strcat(state->msg, ": ");
|
||||||
strcat(state->msg, msg);
|
strcat(state->msg, msg);
|
||||||
#endif
|
#endif
|
||||||
return;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifndef INT_MAX
|
#ifndef INT_MAX
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* gzread.c -- zlib functions for reading gzip files
|
/* gzread.c -- zlib functions for reading gzip files
|
||||||
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
|
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -12,6 +12,7 @@ local int gz_look OF((gz_statep));
|
||||||
local int gz_decomp OF((gz_statep));
|
local int gz_decomp OF((gz_statep));
|
||||||
local int gz_fetch OF((gz_statep));
|
local int gz_fetch OF((gz_statep));
|
||||||
local int gz_skip OF((gz_statep, z_off64_t));
|
local int gz_skip OF((gz_statep, z_off64_t));
|
||||||
|
local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
|
||||||
|
|
||||||
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
|
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
|
||||||
state->fd, and update state->eof, state->err, and state->msg as appropriate.
|
state->fd, and update state->eof, state->err, and state->msg as appropriate.
|
||||||
|
|
@ -24,13 +25,17 @@ local int gz_load(state, buf, len, have)
|
||||||
unsigned *have;
|
unsigned *have;
|
||||||
{
|
{
|
||||||
int ret;
|
int ret;
|
||||||
|
unsigned get, max = ((unsigned)-1 >> 2) + 1;
|
||||||
|
|
||||||
*have = 0;
|
*have = 0;
|
||||||
do {
|
do {
|
||||||
ret = read(state->fd, buf + *have, len - *have);
|
get = len - *have;
|
||||||
|
if (get > max)
|
||||||
|
get = max;
|
||||||
|
ret = read(state->fd, buf + *have, get);
|
||||||
if (ret <= 0)
|
if (ret <= 0)
|
||||||
break;
|
break;
|
||||||
*have += ret;
|
*have += (unsigned)ret;
|
||||||
} while (*have < len);
|
} while (*have < len);
|
||||||
if (ret < 0) {
|
if (ret < 0) {
|
||||||
gz_error(state, Z_ERRNO, zstrerror());
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
|
@ -94,10 +99,8 @@ local int gz_look(state)
|
||||||
state->in = (unsigned char *)malloc(state->want);
|
state->in = (unsigned char *)malloc(state->want);
|
||||||
state->out = (unsigned char *)malloc(state->want << 1);
|
state->out = (unsigned char *)malloc(state->want << 1);
|
||||||
if (state->in == NULL || state->out == NULL) {
|
if (state->in == NULL || state->out == NULL) {
|
||||||
if (state->out != NULL)
|
free(state->out);
|
||||||
free(state->out);
|
free(state->in);
|
||||||
if (state->in != NULL)
|
|
||||||
free(state->in);
|
|
||||||
gz_error(state, Z_MEM_ERROR, "out of memory");
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
|
@ -284,33 +287,17 @@ local int gz_skip(state, len)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* -- see zlib.h -- */
|
/* Read len bytes into buf from file, or less than len up to the end of the
|
||||||
int ZEXPORT gzread(file, buf, len)
|
input. Return the number of bytes read. If zero is returned, either the
|
||||||
gzFile file;
|
end of file was reached, or there was an error. state->err must be
|
||||||
voidp buf;
|
consulted in that case to determine which. */
|
||||||
unsigned len;
|
local z_size_t gz_read(state, buf, len)
|
||||||
{
|
|
||||||
unsigned got, n;
|
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
z_streamp strm;
|
voidp buf;
|
||||||
|
z_size_t len;
|
||||||
/* get internal structure */
|
{
|
||||||
if (file == NULL)
|
z_size_t got;
|
||||||
return -1;
|
unsigned n;
|
||||||
state = (gz_statep)file;
|
|
||||||
strm = &(state->strm);
|
|
||||||
|
|
||||||
/* check that we're reading and that there's no (serious) error */
|
|
||||||
if (state->mode != GZ_READ ||
|
|
||||||
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
/* since an int is returned, make sure len fits in one, otherwise return
|
|
||||||
with an error (this avoids the flaw in the interface) */
|
|
||||||
if ((int)len < 0) {
|
|
||||||
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* if len is zero, avoid unnecessary operations */
|
/* if len is zero, avoid unnecessary operations */
|
||||||
if (len == 0)
|
if (len == 0)
|
||||||
|
|
@ -320,32 +307,38 @@ int ZEXPORT gzread(file, buf, len)
|
||||||
if (state->seek) {
|
if (state->seek) {
|
||||||
state->seek = 0;
|
state->seek = 0;
|
||||||
if (gz_skip(state, state->skip) == -1)
|
if (gz_skip(state, state->skip) == -1)
|
||||||
return -1;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* get len bytes to buf, or less than len if at the end */
|
/* get len bytes to buf, or less than len if at the end */
|
||||||
got = 0;
|
got = 0;
|
||||||
do {
|
do {
|
||||||
|
/* set n to the maximum amount of len that fits in an unsigned int */
|
||||||
|
n = -1;
|
||||||
|
if (n > len)
|
||||||
|
n = len;
|
||||||
|
|
||||||
/* first just try copying data from the output buffer */
|
/* first just try copying data from the output buffer */
|
||||||
if (state->x.have) {
|
if (state->x.have) {
|
||||||
n = state->x.have > len ? len : state->x.have;
|
if (state->x.have < n)
|
||||||
|
n = state->x.have;
|
||||||
memcpy(buf, state->x.next, n);
|
memcpy(buf, state->x.next, n);
|
||||||
state->x.next += n;
|
state->x.next += n;
|
||||||
state->x.have -= n;
|
state->x.have -= n;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* output buffer empty -- return if we're at the end of the input */
|
/* output buffer empty -- return if we're at the end of the input */
|
||||||
else if (state->eof && strm->avail_in == 0) {
|
else if (state->eof && state->strm.avail_in == 0) {
|
||||||
state->past = 1; /* tried to read past end */
|
state->past = 1; /* tried to read past end */
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* need output data -- for small len or new stream load up our output
|
/* need output data -- for small len or new stream load up our output
|
||||||
buffer */
|
buffer */
|
||||||
else if (state->how == LOOK || len < (state->size << 1)) {
|
else if (state->how == LOOK || n < (state->size << 1)) {
|
||||||
/* get more output, looking for header if required */
|
/* get more output, looking for header if required */
|
||||||
if (gz_fetch(state) == -1)
|
if (gz_fetch(state) == -1)
|
||||||
return -1;
|
return 0;
|
||||||
continue; /* no progress yet -- go back to copy above */
|
continue; /* no progress yet -- go back to copy above */
|
||||||
/* the copy above assures that we will leave with space in the
|
/* the copy above assures that we will leave with space in the
|
||||||
output buffer, allowing at least one gzungetc() to succeed */
|
output buffer, allowing at least one gzungetc() to succeed */
|
||||||
|
|
@ -353,16 +346,16 @@ int ZEXPORT gzread(file, buf, len)
|
||||||
|
|
||||||
/* large len -- read directly into user buffer */
|
/* large len -- read directly into user buffer */
|
||||||
else if (state->how == COPY) { /* read directly */
|
else if (state->how == COPY) { /* read directly */
|
||||||
if (gz_load(state, (unsigned char *)buf, len, &n) == -1)
|
if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
|
||||||
return -1;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* large len -- decompress directly into user buffer */
|
/* large len -- decompress directly into user buffer */
|
||||||
else { /* state->how == GZIP */
|
else { /* state->how == GZIP */
|
||||||
strm->avail_out = len;
|
state->strm.avail_out = n;
|
||||||
strm->next_out = (unsigned char *)buf;
|
state->strm.next_out = (unsigned char *)buf;
|
||||||
if (gz_decomp(state) == -1)
|
if (gz_decomp(state) == -1)
|
||||||
return -1;
|
return 0;
|
||||||
n = state->x.have;
|
n = state->x.have;
|
||||||
state->x.have = 0;
|
state->x.have = 0;
|
||||||
}
|
}
|
||||||
|
|
@ -374,8 +367,75 @@ int ZEXPORT gzread(file, buf, len)
|
||||||
state->x.pos += n;
|
state->x.pos += n;
|
||||||
} while (len);
|
} while (len);
|
||||||
|
|
||||||
/* return number of bytes read into user buffer (will fit in int) */
|
/* return number of bytes read into user buffer */
|
||||||
return (int)got;
|
return got;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzread(file, buf, len)
|
||||||
|
gzFile file;
|
||||||
|
voidp buf;
|
||||||
|
unsigned len;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* since an int is returned, make sure len fits in one, otherwise return
|
||||||
|
with an error (this avoids a flaw in the interface) */
|
||||||
|
if ((int)len < 0) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* read len or fewer bytes to buf */
|
||||||
|
len = gz_read(state, buf, len);
|
||||||
|
|
||||||
|
/* check for an error */
|
||||||
|
if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* return the number of bytes read (this is assured to fit in an int) */
|
||||||
|
return (int)len;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_size_t ZEXPORT gzfread(buf, size, nitems, file)
|
||||||
|
voidp buf;
|
||||||
|
z_size_t size;
|
||||||
|
z_size_t nitems;
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_size_t len;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* compute bytes to read -- error on overflow */
|
||||||
|
len = nitems * size;
|
||||||
|
if (size && len / size != nitems) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* read len or fewer bytes to buf, return the number of full items read */
|
||||||
|
return len ? gz_read(state, buf, len) / size : 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* -- see zlib.h -- */
|
/* -- see zlib.h -- */
|
||||||
|
|
@ -408,8 +468,8 @@ int ZEXPORT gzgetc(file)
|
||||||
return *(state->x.next)++;
|
return *(state->x.next)++;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* nothing there -- try gzread() */
|
/* nothing there -- try gz_read() */
|
||||||
ret = gzread(file, buf, 1);
|
ret = gz_read(state, buf, 1);
|
||||||
return ret < 1 ? -1 : buf[0];
|
return ret < 1 ? -1 : buf[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -451,7 +511,7 @@ int ZEXPORT gzungetc(c, file)
|
||||||
if (state->x.have == 0) {
|
if (state->x.have == 0) {
|
||||||
state->x.have = 1;
|
state->x.have = 1;
|
||||||
state->x.next = state->out + (state->size << 1) - 1;
|
state->x.next = state->out + (state->size << 1) - 1;
|
||||||
state->x.next[0] = c;
|
state->x.next[0] = (unsigned char)c;
|
||||||
state->x.pos--;
|
state->x.pos--;
|
||||||
state->past = 0;
|
state->past = 0;
|
||||||
return c;
|
return c;
|
||||||
|
|
@ -473,7 +533,7 @@ int ZEXPORT gzungetc(c, file)
|
||||||
}
|
}
|
||||||
state->x.have++;
|
state->x.have++;
|
||||||
state->x.next--;
|
state->x.next--;
|
||||||
state->x.next[0] = c;
|
state->x.next[0] = (unsigned char)c;
|
||||||
state->x.pos--;
|
state->x.pos--;
|
||||||
state->past = 0;
|
state->past = 0;
|
||||||
return c;
|
return c;
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* gzwrite.c -- zlib functions for writing gzip files
|
/* gzwrite.c -- zlib functions for writing gzip files
|
||||||
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
|
* Copyright (C) 2004-2017 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -9,17 +9,19 @@
|
||||||
local int gz_init OF((gz_statep));
|
local int gz_init OF((gz_statep));
|
||||||
local int gz_comp OF((gz_statep, int));
|
local int gz_comp OF((gz_statep, int));
|
||||||
local int gz_zero OF((gz_statep, z_off64_t));
|
local int gz_zero OF((gz_statep, z_off64_t));
|
||||||
|
local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
|
||||||
|
|
||||||
/* Initialize state for writing a gzip file. Mark initialization by setting
|
/* Initialize state for writing a gzip file. Mark initialization by setting
|
||||||
state->size to non-zero. Return -1 on failure or 0 on success. */
|
state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
|
||||||
|
success. */
|
||||||
local int gz_init(state)
|
local int gz_init(state)
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
{
|
{
|
||||||
int ret;
|
int ret;
|
||||||
z_streamp strm = &(state->strm);
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
/* allocate input buffer */
|
/* allocate input buffer (double size for gzprintf) */
|
||||||
state->in = (unsigned char *)malloc(state->want);
|
state->in = (unsigned char *)malloc(state->want << 1);
|
||||||
if (state->in == NULL) {
|
if (state->in == NULL) {
|
||||||
gz_error(state, Z_MEM_ERROR, "out of memory");
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
return -1;
|
return -1;
|
||||||
|
|
@ -47,6 +49,7 @@ local int gz_init(state)
|
||||||
gz_error(state, Z_MEM_ERROR, "out of memory");
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
return -1;
|
return -1;
|
||||||
}
|
}
|
||||||
|
strm->next_in = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* mark state as initialized */
|
/* mark state as initialized */
|
||||||
|
|
@ -62,17 +65,17 @@ local int gz_init(state)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Compress whatever is at avail_in and next_in and write to the output file.
|
/* Compress whatever is at avail_in and next_in and write to the output file.
|
||||||
Return -1 if there is an error writing to the output file, otherwise 0.
|
Return -1 if there is an error writing to the output file or if gz_init()
|
||||||
flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH,
|
fails to allocate memory, otherwise 0. flush is assumed to be a valid
|
||||||
then the deflate() state is reset to start a new gzip stream. If gz->direct
|
deflate() flush value. If flush is Z_FINISH, then the deflate() state is
|
||||||
is true, then simply write to the output file without compressing, and
|
reset to start a new gzip stream. If gz->direct is true, then simply write
|
||||||
ignore flush. */
|
to the output file without compressing, and ignore flush. */
|
||||||
local int gz_comp(state, flush)
|
local int gz_comp(state, flush)
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
int flush;
|
int flush;
|
||||||
{
|
{
|
||||||
int ret, got;
|
int ret, writ;
|
||||||
unsigned have;
|
unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
|
||||||
z_streamp strm = &(state->strm);
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
/* allocate memory if this is the first time through */
|
/* allocate memory if this is the first time through */
|
||||||
|
|
@ -81,12 +84,16 @@ local int gz_comp(state, flush)
|
||||||
|
|
||||||
/* write directly if requested */
|
/* write directly if requested */
|
||||||
if (state->direct) {
|
if (state->direct) {
|
||||||
got = write(state->fd, strm->next_in, strm->avail_in);
|
while (strm->avail_in) {
|
||||||
if (got < 0 || (unsigned)got != strm->avail_in) {
|
put = strm->avail_in > max ? max : strm->avail_in;
|
||||||
gz_error(state, Z_ERRNO, zstrerror());
|
writ = write(state->fd, strm->next_in, put);
|
||||||
return -1;
|
if (writ < 0) {
|
||||||
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
strm->avail_in -= (unsigned)writ;
|
||||||
|
strm->next_in += writ;
|
||||||
}
|
}
|
||||||
strm->avail_in = 0;
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -97,17 +104,21 @@ local int gz_comp(state, flush)
|
||||||
doing Z_FINISH then don't write until we get to Z_STREAM_END */
|
doing Z_FINISH then don't write until we get to Z_STREAM_END */
|
||||||
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
|
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
|
||||||
(flush != Z_FINISH || ret == Z_STREAM_END))) {
|
(flush != Z_FINISH || ret == Z_STREAM_END))) {
|
||||||
have = (unsigned)(strm->next_out - state->x.next);
|
while (strm->next_out > state->x.next) {
|
||||||
if (have && ((got = write(state->fd, state->x.next, have)) < 0 ||
|
put = strm->next_out - state->x.next > (int)max ? max :
|
||||||
(unsigned)got != have)) {
|
(unsigned)(strm->next_out - state->x.next);
|
||||||
gz_error(state, Z_ERRNO, zstrerror());
|
writ = write(state->fd, state->x.next, put);
|
||||||
return -1;
|
if (writ < 0) {
|
||||||
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
state->x.next += writ;
|
||||||
}
|
}
|
||||||
if (strm->avail_out == 0) {
|
if (strm->avail_out == 0) {
|
||||||
strm->avail_out = state->size;
|
strm->avail_out = state->size;
|
||||||
strm->next_out = state->out;
|
strm->next_out = state->out;
|
||||||
|
state->x.next = state->out;
|
||||||
}
|
}
|
||||||
state->x.next = strm->next_out;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* compress */
|
/* compress */
|
||||||
|
|
@ -129,7 +140,8 @@ local int gz_comp(state, flush)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Compress len zeros to output. Return -1 on error, 0 on success. */
|
/* Compress len zeros to output. Return -1 on a write error or memory
|
||||||
|
allocation failure by gz_comp(), or 0 on success. */
|
||||||
local int gz_zero(state, len)
|
local int gz_zero(state, len)
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
z_off64_t len;
|
z_off64_t len;
|
||||||
|
|
@ -161,32 +173,14 @@ local int gz_zero(state, len)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* -- see zlib.h -- */
|
/* Write len bytes from buf to file. Return the number of bytes written. If
|
||||||
int ZEXPORT gzwrite(file, buf, len)
|
the returned value is less than len, then there was an error. */
|
||||||
gzFile file;
|
local z_size_t gz_write(state, buf, len)
|
||||||
voidpc buf;
|
|
||||||
unsigned len;
|
|
||||||
{
|
|
||||||
unsigned put = len;
|
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
z_streamp strm;
|
voidpc buf;
|
||||||
|
z_size_t len;
|
||||||
/* get internal structure */
|
{
|
||||||
if (file == NULL)
|
z_size_t put = len;
|
||||||
return 0;
|
|
||||||
state = (gz_statep)file;
|
|
||||||
strm = &(state->strm);
|
|
||||||
|
|
||||||
/* check that we're writing and that there's no error */
|
|
||||||
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
/* since an int is returned, make sure len fits in one, otherwise return
|
|
||||||
with an error (this avoids the flaw in the interface) */
|
|
||||||
if ((int)len < 0) {
|
|
||||||
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* if len is zero, avoid unnecessary operations */
|
/* if len is zero, avoid unnecessary operations */
|
||||||
if (len == 0)
|
if (len == 0)
|
||||||
|
|
@ -209,14 +203,15 @@ int ZEXPORT gzwrite(file, buf, len)
|
||||||
do {
|
do {
|
||||||
unsigned have, copy;
|
unsigned have, copy;
|
||||||
|
|
||||||
if (strm->avail_in == 0)
|
if (state->strm.avail_in == 0)
|
||||||
strm->next_in = state->in;
|
state->strm.next_in = state->in;
|
||||||
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
|
have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
|
||||||
|
state->in);
|
||||||
copy = state->size - have;
|
copy = state->size - have;
|
||||||
if (copy > len)
|
if (copy > len)
|
||||||
copy = len;
|
copy = len;
|
||||||
memcpy(state->in + have, buf, copy);
|
memcpy(state->in + have, buf, copy);
|
||||||
strm->avail_in += copy;
|
state->strm.avail_in += copy;
|
||||||
state->x.pos += copy;
|
state->x.pos += copy;
|
||||||
buf = (const char *)buf + copy;
|
buf = (const char *)buf + copy;
|
||||||
len -= copy;
|
len -= copy;
|
||||||
|
|
@ -226,19 +221,83 @@ int ZEXPORT gzwrite(file, buf, len)
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
/* consume whatever's left in the input buffer */
|
/* consume whatever's left in the input buffer */
|
||||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
/* directly compress user buffer to file */
|
/* directly compress user buffer to file */
|
||||||
strm->avail_in = len;
|
state->strm.next_in = (z_const Bytef *)buf;
|
||||||
strm->next_in = (z_const Bytef *)buf;
|
do {
|
||||||
state->x.pos += len;
|
unsigned n = (unsigned)-1;
|
||||||
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
if (n > len)
|
||||||
return 0;
|
n = len;
|
||||||
|
state->strm.avail_in = n;
|
||||||
|
state->x.pos += n;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return 0;
|
||||||
|
len -= n;
|
||||||
|
} while (len);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* input was all buffered or compressed (put will fit in int) */
|
/* input was all buffered or compressed */
|
||||||
return (int)put;
|
return put;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzwrite(file, buf, len)
|
||||||
|
gzFile file;
|
||||||
|
voidpc buf;
|
||||||
|
unsigned len;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* since an int is returned, make sure len fits in one, otherwise return
|
||||||
|
with an error (this avoids a flaw in the interface) */
|
||||||
|
if ((int)len < 0) {
|
||||||
|
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* write len bytes from buf (the return value will fit in an int) */
|
||||||
|
return (int)gz_write(state, buf, len);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
|
||||||
|
voidpc buf;
|
||||||
|
z_size_t size;
|
||||||
|
z_size_t nitems;
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_size_t len;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* compute bytes to read -- error on overflow */
|
||||||
|
len = nitems * size;
|
||||||
|
if (size && len / size != nitems) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* write len bytes to buf, return the number of full items written */
|
||||||
|
return len ? gz_write(state, buf, len) / size : 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* -- see zlib.h -- */
|
/* -- see zlib.h -- */
|
||||||
|
|
@ -275,7 +334,7 @@ int ZEXPORT gzputc(file, c)
|
||||||
strm->next_in = state->in;
|
strm->next_in = state->in;
|
||||||
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
|
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
|
||||||
if (have < state->size) {
|
if (have < state->size) {
|
||||||
state->in[have] = c;
|
state->in[have] = (unsigned char)c;
|
||||||
strm->avail_in++;
|
strm->avail_in++;
|
||||||
state->x.pos++;
|
state->x.pos++;
|
||||||
return c & 0xff;
|
return c & 0xff;
|
||||||
|
|
@ -283,8 +342,8 @@ int ZEXPORT gzputc(file, c)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* no room in buffer or not initialized, use gz_write() */
|
/* no room in buffer or not initialized, use gz_write() */
|
||||||
buf[0] = c;
|
buf[0] = (unsigned char)c;
|
||||||
if (gzwrite(file, buf, 1) != 1)
|
if (gz_write(state, buf, 1) != 1)
|
||||||
return -1;
|
return -1;
|
||||||
return c & 0xff;
|
return c & 0xff;
|
||||||
}
|
}
|
||||||
|
|
@ -295,11 +354,21 @@ int ZEXPORT gzputs(file, str)
|
||||||
const char *str;
|
const char *str;
|
||||||
{
|
{
|
||||||
int ret;
|
int ret;
|
||||||
unsigned len;
|
z_size_t len;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return -1;
|
||||||
|
|
||||||
/* write string */
|
/* write string */
|
||||||
len = (unsigned)strlen(str);
|
len = strlen(str);
|
||||||
ret = gzwrite(file, str, len);
|
ret = gz_write(state, str, len);
|
||||||
return ret == 0 && len != 0 ? -1 : ret;
|
return ret == 0 && len != 0 ? -1 : ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -309,63 +378,73 @@ int ZEXPORT gzputs(file, str)
|
||||||
/* -- see zlib.h -- */
|
/* -- see zlib.h -- */
|
||||||
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
|
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
|
||||||
{
|
{
|
||||||
int size, len;
|
int len;
|
||||||
|
unsigned left;
|
||||||
|
char *next;
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
z_streamp strm;
|
z_streamp strm;
|
||||||
|
|
||||||
/* get internal structure */
|
/* get internal structure */
|
||||||
if (file == NULL)
|
if (file == NULL)
|
||||||
return -1;
|
return Z_STREAM_ERROR;
|
||||||
state = (gz_statep)file;
|
state = (gz_statep)file;
|
||||||
strm = &(state->strm);
|
strm = &(state->strm);
|
||||||
|
|
||||||
/* check that we're writing and that there's no error */
|
/* check that we're writing and that there's no error */
|
||||||
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
return 0;
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
/* make sure we have some buffer space */
|
/* make sure we have some buffer space */
|
||||||
if (state->size == 0 && gz_init(state) == -1)
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
return 0;
|
return state->err;
|
||||||
|
|
||||||
/* check for seek request */
|
/* check for seek request */
|
||||||
if (state->seek) {
|
if (state->seek) {
|
||||||
state->seek = 0;
|
state->seek = 0;
|
||||||
if (gz_zero(state, state->skip) == -1)
|
if (gz_zero(state, state->skip) == -1)
|
||||||
return 0;
|
return state->err;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* consume whatever's left in the input buffer */
|
/* do the printf() into the input buffer, put length in len -- the input
|
||||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
buffer is double-sized just for this function, so there is guaranteed to
|
||||||
return 0;
|
be state->size bytes available after the current contents */
|
||||||
|
if (strm->avail_in == 0)
|
||||||
/* do the printf() into the input buffer, put length in len */
|
strm->next_in = state->in;
|
||||||
size = (int)(state->size);
|
next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
|
||||||
state->in[size - 1] = 0;
|
next[state->size - 1] = 0;
|
||||||
#ifdef NO_vsnprintf
|
#ifdef NO_vsnprintf
|
||||||
# ifdef HAS_vsprintf_void
|
# ifdef HAS_vsprintf_void
|
||||||
(void)vsprintf((char *)(state->in), format, va);
|
(void)vsprintf(next, format, va);
|
||||||
for (len = 0; len < size; len++)
|
for (len = 0; len < state->size; len++)
|
||||||
if (state->in[len] == 0) break;
|
if (next[len] == 0) break;
|
||||||
# else
|
# else
|
||||||
len = vsprintf((char *)(state->in), format, va);
|
len = vsprintf(next, format, va);
|
||||||
# endif
|
# endif
|
||||||
#else
|
#else
|
||||||
# ifdef HAS_vsnprintf_void
|
# ifdef HAS_vsnprintf_void
|
||||||
(void)vsnprintf((char *)(state->in), size, format, va);
|
(void)vsnprintf(next, state->size, format, va);
|
||||||
len = strlen((char *)(state->in));
|
len = strlen(next);
|
||||||
# else
|
# else
|
||||||
len = vsnprintf((char *)(state->in), size, format, va);
|
len = vsnprintf(next, state->size, format, va);
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* check that printf() results fit in buffer */
|
/* check that printf() results fit in buffer */
|
||||||
if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
|
if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
/* update buffer and position, defer compression until needed */
|
/* update buffer and position, compress first half if past that */
|
||||||
strm->avail_in = (unsigned)len;
|
strm->avail_in += (unsigned)len;
|
||||||
strm->next_in = state->in;
|
|
||||||
state->x.pos += len;
|
state->x.pos += len;
|
||||||
|
if (strm->avail_in >= state->size) {
|
||||||
|
left = strm->avail_in - state->size;
|
||||||
|
strm->avail_in = state->size;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return state->err;
|
||||||
|
memcpy(state->in, state->in + state->size, left);
|
||||||
|
strm->next_in = state->in;
|
||||||
|
strm->avail_in = left;
|
||||||
|
}
|
||||||
return len;
|
return len;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -390,73 +469,82 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
||||||
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
||||||
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
|
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
|
||||||
{
|
{
|
||||||
int size, len;
|
unsigned len, left;
|
||||||
|
char *next;
|
||||||
gz_statep state;
|
gz_statep state;
|
||||||
z_streamp strm;
|
z_streamp strm;
|
||||||
|
|
||||||
/* get internal structure */
|
/* get internal structure */
|
||||||
if (file == NULL)
|
if (file == NULL)
|
||||||
return -1;
|
return Z_STREAM_ERROR;
|
||||||
state = (gz_statep)file;
|
state = (gz_statep)file;
|
||||||
strm = &(state->strm);
|
strm = &(state->strm);
|
||||||
|
|
||||||
/* check that can really pass pointer in ints */
|
/* check that can really pass pointer in ints */
|
||||||
if (sizeof(int) != sizeof(void *))
|
if (sizeof(int) != sizeof(void *))
|
||||||
return 0;
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
/* check that we're writing and that there's no error */
|
/* check that we're writing and that there's no error */
|
||||||
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
return 0;
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
/* make sure we have some buffer space */
|
/* make sure we have some buffer space */
|
||||||
if (state->size == 0 && gz_init(state) == -1)
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
return 0;
|
return state->error;
|
||||||
|
|
||||||
/* check for seek request */
|
/* check for seek request */
|
||||||
if (state->seek) {
|
if (state->seek) {
|
||||||
state->seek = 0;
|
state->seek = 0;
|
||||||
if (gz_zero(state, state->skip) == -1)
|
if (gz_zero(state, state->skip) == -1)
|
||||||
return 0;
|
return state->error;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* consume whatever's left in the input buffer */
|
/* do the printf() into the input buffer, put length in len -- the input
|
||||||
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
buffer is double-sized just for this function, so there is guaranteed to
|
||||||
return 0;
|
be state->size bytes available after the current contents */
|
||||||
|
if (strm->avail_in == 0)
|
||||||
/* do the printf() into the input buffer, put length in len */
|
strm->next_in = state->in;
|
||||||
size = (int)(state->size);
|
next = (char *)(strm->next_in + strm->avail_in);
|
||||||
state->in[size - 1] = 0;
|
next[state->size - 1] = 0;
|
||||||
#ifdef NO_snprintf
|
#ifdef NO_snprintf
|
||||||
# ifdef HAS_sprintf_void
|
# ifdef HAS_sprintf_void
|
||||||
sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
|
sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
|
||||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
for (len = 0; len < size; len++)
|
for (len = 0; len < size; len++)
|
||||||
if (state->in[len] == 0) break;
|
if (next[len] == 0)
|
||||||
|
break;
|
||||||
# else
|
# else
|
||||||
len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8,
|
len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
|
||||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
# endif
|
# endif
|
||||||
#else
|
#else
|
||||||
# ifdef HAS_snprintf_void
|
# ifdef HAS_snprintf_void
|
||||||
snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8,
|
snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
||||||
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
len = strlen((char *)(state->in));
|
len = strlen(next);
|
||||||
# else
|
# else
|
||||||
len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6,
|
len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||||
a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
|
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
a19, a20);
|
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* check that printf() results fit in buffer */
|
/* check that printf() results fit in buffer */
|
||||||
if (len <= 0 || len >= (int)size || state->in[size - 1] != 0)
|
if (len == 0 || len >= state->size || next[state->size - 1] != 0)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
/* update buffer and position, defer compression until needed */
|
/* update buffer and position, compress first half if past that */
|
||||||
strm->avail_in = (unsigned)len;
|
strm->avail_in += len;
|
||||||
strm->next_in = state->in;
|
|
||||||
state->x.pos += len;
|
state->x.pos += len;
|
||||||
return len;
|
if (strm->avail_in >= state->size) {
|
||||||
|
left = strm->avail_in - state->size;
|
||||||
|
strm->avail_in = state->size;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return state->err;
|
||||||
|
memcpy(state->in, state->in + state->size, left);
|
||||||
|
strm->next_in = state->in;
|
||||||
|
strm->avail_in = left;
|
||||||
|
}
|
||||||
|
return (int)len;
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -470,7 +558,7 @@ int ZEXPORT gzflush(file, flush)
|
||||||
|
|
||||||
/* get internal structure */
|
/* get internal structure */
|
||||||
if (file == NULL)
|
if (file == NULL)
|
||||||
return -1;
|
return Z_STREAM_ERROR;
|
||||||
state = (gz_statep)file;
|
state = (gz_statep)file;
|
||||||
|
|
||||||
/* check that we're writing and that there's no error */
|
/* check that we're writing and that there's no error */
|
||||||
|
|
@ -485,11 +573,11 @@ int ZEXPORT gzflush(file, flush)
|
||||||
if (state->seek) {
|
if (state->seek) {
|
||||||
state->seek = 0;
|
state->seek = 0;
|
||||||
if (gz_zero(state, state->skip) == -1)
|
if (gz_zero(state, state->skip) == -1)
|
||||||
return -1;
|
return state->err;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* compress remaining data with requested flush */
|
/* compress remaining data with requested flush */
|
||||||
gz_comp(state, flush);
|
(void)gz_comp(state, flush);
|
||||||
return state->err;
|
return state->err;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -520,13 +608,13 @@ int ZEXPORT gzsetparams(file, level, strategy)
|
||||||
if (state->seek) {
|
if (state->seek) {
|
||||||
state->seek = 0;
|
state->seek = 0;
|
||||||
if (gz_zero(state, state->skip) == -1)
|
if (gz_zero(state, state->skip) == -1)
|
||||||
return -1;
|
return state->err;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* change compression parameters for subsequent input */
|
/* change compression parameters for subsequent input */
|
||||||
if (state->size) {
|
if (state->size) {
|
||||||
/* flush previous input with previous parameters before changing */
|
/* flush previous input with previous parameters before changing */
|
||||||
if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1)
|
if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
|
||||||
return state->err;
|
return state->err;
|
||||||
deflateParams(strm, level, strategy);
|
deflateParams(strm, level, strategy);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* infback.c -- inflate using a call-back interface
|
/* infback.c -- inflate using a call-back interface
|
||||||
* Copyright (C) 1995-2011 Mark Adler
|
* Copyright (C) 1995-2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -61,7 +61,7 @@ int stream_size;
|
||||||
Tracev((stderr, "inflate: allocated\n"));
|
Tracev((stderr, "inflate: allocated\n"));
|
||||||
strm->state = (struct internal_state FAR *)state;
|
strm->state = (struct internal_state FAR *)state;
|
||||||
state->dmax = 32768U;
|
state->dmax = 32768U;
|
||||||
state->wbits = windowBits;
|
state->wbits = (uInt)windowBits;
|
||||||
state->wsize = 1U << windowBits;
|
state->wsize = 1U << windowBits;
|
||||||
state->window = window;
|
state->window = window;
|
||||||
state->wnext = 0;
|
state->wnext = 0;
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* inffast.c -- fast decoding
|
/* inffast.c -- fast decoding
|
||||||
* Copyright (C) 1995-2008, 2010, 2013 Mark Adler
|
* Copyright (C) 1995-2017 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -8,26 +8,9 @@
|
||||||
#include "inflate.h"
|
#include "inflate.h"
|
||||||
#include "inffast.h"
|
#include "inffast.h"
|
||||||
|
|
||||||
#ifndef ASMINF
|
#ifdef ASMINF
|
||||||
|
# pragma message("Assembler code may have bugs -- use at your own risk")
|
||||||
/* Allow machine dependent optimization for post-increment or pre-increment.
|
|
||||||
Based on testing to date,
|
|
||||||
Pre-increment preferred for:
|
|
||||||
- PowerPC G3 (Adler)
|
|
||||||
- MIPS R5000 (Randers-Pehrson)
|
|
||||||
Post-increment preferred for:
|
|
||||||
- none
|
|
||||||
No measurable difference:
|
|
||||||
- Pentium III (Anderson)
|
|
||||||
- M68060 (Nikl)
|
|
||||||
*/
|
|
||||||
#ifdef POSTINC
|
|
||||||
# define OFF 0
|
|
||||||
# define PUP(a) *(a)++
|
|
||||||
#else
|
#else
|
||||||
# define OFF 1
|
|
||||||
# define PUP(a) *++(a)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
Decode literal, length, and distance codes and write out the resulting
|
Decode literal, length, and distance codes and write out the resulting
|
||||||
|
|
@ -96,9 +79,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
|
|
||||||
/* copy state to local variables */
|
/* copy state to local variables */
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
in = strm->next_in - OFF;
|
in = strm->next_in;
|
||||||
last = in + (strm->avail_in - 5);
|
last = in + (strm->avail_in - 5);
|
||||||
out = strm->next_out - OFF;
|
out = strm->next_out;
|
||||||
beg = out - (start - strm->avail_out);
|
beg = out - (start - strm->avail_out);
|
||||||
end = out + (strm->avail_out - 257);
|
end = out + (strm->avail_out - 257);
|
||||||
#ifdef INFLATE_STRICT
|
#ifdef INFLATE_STRICT
|
||||||
|
|
@ -119,9 +102,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
input data or output space */
|
input data or output space */
|
||||||
do {
|
do {
|
||||||
if (bits < 15) {
|
if (bits < 15) {
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
}
|
}
|
||||||
here = lcode[hold & lmask];
|
here = lcode[hold & lmask];
|
||||||
|
|
@ -134,14 +117,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
||||||
"inflate: literal '%c'\n" :
|
"inflate: literal '%c'\n" :
|
||||||
"inflate: literal 0x%02x\n", here.val));
|
"inflate: literal 0x%02x\n", here.val));
|
||||||
PUP(out) = (unsigned char)(here.val);
|
*out++ = (unsigned char)(here.val);
|
||||||
}
|
}
|
||||||
else if (op & 16) { /* length base */
|
else if (op & 16) { /* length base */
|
||||||
len = (unsigned)(here.val);
|
len = (unsigned)(here.val);
|
||||||
op &= 15; /* number of extra bits */
|
op &= 15; /* number of extra bits */
|
||||||
if (op) {
|
if (op) {
|
||||||
if (bits < op) {
|
if (bits < op) {
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
}
|
}
|
||||||
len += (unsigned)hold & ((1U << op) - 1);
|
len += (unsigned)hold & ((1U << op) - 1);
|
||||||
|
|
@ -150,9 +133,9 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
}
|
}
|
||||||
Tracevv((stderr, "inflate: length %u\n", len));
|
Tracevv((stderr, "inflate: length %u\n", len));
|
||||||
if (bits < 15) {
|
if (bits < 15) {
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
}
|
}
|
||||||
here = dcode[hold & dmask];
|
here = dcode[hold & dmask];
|
||||||
|
|
@ -165,10 +148,10 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
dist = (unsigned)(here.val);
|
dist = (unsigned)(here.val);
|
||||||
op &= 15; /* number of extra bits */
|
op &= 15; /* number of extra bits */
|
||||||
if (bits < op) {
|
if (bits < op) {
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
if (bits < op) {
|
if (bits < op) {
|
||||||
hold += (unsigned long)(PUP(in)) << bits;
|
hold += (unsigned long)(*in++) << bits;
|
||||||
bits += 8;
|
bits += 8;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -196,30 +179,30 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
||||||
if (len <= op - whave) {
|
if (len <= op - whave) {
|
||||||
do {
|
do {
|
||||||
PUP(out) = 0;
|
*out++ = 0;
|
||||||
} while (--len);
|
} while (--len);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
len -= op - whave;
|
len -= op - whave;
|
||||||
do {
|
do {
|
||||||
PUP(out) = 0;
|
*out++ = 0;
|
||||||
} while (--op > whave);
|
} while (--op > whave);
|
||||||
if (op == 0) {
|
if (op == 0) {
|
||||||
from = out - dist;
|
from = out - dist;
|
||||||
do {
|
do {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
} while (--len);
|
} while (--len);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
from = window - OFF;
|
from = window;
|
||||||
if (wnext == 0) { /* very common case */
|
if (wnext == 0) { /* very common case */
|
||||||
from += wsize - op;
|
from += wsize - op;
|
||||||
if (op < len) { /* some from window */
|
if (op < len) { /* some from window */
|
||||||
len -= op;
|
len -= op;
|
||||||
do {
|
do {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
} while (--op);
|
} while (--op);
|
||||||
from = out - dist; /* rest from output */
|
from = out - dist; /* rest from output */
|
||||||
}
|
}
|
||||||
|
|
@ -230,14 +213,14 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
if (op < len) { /* some from end of window */
|
if (op < len) { /* some from end of window */
|
||||||
len -= op;
|
len -= op;
|
||||||
do {
|
do {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
} while (--op);
|
} while (--op);
|
||||||
from = window - OFF;
|
from = window;
|
||||||
if (wnext < len) { /* some from start of window */
|
if (wnext < len) { /* some from start of window */
|
||||||
op = wnext;
|
op = wnext;
|
||||||
len -= op;
|
len -= op;
|
||||||
do {
|
do {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
} while (--op);
|
} while (--op);
|
||||||
from = out - dist; /* rest from output */
|
from = out - dist; /* rest from output */
|
||||||
}
|
}
|
||||||
|
|
@ -248,35 +231,35 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
if (op < len) { /* some from window */
|
if (op < len) { /* some from window */
|
||||||
len -= op;
|
len -= op;
|
||||||
do {
|
do {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
} while (--op);
|
} while (--op);
|
||||||
from = out - dist; /* rest from output */
|
from = out - dist; /* rest from output */
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
while (len > 2) {
|
while (len > 2) {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
len -= 3;
|
len -= 3;
|
||||||
}
|
}
|
||||||
if (len) {
|
if (len) {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
if (len > 1)
|
if (len > 1)
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
from = out - dist; /* copy direct from output */
|
from = out - dist; /* copy direct from output */
|
||||||
do { /* minimum length is three */
|
do { /* minimum length is three */
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
len -= 3;
|
len -= 3;
|
||||||
} while (len > 2);
|
} while (len > 2);
|
||||||
if (len) {
|
if (len) {
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
if (len > 1)
|
if (len > 1)
|
||||||
PUP(out) = PUP(from);
|
*out++ = *from++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -313,8 +296,8 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
hold &= (1U << bits) - 1;
|
hold &= (1U << bits) - 1;
|
||||||
|
|
||||||
/* update state and return */
|
/* update state and return */
|
||||||
strm->next_in = in + OFF;
|
strm->next_in = in;
|
||||||
strm->next_out = out + OFF;
|
strm->next_out = out;
|
||||||
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
|
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
|
||||||
strm->avail_out = (unsigned)(out < end ?
|
strm->avail_out = (unsigned)(out < end ?
|
||||||
257 + (end - out) : 257 - (out - end));
|
257 + (end - out) : 257 - (out - end));
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* inflate.c -- zlib decompression
|
/* inflate.c -- zlib decompression
|
||||||
* Copyright (C) 1995-2012 Mark Adler
|
* Copyright (C) 1995-2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -92,6 +92,7 @@
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* function prototypes */
|
/* function prototypes */
|
||||||
|
local int inflateStateCheck OF((z_streamp strm));
|
||||||
local void fixedtables OF((struct inflate_state FAR *state));
|
local void fixedtables OF((struct inflate_state FAR *state));
|
||||||
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
|
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
|
||||||
unsigned copy));
|
unsigned copy));
|
||||||
|
|
@ -101,12 +102,26 @@ local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
|
||||||
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
|
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
|
||||||
unsigned len));
|
unsigned len));
|
||||||
|
|
||||||
|
local int inflateStateCheck(strm)
|
||||||
|
z_streamp strm;
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
if (strm == Z_NULL ||
|
||||||
|
strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
|
||||||
|
return 1;
|
||||||
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
if (state == Z_NULL || state->strm != strm ||
|
||||||
|
state->mode < HEAD || state->mode > SYNC)
|
||||||
|
return 1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
int ZEXPORT inflateResetKeep(strm)
|
int ZEXPORT inflateResetKeep(strm)
|
||||||
z_streamp strm;
|
z_streamp strm;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
strm->total_in = strm->total_out = state->total = 0;
|
strm->total_in = strm->total_out = state->total = 0;
|
||||||
strm->msg = Z_NULL;
|
strm->msg = Z_NULL;
|
||||||
|
|
@ -131,7 +146,7 @@ z_streamp strm;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
state->wsize = 0;
|
state->wsize = 0;
|
||||||
state->whave = 0;
|
state->whave = 0;
|
||||||
|
|
@ -147,7 +162,7 @@ int windowBits;
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
/* get the state */
|
/* get the state */
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
|
||||||
/* extract wrap request from windowBits parameter */
|
/* extract wrap request from windowBits parameter */
|
||||||
|
|
@ -156,7 +171,7 @@ int windowBits;
|
||||||
windowBits = -windowBits;
|
windowBits = -windowBits;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
wrap = (windowBits >> 4) + 1;
|
wrap = (windowBits >> 4) + 5;
|
||||||
#ifdef GUNZIP
|
#ifdef GUNZIP
|
||||||
if (windowBits < 48)
|
if (windowBits < 48)
|
||||||
windowBits &= 15;
|
windowBits &= 15;
|
||||||
|
|
@ -210,7 +225,9 @@ int stream_size;
|
||||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||||
Tracev((stderr, "inflate: allocated\n"));
|
Tracev((stderr, "inflate: allocated\n"));
|
||||||
strm->state = (struct internal_state FAR *)state;
|
strm->state = (struct internal_state FAR *)state;
|
||||||
|
state->strm = strm;
|
||||||
state->window = Z_NULL;
|
state->window = Z_NULL;
|
||||||
|
state->mode = HEAD; /* to pass state test in inflateReset2() */
|
||||||
ret = inflateReset2(strm, windowBits);
|
ret = inflateReset2(strm, windowBits);
|
||||||
if (ret != Z_OK) {
|
if (ret != Z_OK) {
|
||||||
ZFREE(strm, state);
|
ZFREE(strm, state);
|
||||||
|
|
@ -234,17 +251,17 @@ int value;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
if (bits < 0) {
|
if (bits < 0) {
|
||||||
state->hold = 0;
|
state->hold = 0;
|
||||||
state->bits = 0;
|
state->bits = 0;
|
||||||
return Z_OK;
|
return Z_OK;
|
||||||
}
|
}
|
||||||
if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
|
if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
|
||||||
value &= (1L << bits) - 1;
|
value &= (1L << bits) - 1;
|
||||||
state->hold += value << state->bits;
|
state->hold += (unsigned)value << state->bits;
|
||||||
state->bits += bits;
|
state->bits += (uInt)bits;
|
||||||
return Z_OK;
|
return Z_OK;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -625,7 +642,7 @@ int flush;
|
||||||
static const unsigned short order[19] = /* permutation of code lengths */
|
static const unsigned short order[19] = /* permutation of code lengths */
|
||||||
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
|
if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
|
||||||
(strm->next_in == Z_NULL && strm->avail_in != 0))
|
(strm->next_in == Z_NULL && strm->avail_in != 0))
|
||||||
return Z_STREAM_ERROR;
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
|
@ -645,6 +662,8 @@ int flush;
|
||||||
NEEDBITS(16);
|
NEEDBITS(16);
|
||||||
#ifdef GUNZIP
|
#ifdef GUNZIP
|
||||||
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
|
if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */
|
||||||
|
if (state->wbits == 0)
|
||||||
|
state->wbits = 15;
|
||||||
state->check = crc32(0L, Z_NULL, 0);
|
state->check = crc32(0L, Z_NULL, 0);
|
||||||
CRC2(state->check, hold);
|
CRC2(state->check, hold);
|
||||||
INITBITS();
|
INITBITS();
|
||||||
|
|
@ -672,7 +691,7 @@ int flush;
|
||||||
len = BITS(4) + 8;
|
len = BITS(4) + 8;
|
||||||
if (state->wbits == 0)
|
if (state->wbits == 0)
|
||||||
state->wbits = len;
|
state->wbits = len;
|
||||||
else if (len > state->wbits) {
|
if (len > 15 || len > state->wbits) {
|
||||||
strm->msg = (char *)"invalid window size";
|
strm->msg = (char *)"invalid window size";
|
||||||
state->mode = BAD;
|
state->mode = BAD;
|
||||||
break;
|
break;
|
||||||
|
|
@ -699,14 +718,16 @@ int flush;
|
||||||
}
|
}
|
||||||
if (state->head != Z_NULL)
|
if (state->head != Z_NULL)
|
||||||
state->head->text = (int)((hold >> 8) & 1);
|
state->head->text = (int)((hold >> 8) & 1);
|
||||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
|
CRC2(state->check, hold);
|
||||||
INITBITS();
|
INITBITS();
|
||||||
state->mode = TIME;
|
state->mode = TIME;
|
||||||
case TIME:
|
case TIME:
|
||||||
NEEDBITS(32);
|
NEEDBITS(32);
|
||||||
if (state->head != Z_NULL)
|
if (state->head != Z_NULL)
|
||||||
state->head->time = hold;
|
state->head->time = hold;
|
||||||
if (state->flags & 0x0200) CRC4(state->check, hold);
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
|
CRC4(state->check, hold);
|
||||||
INITBITS();
|
INITBITS();
|
||||||
state->mode = OS;
|
state->mode = OS;
|
||||||
case OS:
|
case OS:
|
||||||
|
|
@ -715,7 +736,8 @@ int flush;
|
||||||
state->head->xflags = (int)(hold & 0xff);
|
state->head->xflags = (int)(hold & 0xff);
|
||||||
state->head->os = (int)(hold >> 8);
|
state->head->os = (int)(hold >> 8);
|
||||||
}
|
}
|
||||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
|
CRC2(state->check, hold);
|
||||||
INITBITS();
|
INITBITS();
|
||||||
state->mode = EXLEN;
|
state->mode = EXLEN;
|
||||||
case EXLEN:
|
case EXLEN:
|
||||||
|
|
@ -724,7 +746,8 @@ int flush;
|
||||||
state->length = (unsigned)(hold);
|
state->length = (unsigned)(hold);
|
||||||
if (state->head != Z_NULL)
|
if (state->head != Z_NULL)
|
||||||
state->head->extra_len = (unsigned)hold;
|
state->head->extra_len = (unsigned)hold;
|
||||||
if (state->flags & 0x0200) CRC2(state->check, hold);
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
|
CRC2(state->check, hold);
|
||||||
INITBITS();
|
INITBITS();
|
||||||
}
|
}
|
||||||
else if (state->head != Z_NULL)
|
else if (state->head != Z_NULL)
|
||||||
|
|
@ -742,7 +765,7 @@ int flush;
|
||||||
len + copy > state->head->extra_max ?
|
len + copy > state->head->extra_max ?
|
||||||
state->head->extra_max - len : copy);
|
state->head->extra_max - len : copy);
|
||||||
}
|
}
|
||||||
if (state->flags & 0x0200)
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
state->check = crc32(state->check, next, copy);
|
state->check = crc32(state->check, next, copy);
|
||||||
have -= copy;
|
have -= copy;
|
||||||
next += copy;
|
next += copy;
|
||||||
|
|
@ -761,9 +784,9 @@ int flush;
|
||||||
if (state->head != Z_NULL &&
|
if (state->head != Z_NULL &&
|
||||||
state->head->name != Z_NULL &&
|
state->head->name != Z_NULL &&
|
||||||
state->length < state->head->name_max)
|
state->length < state->head->name_max)
|
||||||
state->head->name[state->length++] = len;
|
state->head->name[state->length++] = (Bytef)len;
|
||||||
} while (len && copy < have);
|
} while (len && copy < have);
|
||||||
if (state->flags & 0x0200)
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
state->check = crc32(state->check, next, copy);
|
state->check = crc32(state->check, next, copy);
|
||||||
have -= copy;
|
have -= copy;
|
||||||
next += copy;
|
next += copy;
|
||||||
|
|
@ -782,9 +805,9 @@ int flush;
|
||||||
if (state->head != Z_NULL &&
|
if (state->head != Z_NULL &&
|
||||||
state->head->comment != Z_NULL &&
|
state->head->comment != Z_NULL &&
|
||||||
state->length < state->head->comm_max)
|
state->length < state->head->comm_max)
|
||||||
state->head->comment[state->length++] = len;
|
state->head->comment[state->length++] = (Bytef)len;
|
||||||
} while (len && copy < have);
|
} while (len && copy < have);
|
||||||
if (state->flags & 0x0200)
|
if ((state->flags & 0x0200) && (state->wrap & 4))
|
||||||
state->check = crc32(state->check, next, copy);
|
state->check = crc32(state->check, next, copy);
|
||||||
have -= copy;
|
have -= copy;
|
||||||
next += copy;
|
next += copy;
|
||||||
|
|
@ -796,7 +819,7 @@ int flush;
|
||||||
case HCRC:
|
case HCRC:
|
||||||
if (state->flags & 0x0200) {
|
if (state->flags & 0x0200) {
|
||||||
NEEDBITS(16);
|
NEEDBITS(16);
|
||||||
if (hold != (state->check & 0xffff)) {
|
if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
|
||||||
strm->msg = (char *)"header crc mismatch";
|
strm->msg = (char *)"header crc mismatch";
|
||||||
state->mode = BAD;
|
state->mode = BAD;
|
||||||
break;
|
break;
|
||||||
|
|
@ -1177,11 +1200,11 @@ int flush;
|
||||||
out -= left;
|
out -= left;
|
||||||
strm->total_out += out;
|
strm->total_out += out;
|
||||||
state->total += out;
|
state->total += out;
|
||||||
if (out)
|
if ((state->wrap & 4) && out)
|
||||||
strm->adler = state->check =
|
strm->adler = state->check =
|
||||||
UPDATE(state->check, put - out, out);
|
UPDATE(state->check, put - out, out);
|
||||||
out = left;
|
out = left;
|
||||||
if ((
|
if ((state->wrap & 4) && (
|
||||||
#ifdef GUNZIP
|
#ifdef GUNZIP
|
||||||
state->flags ? hold :
|
state->flags ? hold :
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -1240,10 +1263,10 @@ int flush;
|
||||||
strm->total_in += in;
|
strm->total_in += in;
|
||||||
strm->total_out += out;
|
strm->total_out += out;
|
||||||
state->total += out;
|
state->total += out;
|
||||||
if (state->wrap && out)
|
if ((state->wrap & 4) && out)
|
||||||
strm->adler = state->check =
|
strm->adler = state->check =
|
||||||
UPDATE(state->check, strm->next_out - out, out);
|
UPDATE(state->check, strm->next_out - out, out);
|
||||||
strm->data_type = state->bits + (state->last ? 64 : 0) +
|
strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
|
||||||
(state->mode == TYPE ? 128 : 0) +
|
(state->mode == TYPE ? 128 : 0) +
|
||||||
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
|
(state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
|
||||||
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
|
if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
|
||||||
|
|
@ -1255,7 +1278,7 @@ int ZEXPORT inflateEnd(strm)
|
||||||
z_streamp strm;
|
z_streamp strm;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
if (inflateStateCheck(strm))
|
||||||
return Z_STREAM_ERROR;
|
return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
if (state->window != Z_NULL) ZFREE(strm, state->window);
|
if (state->window != Z_NULL) ZFREE(strm, state->window);
|
||||||
|
|
@ -1273,7 +1296,7 @@ uInt *dictLength;
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
/* check state */
|
/* check state */
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
|
||||||
/* copy dictionary */
|
/* copy dictionary */
|
||||||
|
|
@ -1298,7 +1321,7 @@ uInt dictLength;
|
||||||
int ret;
|
int ret;
|
||||||
|
|
||||||
/* check state */
|
/* check state */
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
if (state->wrap != 0 && state->mode != DICT)
|
if (state->wrap != 0 && state->mode != DICT)
|
||||||
return Z_STREAM_ERROR;
|
return Z_STREAM_ERROR;
|
||||||
|
|
@ -1330,7 +1353,7 @@ gz_headerp head;
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
/* check state */
|
/* check state */
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
|
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
|
@ -1383,7 +1406,7 @@ z_streamp strm;
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
/* check parameters */
|
/* check parameters */
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
|
if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
|
||||||
|
|
||||||
|
|
@ -1430,7 +1453,7 @@ z_streamp strm;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
return state->mode == STORED && state->bits == 0;
|
return state->mode == STORED && state->bits == 0;
|
||||||
}
|
}
|
||||||
|
|
@ -1445,8 +1468,7 @@ z_streamp source;
|
||||||
unsigned wsize;
|
unsigned wsize;
|
||||||
|
|
||||||
/* check input */
|
/* check input */
|
||||||
if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
|
if (inflateStateCheck(source) || dest == Z_NULL)
|
||||||
source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
|
|
||||||
return Z_STREAM_ERROR;
|
return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)source->state;
|
state = (struct inflate_state FAR *)source->state;
|
||||||
|
|
||||||
|
|
@ -1467,6 +1489,7 @@ z_streamp source;
|
||||||
/* copy state */
|
/* copy state */
|
||||||
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
|
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
|
||||||
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
|
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
|
||||||
|
copy->strm = dest;
|
||||||
if (state->lencode >= state->codes &&
|
if (state->lencode >= state->codes &&
|
||||||
state->lencode <= state->codes + ENOUGH - 1) {
|
state->lencode <= state->codes + ENOUGH - 1) {
|
||||||
copy->lencode = copy->codes + (state->lencode - state->codes);
|
copy->lencode = copy->codes + (state->lencode - state->codes);
|
||||||
|
|
@ -1488,25 +1511,51 @@ int subvert;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
state->sane = !subvert;
|
|
||||||
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
||||||
|
state->sane = !subvert;
|
||||||
return Z_OK;
|
return Z_OK;
|
||||||
#else
|
#else
|
||||||
|
(void)subvert;
|
||||||
state->sane = 1;
|
state->sane = 1;
|
||||||
return Z_DATA_ERROR;
|
return Z_DATA_ERROR;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
int ZEXPORT inflateValidate(strm, check)
|
||||||
|
z_streamp strm;
|
||||||
|
int check;
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
|
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
|
||||||
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
if (check)
|
||||||
|
state->wrap |= 4;
|
||||||
|
else
|
||||||
|
state->wrap &= ~4;
|
||||||
|
return Z_OK;
|
||||||
|
}
|
||||||
|
|
||||||
long ZEXPORT inflateMark(strm)
|
long ZEXPORT inflateMark(strm)
|
||||||
z_streamp strm;
|
z_streamp strm;
|
||||||
{
|
{
|
||||||
struct inflate_state FAR *state;
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16;
|
if (inflateStateCheck(strm))
|
||||||
|
return -(1L << 16);
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
return ((long)(state->back) << 16) +
|
return (long)(((unsigned long)((long)state->back)) << 16) +
|
||||||
(state->mode == COPY ? state->length :
|
(state->mode == COPY ? state->length :
|
||||||
(state->mode == MATCH ? state->was - state->length : 0));
|
(state->mode == MATCH ? state->was - state->length : 0));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
unsigned long ZEXPORT inflateCodesUsed(strm)
|
||||||
|
z_streamp strm;
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
if (inflateStateCheck(strm)) return (unsigned long)-1;
|
||||||
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
return (unsigned long)(state->next - state->codes);
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* inflate.h -- internal inflate state definition
|
/* inflate.h -- internal inflate state definition
|
||||||
* Copyright (C) 1995-2009 Mark Adler
|
* Copyright (C) 1995-2016 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -18,7 +18,7 @@
|
||||||
|
|
||||||
/* Possible inflate modes between inflate() calls */
|
/* Possible inflate modes between inflate() calls */
|
||||||
typedef enum {
|
typedef enum {
|
||||||
HEAD, /* i: waiting for magic header */
|
HEAD = 16180, /* i: waiting for magic header */
|
||||||
FLAGS, /* i: waiting for method and flags (gzip) */
|
FLAGS, /* i: waiting for method and flags (gzip) */
|
||||||
TIME, /* i: waiting for modification time (gzip) */
|
TIME, /* i: waiting for modification time (gzip) */
|
||||||
OS, /* i: waiting for extra flags and operating system (gzip) */
|
OS, /* i: waiting for extra flags and operating system (gzip) */
|
||||||
|
|
@ -77,11 +77,14 @@ typedef enum {
|
||||||
CHECK -> LENGTH -> DONE
|
CHECK -> LENGTH -> DONE
|
||||||
*/
|
*/
|
||||||
|
|
||||||
/* state maintained between inflate() calls. Approximately 10K bytes. */
|
/* State maintained between inflate() calls -- approximately 7K bytes, not
|
||||||
|
including the allocated sliding window, which is up to 32K bytes. */
|
||||||
struct inflate_state {
|
struct inflate_state {
|
||||||
|
z_streamp strm; /* pointer back to this zlib stream */
|
||||||
inflate_mode mode; /* current inflate mode */
|
inflate_mode mode; /* current inflate mode */
|
||||||
int last; /* true if processing last block */
|
int last; /* true if processing last block */
|
||||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
|
||||||
|
bit 2 true to validate check value */
|
||||||
int havedict; /* true if dictionary provided */
|
int havedict; /* true if dictionary provided */
|
||||||
int flags; /* gzip header method and flags (0 if zlib) */
|
int flags; /* gzip header method and flags (0 if zlib) */
|
||||||
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
|
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* inftrees.c -- generate Huffman trees for efficient decoding
|
/* inftrees.c -- generate Huffman trees for efficient decoding
|
||||||
* Copyright (C) 1995-2013 Mark Adler
|
* Copyright (C) 1995-2017 Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -9,7 +9,7 @@
|
||||||
#define MAXBITS 15
|
#define MAXBITS 15
|
||||||
|
|
||||||
const char inflate_copyright[] =
|
const char inflate_copyright[] =
|
||||||
" inflate 1.2.8 Copyright 1995-2013 Mark Adler ";
|
" inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
|
||||||
/*
|
/*
|
||||||
If you use the zlib library in a product, an acknowledgment is welcome
|
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
|
in the documentation of your product. If for some reason you cannot
|
||||||
|
|
@ -54,7 +54,7 @@ unsigned short FAR *work;
|
||||||
code FAR *next; /* next available space in table */
|
code FAR *next; /* next available space in table */
|
||||||
const unsigned short FAR *base; /* base value table to use */
|
const unsigned short FAR *base; /* base value table to use */
|
||||||
const unsigned short FAR *extra; /* extra bits table to use */
|
const unsigned short FAR *extra; /* extra bits table to use */
|
||||||
int end; /* use base and extra for symbol > end */
|
unsigned match; /* use base and extra for symbol >= match */
|
||||||
unsigned short count[MAXBITS+1]; /* number of codes of each length */
|
unsigned short count[MAXBITS+1]; /* number of codes of each length */
|
||||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||||
|
|
@ -62,7 +62,7 @@ unsigned short FAR *work;
|
||||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
||||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||||
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78};
|
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
|
||||||
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
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,
|
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||||
|
|
@ -181,19 +181,17 @@ unsigned short FAR *work;
|
||||||
switch (type) {
|
switch (type) {
|
||||||
case CODES:
|
case CODES:
|
||||||
base = extra = work; /* dummy value--not used */
|
base = extra = work; /* dummy value--not used */
|
||||||
end = 19;
|
match = 20;
|
||||||
break;
|
break;
|
||||||
case LENS:
|
case LENS:
|
||||||
base = lbase;
|
base = lbase;
|
||||||
base -= 257;
|
|
||||||
extra = lext;
|
extra = lext;
|
||||||
extra -= 257;
|
match = 257;
|
||||||
end = 256;
|
|
||||||
break;
|
break;
|
||||||
default: /* DISTS */
|
default: /* DISTS */
|
||||||
base = dbase;
|
base = dbase;
|
||||||
extra = dext;
|
extra = dext;
|
||||||
end = -1;
|
match = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* initialize state for loop */
|
/* initialize state for loop */
|
||||||
|
|
@ -216,13 +214,13 @@ unsigned short FAR *work;
|
||||||
for (;;) {
|
for (;;) {
|
||||||
/* create table entry */
|
/* create table entry */
|
||||||
here.bits = (unsigned char)(len - drop);
|
here.bits = (unsigned char)(len - drop);
|
||||||
if ((int)(work[sym]) < end) {
|
if (work[sym] + 1U < match) {
|
||||||
here.op = (unsigned char)0;
|
here.op = (unsigned char)0;
|
||||||
here.val = work[sym];
|
here.val = work[sym];
|
||||||
}
|
}
|
||||||
else if ((int)(work[sym]) > end) {
|
else if (work[sym] >= match) {
|
||||||
here.op = (unsigned char)(extra[work[sym]]);
|
here.op = (unsigned char)(extra[work[sym] - match]);
|
||||||
here.val = base[work[sym]];
|
here.val = base[work[sym] - match];
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
here.op = (unsigned char)(32 + 64); /* end of block */
|
here.op = (unsigned char)(32 + 64); /* end of block */
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* trees.c -- output deflated data using Huffman coding
|
/* trees.c -- output deflated data using Huffman coding
|
||||||
* Copyright (C) 1995-2012 Jean-loup Gailly
|
* Copyright (C) 1995-2017 Jean-loup Gailly
|
||||||
* detect_data_type() function provided freely by Cosmin Truta, 2006
|
* detect_data_type() function provided freely by Cosmin Truta, 2006
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
@ -36,7 +36,7 @@
|
||||||
|
|
||||||
#include "deflate.h"
|
#include "deflate.h"
|
||||||
|
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
# include <ctype.h>
|
# include <ctype.h>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
@ -122,13 +122,13 @@ struct static_tree_desc_s {
|
||||||
int max_length; /* max bit length for the codes */
|
int max_length; /* max bit length for the codes */
|
||||||
};
|
};
|
||||||
|
|
||||||
local static_tree_desc static_l_desc =
|
local const static_tree_desc static_l_desc =
|
||||||
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
|
{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
|
||||||
|
|
||||||
local static_tree_desc static_d_desc =
|
local const static_tree_desc static_d_desc =
|
||||||
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
|
{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
|
||||||
|
|
||||||
local static_tree_desc static_bl_desc =
|
local const static_tree_desc static_bl_desc =
|
||||||
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
|
{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS};
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
|
|
@ -152,18 +152,16 @@ local int detect_data_type OF((deflate_state *s));
|
||||||
local unsigned bi_reverse OF((unsigned value, int length));
|
local unsigned bi_reverse OF((unsigned value, int length));
|
||||||
local void bi_windup OF((deflate_state *s));
|
local void bi_windup OF((deflate_state *s));
|
||||||
local void bi_flush 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));
|
|
||||||
|
|
||||||
#ifdef GEN_TREES_H
|
#ifdef GEN_TREES_H
|
||||||
local void gen_trees_header OF((void));
|
local void gen_trees_header OF((void));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef DEBUG
|
#ifndef ZLIB_DEBUG
|
||||||
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
|
# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
|
||||||
/* Send a code of the given tree. c and tree must not have side effects */
|
/* Send a code of the given tree. c and tree must not have side effects */
|
||||||
|
|
||||||
#else /* DEBUG */
|
#else /* !ZLIB_DEBUG */
|
||||||
# define send_code(s, c, tree) \
|
# define send_code(s, c, tree) \
|
||||||
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
|
{ if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
|
||||||
send_bits(s, tree[c].Code, tree[c].Len); }
|
send_bits(s, tree[c].Code, tree[c].Len); }
|
||||||
|
|
@ -182,7 +180,7 @@ local void gen_trees_header OF((void));
|
||||||
* Send a value on a given number of bits.
|
* Send a value on a given number of bits.
|
||||||
* IN assertion: length <= 16 and value fits in length bits.
|
* IN assertion: length <= 16 and value fits in length bits.
|
||||||
*/
|
*/
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
local void send_bits OF((deflate_state *s, int value, int length));
|
local void send_bits OF((deflate_state *s, int value, int length));
|
||||||
|
|
||||||
local void send_bits(s, value, length)
|
local void send_bits(s, value, length)
|
||||||
|
|
@ -208,12 +206,12 @@ local void send_bits(s, value, length)
|
||||||
s->bi_valid += length;
|
s->bi_valid += length;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#else /* !DEBUG */
|
#else /* !ZLIB_DEBUG */
|
||||||
|
|
||||||
#define send_bits(s, value, length) \
|
#define send_bits(s, value, length) \
|
||||||
{ int len = length;\
|
{ int len = length;\
|
||||||
if (s->bi_valid > (int)Buf_size - len) {\
|
if (s->bi_valid > (int)Buf_size - len) {\
|
||||||
int val = value;\
|
int val = (int)value;\
|
||||||
s->bi_buf |= (ush)val << s->bi_valid;\
|
s->bi_buf |= (ush)val << s->bi_valid;\
|
||||||
put_short(s, s->bi_buf);\
|
put_short(s, s->bi_buf);\
|
||||||
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
|
s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
|
||||||
|
|
@ -223,7 +221,7 @@ local void send_bits(s, value, length)
|
||||||
s->bi_valid += len;\
|
s->bi_valid += len;\
|
||||||
}\
|
}\
|
||||||
}
|
}
|
||||||
#endif /* DEBUG */
|
#endif /* ZLIB_DEBUG */
|
||||||
|
|
||||||
|
|
||||||
/* the arguments must not have side effects */
|
/* the arguments must not have side effects */
|
||||||
|
|
@ -317,7 +315,7 @@ local void tr_static_init()
|
||||||
* Genererate the file trees.h describing the static trees.
|
* Genererate the file trees.h describing the static trees.
|
||||||
*/
|
*/
|
||||||
#ifdef GEN_TREES_H
|
#ifdef GEN_TREES_H
|
||||||
# ifndef DEBUG
|
# ifndef ZLIB_DEBUG
|
||||||
# include <stdio.h>
|
# include <stdio.h>
|
||||||
# endif
|
# endif
|
||||||
|
|
||||||
|
|
@ -394,7 +392,7 @@ void ZLIB_INTERNAL _tr_init(s)
|
||||||
|
|
||||||
s->bi_buf = 0;
|
s->bi_buf = 0;
|
||||||
s->bi_valid = 0;
|
s->bi_valid = 0;
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len = 0L;
|
s->compressed_len = 0L;
|
||||||
s->bits_sent = 0L;
|
s->bits_sent = 0L;
|
||||||
#endif
|
#endif
|
||||||
|
|
@ -522,12 +520,12 @@ local void gen_bitlen(s, desc)
|
||||||
xbits = 0;
|
xbits = 0;
|
||||||
if (n >= base) xbits = extra[n-base];
|
if (n >= base) xbits = extra[n-base];
|
||||||
f = tree[n].Freq;
|
f = tree[n].Freq;
|
||||||
s->opt_len += (ulg)f * (bits + xbits);
|
s->opt_len += (ulg)f * (unsigned)(bits + xbits);
|
||||||
if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits);
|
if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
|
||||||
}
|
}
|
||||||
if (overflow == 0) return;
|
if (overflow == 0) return;
|
||||||
|
|
||||||
Trace((stderr,"\nbit length overflow\n"));
|
Tracev((stderr,"\nbit length overflow\n"));
|
||||||
/* This happens for example on obj2 and pic of the Calgary corpus */
|
/* This happens for example on obj2 and pic of the Calgary corpus */
|
||||||
|
|
||||||
/* Find the first bit length which could increase: */
|
/* Find the first bit length which could increase: */
|
||||||
|
|
@ -554,9 +552,8 @@ local void gen_bitlen(s, desc)
|
||||||
m = s->heap[--h];
|
m = s->heap[--h];
|
||||||
if (m > max_code) continue;
|
if (m > max_code) continue;
|
||||||
if ((unsigned) tree[m].Len != (unsigned) bits) {
|
if ((unsigned) tree[m].Len != (unsigned) bits) {
|
||||||
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
||||||
s->opt_len += ((long)bits - (long)tree[m].Len)
|
s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
|
||||||
*(long)tree[m].Freq;
|
|
||||||
tree[m].Len = (ush)bits;
|
tree[m].Len = (ush)bits;
|
||||||
}
|
}
|
||||||
n--;
|
n--;
|
||||||
|
|
@ -578,7 +575,7 @@ local void gen_codes (tree, max_code, bl_count)
|
||||||
ushf *bl_count; /* number of codes at each bit length */
|
ushf *bl_count; /* number of codes at each bit length */
|
||||||
{
|
{
|
||||||
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
|
ush next_code[MAX_BITS+1]; /* next code value for each bit length */
|
||||||
ush code = 0; /* running code value */
|
unsigned code = 0; /* running code value */
|
||||||
int bits; /* bit index */
|
int bits; /* bit index */
|
||||||
int n; /* code index */
|
int n; /* code index */
|
||||||
|
|
||||||
|
|
@ -586,7 +583,8 @@ local void gen_codes (tree, max_code, bl_count)
|
||||||
* without bit reversal.
|
* without bit reversal.
|
||||||
*/
|
*/
|
||||||
for (bits = 1; bits <= MAX_BITS; bits++) {
|
for (bits = 1; bits <= MAX_BITS; bits++) {
|
||||||
next_code[bits] = code = (code + bl_count[bits-1]) << 1;
|
code = (code + bl_count[bits-1]) << 1;
|
||||||
|
next_code[bits] = (ush)code;
|
||||||
}
|
}
|
||||||
/* Check that the bit counts in bl_count are consistent. The last code
|
/* Check that the bit counts in bl_count are consistent. The last code
|
||||||
* must be all ones.
|
* must be all ones.
|
||||||
|
|
@ -599,7 +597,7 @@ local void gen_codes (tree, max_code, bl_count)
|
||||||
int len = tree[n].Len;
|
int len = tree[n].Len;
|
||||||
if (len == 0) continue;
|
if (len == 0) continue;
|
||||||
/* Now reverse the bits */
|
/* Now reverse the bits */
|
||||||
tree[n].Code = bi_reverse(next_code[len]++, len);
|
tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
|
||||||
|
|
||||||
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
|
Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
|
||||||
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
|
n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
|
||||||
|
|
@ -821,7 +819,7 @@ local int build_bl_tree(s)
|
||||||
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
|
if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
|
||||||
}
|
}
|
||||||
/* Update opt_len to include the bit length tree and counts */
|
/* Update opt_len to include the bit length tree and counts */
|
||||||
s->opt_len += 3*(max_blindex+1) + 5+5+4;
|
s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
|
||||||
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
|
Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
|
||||||
s->opt_len, s->static_len));
|
s->opt_len, s->static_len));
|
||||||
|
|
||||||
|
|
@ -869,11 +867,17 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
|
||||||
int last; /* one if this is the last block for a file */
|
int last; /* one if this is the last block for a file */
|
||||||
{
|
{
|
||||||
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
|
send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */
|
||||||
#ifdef DEBUG
|
bi_windup(s); /* align on byte boundary */
|
||||||
|
put_short(s, (ush)stored_len);
|
||||||
|
put_short(s, (ush)~stored_len);
|
||||||
|
zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
|
||||||
|
s->pending += stored_len;
|
||||||
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
|
s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
|
||||||
s->compressed_len += (stored_len + 4) << 3;
|
s->compressed_len += (stored_len + 4) << 3;
|
||||||
|
s->bits_sent += 2*16;
|
||||||
|
s->bits_sent += stored_len<<3;
|
||||||
#endif
|
#endif
|
||||||
copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
|
|
@ -894,7 +898,7 @@ void ZLIB_INTERNAL _tr_align(s)
|
||||||
{
|
{
|
||||||
send_bits(s, STATIC_TREES<<1, 3);
|
send_bits(s, STATIC_TREES<<1, 3);
|
||||||
send_code(s, END_BLOCK, static_ltree);
|
send_code(s, END_BLOCK, static_ltree);
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
|
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
|
||||||
#endif
|
#endif
|
||||||
bi_flush(s);
|
bi_flush(s);
|
||||||
|
|
@ -902,7 +906,7 @@ void ZLIB_INTERNAL _tr_align(s)
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
* Determine the best encoding for the current block: dynamic trees, static
|
* Determine the best encoding for the current block: dynamic trees, static
|
||||||
* trees or store, and output the encoded block to the zip file.
|
* trees or store, and write out the encoded block.
|
||||||
*/
|
*/
|
||||||
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
||||||
deflate_state *s;
|
deflate_state *s;
|
||||||
|
|
@ -974,7 +978,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
||||||
send_bits(s, (STATIC_TREES<<1)+last, 3);
|
send_bits(s, (STATIC_TREES<<1)+last, 3);
|
||||||
compress_block(s, (const ct_data *)static_ltree,
|
compress_block(s, (const ct_data *)static_ltree,
|
||||||
(const ct_data *)static_dtree);
|
(const ct_data *)static_dtree);
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len += 3 + s->static_len;
|
s->compressed_len += 3 + s->static_len;
|
||||||
#endif
|
#endif
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -983,7 +987,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
||||||
max_blindex+1);
|
max_blindex+1);
|
||||||
compress_block(s, (const ct_data *)s->dyn_ltree,
|
compress_block(s, (const ct_data *)s->dyn_ltree,
|
||||||
(const ct_data *)s->dyn_dtree);
|
(const ct_data *)s->dyn_dtree);
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len += 3 + s->opt_len;
|
s->compressed_len += 3 + s->opt_len;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
@ -995,7 +999,7 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
|
||||||
|
|
||||||
if (last) {
|
if (last) {
|
||||||
bi_windup(s);
|
bi_windup(s);
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->compressed_len += 7; /* align on byte boundary */
|
s->compressed_len += 7; /* align on byte boundary */
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
@ -1090,7 +1094,7 @@ local void compress_block(s, ltree, dtree)
|
||||||
send_code(s, code, dtree); /* send the distance code */
|
send_code(s, code, dtree); /* send the distance code */
|
||||||
extra = extra_dbits[code];
|
extra = extra_dbits[code];
|
||||||
if (extra != 0) {
|
if (extra != 0) {
|
||||||
dist -= base_dist[code];
|
dist -= (unsigned)base_dist[code];
|
||||||
send_bits(s, dist, extra); /* send the extra distance bits */
|
send_bits(s, dist, extra); /* send the extra distance bits */
|
||||||
}
|
}
|
||||||
} /* literal or match pair ? */
|
} /* literal or match pair ? */
|
||||||
|
|
@ -1193,34 +1197,7 @@ local void bi_windup(s)
|
||||||
}
|
}
|
||||||
s->bi_buf = 0;
|
s->bi_buf = 0;
|
||||||
s->bi_valid = 0;
|
s->bi_valid = 0;
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
s->bits_sent = (s->bits_sent+7) & ~7;
|
s->bits_sent = (s->bits_sent+7) & ~7;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
/* ===========================================================================
|
|
||||||
* Copy a stored block, storing first the length and its
|
|
||||||
* one's complement if requested.
|
|
||||||
*/
|
|
||||||
local void copy_block(s, buf, len, header)
|
|
||||||
deflate_state *s;
|
|
||||||
charf *buf; /* the input data */
|
|
||||||
unsigned len; /* its length */
|
|
||||||
int header; /* true if block header must be written */
|
|
||||||
{
|
|
||||||
bi_windup(s); /* align on byte boundary */
|
|
||||||
|
|
||||||
if (header) {
|
|
||||||
put_short(s, (ush)len);
|
|
||||||
put_short(s, (ush)~len);
|
|
||||||
#ifdef DEBUG
|
|
||||||
s->bits_sent += 2*16;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
#ifdef DEBUG
|
|
||||||
s->bits_sent += (ulg)len<<3;
|
|
||||||
#endif
|
|
||||||
while (len--) {
|
|
||||||
put_byte(s, *buf++);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* uncompr.c -- decompress a memory buffer
|
/* uncompr.c -- decompress a memory buffer
|
||||||
* Copyright (C) 1995-2003, 2010 Jean-loup Gailly.
|
* Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -9,51 +9,85 @@
|
||||||
#include "zlib.h"
|
#include "zlib.h"
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
Decompresses the source buffer into the destination buffer. sourceLen is
|
Decompresses the source buffer into the destination buffer. *sourceLen is
|
||||||
the byte length of the source buffer. Upon entry, destLen is the total
|
the byte length of the source buffer. Upon entry, *destLen is the total size
|
||||||
size of the destination buffer, which must be large enough to hold the
|
of the destination buffer, which must be large enough to hold the entire
|
||||||
entire uncompressed data. (The size of the uncompressed data must have
|
uncompressed data. (The size of the uncompressed data must have been saved
|
||||||
been saved previously by the compressor and transmitted to the decompressor
|
previously by the compressor and transmitted to the decompressor by some
|
||||||
by some mechanism outside the scope of this compression library.)
|
mechanism outside the scope of this compression library.) Upon exit,
|
||||||
Upon exit, destLen is the actual size of the compressed buffer.
|
*destLen is the size of the decompressed data and *sourceLen is the number
|
||||||
|
of source bytes consumed. Upon return, source + *sourceLen points to the
|
||||||
|
first unused input byte.
|
||||||
|
|
||||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
|
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||||
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
|
||||||
buffer, or Z_DATA_ERROR if the input data was corrupted.
|
Z_DATA_ERROR if the input data was corrupted, including if the input data is
|
||||||
|
an incomplete zlib stream.
|
||||||
*/
|
*/
|
||||||
|
int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
|
||||||
|
Bytef *dest;
|
||||||
|
uLongf *destLen;
|
||||||
|
const Bytef *source;
|
||||||
|
uLong *sourceLen;
|
||||||
|
{
|
||||||
|
z_stream stream;
|
||||||
|
int err;
|
||||||
|
const uInt max = (uInt)-1;
|
||||||
|
uLong len, left;
|
||||||
|
Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
|
||||||
|
|
||||||
|
len = *sourceLen;
|
||||||
|
if (*destLen) {
|
||||||
|
left = *destLen;
|
||||||
|
*destLen = 0;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
left = 1;
|
||||||
|
dest = buf;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream.next_in = (z_const Bytef *)source;
|
||||||
|
stream.avail_in = 0;
|
||||||
|
stream.zalloc = (alloc_func)0;
|
||||||
|
stream.zfree = (free_func)0;
|
||||||
|
stream.opaque = (voidpf)0;
|
||||||
|
|
||||||
|
err = inflateInit(&stream);
|
||||||
|
if (err != Z_OK) return err;
|
||||||
|
|
||||||
|
stream.next_out = dest;
|
||||||
|
stream.avail_out = 0;
|
||||||
|
|
||||||
|
do {
|
||||||
|
if (stream.avail_out == 0) {
|
||||||
|
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||||
|
left -= stream.avail_out;
|
||||||
|
}
|
||||||
|
if (stream.avail_in == 0) {
|
||||||
|
stream.avail_in = len > (uLong)max ? max : (uInt)len;
|
||||||
|
len -= stream.avail_in;
|
||||||
|
}
|
||||||
|
err = inflate(&stream, Z_NO_FLUSH);
|
||||||
|
} while (err == Z_OK);
|
||||||
|
|
||||||
|
*sourceLen -= len + stream.avail_in;
|
||||||
|
if (dest != buf)
|
||||||
|
*destLen = stream.total_out;
|
||||||
|
else if (stream.total_out && err == Z_BUF_ERROR)
|
||||||
|
left = 1;
|
||||||
|
|
||||||
|
inflateEnd(&stream);
|
||||||
|
return err == Z_STREAM_END ? Z_OK :
|
||||||
|
err == Z_NEED_DICT ? Z_DATA_ERROR :
|
||||||
|
err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
|
||||||
|
err;
|
||||||
|
}
|
||||||
|
|
||||||
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
|
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
|
||||||
Bytef *dest;
|
Bytef *dest;
|
||||||
uLongf *destLen;
|
uLongf *destLen;
|
||||||
const Bytef *source;
|
const Bytef *source;
|
||||||
uLong sourceLen;
|
uLong sourceLen;
|
||||||
{
|
{
|
||||||
z_stream stream;
|
return uncompress2(dest, destLen, source, &sourceLen);
|
||||||
int err;
|
|
||||||
|
|
||||||
stream.next_in = (z_const Bytef *)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);
|
|
||||||
if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
|
|
||||||
return Z_DATA_ERROR;
|
|
||||||
return err;
|
|
||||||
}
|
|
||||||
*destLen = stream.total_out;
|
|
||||||
|
|
||||||
err = inflateEnd(&stream);
|
|
||||||
return err;
|
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* zconf.h -- configuration of the zlib compression library
|
/* zconf.h -- configuration of the zlib compression library
|
||||||
* Copyright (C) 1995-2013 Jean-loup Gailly.
|
* Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -17,7 +17,7 @@
|
||||||
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
|
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
|
||||||
# define Z_PREFIX_SET
|
# define Z_PREFIX_SET
|
||||||
|
|
||||||
/* all linked symbols */
|
/* all linked symbols and init macros */
|
||||||
# define _dist_code z__dist_code
|
# define _dist_code z__dist_code
|
||||||
# define _length_code z__length_code
|
# define _length_code z__length_code
|
||||||
# define _tr_align z__tr_align
|
# define _tr_align z__tr_align
|
||||||
|
|
@ -29,6 +29,7 @@
|
||||||
# define adler32 z_adler32
|
# define adler32 z_adler32
|
||||||
# define adler32_combine z_adler32_combine
|
# define adler32_combine z_adler32_combine
|
||||||
# define adler32_combine64 z_adler32_combine64
|
# define adler32_combine64 z_adler32_combine64
|
||||||
|
# define adler32_z z_adler32_z
|
||||||
# ifndef Z_SOLO
|
# ifndef Z_SOLO
|
||||||
# define compress z_compress
|
# define compress z_compress
|
||||||
# define compress2 z_compress2
|
# define compress2 z_compress2
|
||||||
|
|
@ -37,10 +38,14 @@
|
||||||
# define crc32 z_crc32
|
# define crc32 z_crc32
|
||||||
# define crc32_combine z_crc32_combine
|
# define crc32_combine z_crc32_combine
|
||||||
# define crc32_combine64 z_crc32_combine64
|
# define crc32_combine64 z_crc32_combine64
|
||||||
|
# define crc32_z z_crc32_z
|
||||||
# define deflate z_deflate
|
# define deflate z_deflate
|
||||||
# define deflateBound z_deflateBound
|
# define deflateBound z_deflateBound
|
||||||
# define deflateCopy z_deflateCopy
|
# define deflateCopy z_deflateCopy
|
||||||
# define deflateEnd z_deflateEnd
|
# define deflateEnd z_deflateEnd
|
||||||
|
# define deflateGetDictionary z_deflateGetDictionary
|
||||||
|
# define deflateInit z_deflateInit
|
||||||
|
# define deflateInit2 z_deflateInit2
|
||||||
# define deflateInit2_ z_deflateInit2_
|
# define deflateInit2_ z_deflateInit2_
|
||||||
# define deflateInit_ z_deflateInit_
|
# define deflateInit_ z_deflateInit_
|
||||||
# define deflateParams z_deflateParams
|
# define deflateParams z_deflateParams
|
||||||
|
|
@ -67,6 +72,8 @@
|
||||||
# define gzeof z_gzeof
|
# define gzeof z_gzeof
|
||||||
# define gzerror z_gzerror
|
# define gzerror z_gzerror
|
||||||
# define gzflush z_gzflush
|
# define gzflush z_gzflush
|
||||||
|
# define gzfread z_gzfread
|
||||||
|
# define gzfwrite z_gzfwrite
|
||||||
# define gzgetc z_gzgetc
|
# define gzgetc z_gzgetc
|
||||||
# define gzgetc_ z_gzgetc_
|
# define gzgetc_ z_gzgetc_
|
||||||
# define gzgets z_gzgets
|
# define gzgets z_gzgets
|
||||||
|
|
@ -78,7 +85,6 @@
|
||||||
# define gzopen_w z_gzopen_w
|
# define gzopen_w z_gzopen_w
|
||||||
# endif
|
# endif
|
||||||
# define gzprintf z_gzprintf
|
# define gzprintf z_gzprintf
|
||||||
# define gzvprintf z_gzvprintf
|
|
||||||
# define gzputc z_gzputc
|
# define gzputc z_gzputc
|
||||||
# define gzputs z_gzputs
|
# define gzputs z_gzputs
|
||||||
# define gzread z_gzread
|
# define gzread z_gzread
|
||||||
|
|
@ -89,32 +95,39 @@
|
||||||
# define gztell z_gztell
|
# define gztell z_gztell
|
||||||
# define gztell64 z_gztell64
|
# define gztell64 z_gztell64
|
||||||
# define gzungetc z_gzungetc
|
# define gzungetc z_gzungetc
|
||||||
|
# define gzvprintf z_gzvprintf
|
||||||
# define gzwrite z_gzwrite
|
# define gzwrite z_gzwrite
|
||||||
# endif
|
# endif
|
||||||
# define inflate z_inflate
|
# define inflate z_inflate
|
||||||
# define inflateBack z_inflateBack
|
# define inflateBack z_inflateBack
|
||||||
# define inflateBackEnd z_inflateBackEnd
|
# define inflateBackEnd z_inflateBackEnd
|
||||||
|
# define inflateBackInit z_inflateBackInit
|
||||||
# define inflateBackInit_ z_inflateBackInit_
|
# define inflateBackInit_ z_inflateBackInit_
|
||||||
|
# define inflateCodesUsed z_inflateCodesUsed
|
||||||
# define inflateCopy z_inflateCopy
|
# define inflateCopy z_inflateCopy
|
||||||
# define inflateEnd z_inflateEnd
|
# define inflateEnd z_inflateEnd
|
||||||
|
# define inflateGetDictionary z_inflateGetDictionary
|
||||||
# define inflateGetHeader z_inflateGetHeader
|
# define inflateGetHeader z_inflateGetHeader
|
||||||
|
# define inflateInit z_inflateInit
|
||||||
|
# define inflateInit2 z_inflateInit2
|
||||||
# define inflateInit2_ z_inflateInit2_
|
# define inflateInit2_ z_inflateInit2_
|
||||||
# define inflateInit_ z_inflateInit_
|
# define inflateInit_ z_inflateInit_
|
||||||
# define inflateMark z_inflateMark
|
# define inflateMark z_inflateMark
|
||||||
# define inflatePrime z_inflatePrime
|
# define inflatePrime z_inflatePrime
|
||||||
# define inflateReset z_inflateReset
|
# define inflateReset z_inflateReset
|
||||||
# define inflateReset2 z_inflateReset2
|
# define inflateReset2 z_inflateReset2
|
||||||
|
# define inflateResetKeep z_inflateResetKeep
|
||||||
# define inflateSetDictionary z_inflateSetDictionary
|
# define inflateSetDictionary z_inflateSetDictionary
|
||||||
# define inflateGetDictionary z_inflateGetDictionary
|
|
||||||
# define inflateSync z_inflateSync
|
# define inflateSync z_inflateSync
|
||||||
# define inflateSyncPoint z_inflateSyncPoint
|
# define inflateSyncPoint z_inflateSyncPoint
|
||||||
# define inflateUndermine z_inflateUndermine
|
# define inflateUndermine z_inflateUndermine
|
||||||
# define inflateResetKeep z_inflateResetKeep
|
# define inflateValidate z_inflateValidate
|
||||||
# define inflate_copyright z_inflate_copyright
|
# define inflate_copyright z_inflate_copyright
|
||||||
# define inflate_fast z_inflate_fast
|
# define inflate_fast z_inflate_fast
|
||||||
# define inflate_table z_inflate_table
|
# define inflate_table z_inflate_table
|
||||||
# ifndef Z_SOLO
|
# ifndef Z_SOLO
|
||||||
# define uncompress z_uncompress
|
# define uncompress z_uncompress
|
||||||
|
# define uncompress2 z_uncompress2
|
||||||
# endif
|
# endif
|
||||||
# define zError z_zError
|
# define zError z_zError
|
||||||
# ifndef Z_SOLO
|
# ifndef Z_SOLO
|
||||||
|
|
@ -224,9 +237,19 @@
|
||||||
# define z_const
|
# define z_const
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Some Mac compilers merge all .h files incorrectly: */
|
#ifdef Z_SOLO
|
||||||
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
|
typedef unsigned long z_size_t;
|
||||||
# define NO_DUMMY_DECL
|
#else
|
||||||
|
# define z_longlong long long
|
||||||
|
# if defined(NO_SIZE_T)
|
||||||
|
typedef unsigned NO_SIZE_T z_size_t;
|
||||||
|
# elif defined(STDC)
|
||||||
|
# include <stddef.h>
|
||||||
|
typedef size_t z_size_t;
|
||||||
|
# else
|
||||||
|
typedef unsigned long z_size_t;
|
||||||
|
# endif
|
||||||
|
# undef z_longlong
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Maximum value for memLevel in deflateInit2 */
|
/* Maximum value for memLevel in deflateInit2 */
|
||||||
|
|
@ -256,7 +279,7 @@
|
||||||
Of course this will generally degrade compression (there's no free lunch).
|
Of course this will generally degrade compression (there's no free lunch).
|
||||||
|
|
||||||
The memory requirements for inflate are (in bytes) 1 << windowBits
|
The memory requirements for inflate are (in bytes) 1 << windowBits
|
||||||
that is, 32K for windowBits=15 (default value) plus a few kilobytes
|
that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
|
||||||
for small objects.
|
for small objects.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -408,11 +431,11 @@ typedef uLong FAR uLongf;
|
||||||
typedef unsigned long z_crc_t;
|
typedef unsigned long z_crc_t;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
|
#if 1 /* was set to #if 1 by ./configure */
|
||||||
# define Z_HAVE_UNISTD_H
|
# define Z_HAVE_UNISTD_H
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
|
#if 1 /* was set to #if 1 by ./configure */
|
||||||
# define Z_HAVE_STDARG_H
|
# define Z_HAVE_STDARG_H
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,7 +1,7 @@
|
||||||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||||
version 1.2.8, April 28th, 2013
|
version 1.2.11, January 15th, 2017
|
||||||
|
|
||||||
Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
|
Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
|
||||||
|
|
||||||
This software is provided 'as-is', without any express or implied
|
This software is provided 'as-is', without any express or implied
|
||||||
warranty. In no event will the authors be held liable for any damages
|
warranty. In no event will the authors be held liable for any damages
|
||||||
|
|
@ -37,11 +37,11 @@
|
||||||
extern "C" {
|
extern "C" {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define ZLIB_VERSION "1.2.8"
|
#define ZLIB_VERSION "1.2.11"
|
||||||
#define ZLIB_VERNUM 0x1280
|
#define ZLIB_VERNUM 0x12b0
|
||||||
#define ZLIB_VER_MAJOR 1
|
#define ZLIB_VER_MAJOR 1
|
||||||
#define ZLIB_VER_MINOR 2
|
#define ZLIB_VER_MINOR 2
|
||||||
#define ZLIB_VER_REVISION 8
|
#define ZLIB_VER_REVISION 11
|
||||||
#define ZLIB_VER_SUBREVISION 0
|
#define ZLIB_VER_SUBREVISION 0
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
|
@ -65,7 +65,8 @@ extern "C" {
|
||||||
with "gz". The gzip format is different from the zlib format. gzip is a
|
with "gz". The gzip format is different from the zlib format. gzip is a
|
||||||
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
|
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
|
||||||
|
|
||||||
This library can optionally read and write gzip streams in memory as well.
|
This library can optionally read and write gzip and raw deflate streams in
|
||||||
|
memory as well.
|
||||||
|
|
||||||
The zlib format was designed to be compact and fast for use in memory
|
The zlib format was designed to be compact and fast for use in memory
|
||||||
and on communications channels. The gzip format was designed for single-
|
and on communications channels. The gzip format was designed for single-
|
||||||
|
|
@ -74,7 +75,7 @@ extern "C" {
|
||||||
|
|
||||||
The library does not install any signal handler. The decoder checks
|
The library does not install any signal handler. The decoder checks
|
||||||
the consistency of the compressed data, so the library should never crash
|
the consistency of the compressed data, so the library should never crash
|
||||||
even in case of corrupted input.
|
even in the case of corrupted input.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
|
typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
|
||||||
|
|
@ -87,7 +88,7 @@ typedef struct z_stream_s {
|
||||||
uInt avail_in; /* number of bytes available at next_in */
|
uInt avail_in; /* number of bytes available at next_in */
|
||||||
uLong total_in; /* total number of input bytes read so far */
|
uLong total_in; /* total number of input bytes read so far */
|
||||||
|
|
||||||
Bytef *next_out; /* next output byte should be put there */
|
Bytef *next_out; /* next output byte will go here */
|
||||||
uInt avail_out; /* remaining free space at next_out */
|
uInt avail_out; /* remaining free space at next_out */
|
||||||
uLong total_out; /* total number of bytes output so far */
|
uLong total_out; /* total number of bytes output so far */
|
||||||
|
|
||||||
|
|
@ -98,8 +99,9 @@ typedef struct z_stream_s {
|
||||||
free_func zfree; /* used to free the internal state */
|
free_func zfree; /* used to free the internal state */
|
||||||
voidpf opaque; /* private data object passed to zalloc and zfree */
|
voidpf opaque; /* private data object passed to zalloc and zfree */
|
||||||
|
|
||||||
int data_type; /* best guess about the data type: binary or text */
|
int data_type; /* best guess about the data type: binary or text
|
||||||
uLong adler; /* adler32 value of the uncompressed data */
|
for deflate, or the decoding state for inflate */
|
||||||
|
uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
|
||||||
uLong reserved; /* reserved for future use */
|
uLong reserved; /* reserved for future use */
|
||||||
} z_stream;
|
} z_stream;
|
||||||
|
|
||||||
|
|
@ -142,7 +144,9 @@ typedef gz_header FAR *gz_headerp;
|
||||||
|
|
||||||
zalloc must return Z_NULL if there is not enough memory for the object.
|
zalloc must return Z_NULL if there is not enough memory for the object.
|
||||||
If zlib is used in a multi-threaded application, zalloc and zfree must be
|
If zlib is used in a multi-threaded application, zalloc and zfree must be
|
||||||
thread safe.
|
thread safe. In that case, zlib is thread-safe. When zalloc and zfree are
|
||||||
|
Z_NULL on entry to the initialization function, they are set to internal
|
||||||
|
routines that use the standard library functions malloc() and free().
|
||||||
|
|
||||||
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
||||||
exactly 65536 bytes, but will not be required to allocate more than this if
|
exactly 65536 bytes, but will not be required to allocate more than this if
|
||||||
|
|
@ -155,7 +159,7 @@ typedef gz_header FAR *gz_headerp;
|
||||||
|
|
||||||
The fields total_in and total_out can be used for statistics or progress
|
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
|
reports. After compression, total_in holds the total size of the
|
||||||
uncompressed data and may be saved for use in the decompressor (particularly
|
uncompressed data and may be saved for use by the decompressor (particularly
|
||||||
if the decompressor wants to decompress everything in a single step).
|
if the decompressor wants to decompress everything in a single step).
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -200,7 +204,7 @@ typedef gz_header FAR *gz_headerp;
|
||||||
#define Z_TEXT 1
|
#define Z_TEXT 1
|
||||||
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
|
#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */
|
||||||
#define Z_UNKNOWN 2
|
#define Z_UNKNOWN 2
|
||||||
/* Possible values of the data_type field (though see inflate()) */
|
/* Possible values of the data_type field for deflate() */
|
||||||
|
|
||||||
#define Z_DEFLATED 8
|
#define Z_DEFLATED 8
|
||||||
/* The deflate compression method (the only one supported in this version) */
|
/* The deflate compression method (the only one supported in this version) */
|
||||||
|
|
@ -258,11 +262,11 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
||||||
enough room in the output buffer), next_in and avail_in are updated and
|
enough room in the output buffer), next_in and avail_in are updated and
|
||||||
processing will resume at this point for the next call of deflate().
|
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
|
- Generate 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.
|
accordingly. This action is forced if the parameter flush is non zero.
|
||||||
Forcing flush frequently degrades the compression ratio, so this parameter
|
Forcing flush frequently degrades the compression ratio, so this parameter
|
||||||
should be set only when necessary (in interactive applications). Some
|
should be set only when necessary. Some output may be provided even if
|
||||||
output may be provided even if flush is not set.
|
flush is zero.
|
||||||
|
|
||||||
Before the call of deflate(), the application should ensure that at least
|
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
|
one of the actions is possible, by providing more input and/or consuming more
|
||||||
|
|
@ -271,7 +275,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
||||||
output when it wants, for example when the output buffer is full (avail_out
|
output when it wants, for example when the output buffer is full (avail_out
|
||||||
== 0), or after each call of deflate(). If deflate returns Z_OK and with
|
== 0), or after each call of deflate(). If deflate returns Z_OK and with
|
||||||
zero avail_out, it must be called again after making room in the output
|
zero avail_out, it must be called again after making room in the output
|
||||||
buffer because there might be more output pending.
|
buffer because there might be more output pending. See deflatePending(),
|
||||||
|
which can be used if desired to determine whether or not there is more ouput
|
||||||
|
in that case.
|
||||||
|
|
||||||
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
|
Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
|
||||||
decide how much data to accumulate before producing output, in order to
|
decide how much data to accumulate before producing output, in order to
|
||||||
|
|
@ -292,8 +298,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
||||||
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
|
input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
|
||||||
This completes the current deflate block and follows it with an empty fixed
|
This completes the current deflate block and follows it with an empty fixed
|
||||||
codes block that is 10 bits long. This assures that enough bytes are output
|
codes block that is 10 bits long. This assures that enough bytes are output
|
||||||
in order for the decompressor to finish the block before the empty fixed code
|
in order for the decompressor to finish the block before the empty fixed
|
||||||
block.
|
codes block.
|
||||||
|
|
||||||
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
|
If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
|
||||||
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
|
for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
|
||||||
|
|
@ -319,34 +325,38 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
||||||
|
|
||||||
If the parameter flush is set to Z_FINISH, pending input is processed,
|
If the parameter flush is set to Z_FINISH, pending input is processed,
|
||||||
pending output is flushed and deflate returns with Z_STREAM_END if there was
|
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
|
enough output space. If deflate returns with Z_OK or Z_BUF_ERROR, this
|
||||||
called again with Z_FINISH and more output space (updated avail_out) but no
|
function must be called again with Z_FINISH and more output space (updated
|
||||||
more input data, until it returns with Z_STREAM_END or an error. After
|
avail_out) but no more input data, until it returns with Z_STREAM_END or an
|
||||||
deflate has returned Z_STREAM_END, the only possible operations on the stream
|
error. After deflate has returned Z_STREAM_END, the only possible operations
|
||||||
are deflateReset or deflateEnd.
|
on the stream are deflateReset or deflateEnd.
|
||||||
|
|
||||||
Z_FINISH can be used immediately after deflateInit if all the compression
|
Z_FINISH can be used in the first deflate call after deflateInit if all the
|
||||||
is to be done in a single step. In this case, avail_out must be at least the
|
compression is to be done in a single step. In order to complete in one
|
||||||
value returned by deflateBound (see below). Then deflate is guaranteed to
|
call, avail_out must be at least the value returned by deflateBound (see
|
||||||
return Z_STREAM_END. If not enough output space is provided, deflate will
|
below). Then deflate is guaranteed to return Z_STREAM_END. If not enough
|
||||||
not return Z_STREAM_END, and it must be called again as described above.
|
output space is provided, deflate will not return Z_STREAM_END, and it must
|
||||||
|
be called again as described above.
|
||||||
|
|
||||||
deflate() sets strm->adler to the adler32 checksum of all input read
|
deflate() sets strm->adler to the Adler-32 checksum of all input read
|
||||||
so far (that is, total_in bytes).
|
so far (that is, total_in bytes). If a gzip stream is being generated, then
|
||||||
|
strm->adler will be the CRC-32 checksum of the input read so far. (See
|
||||||
|
deflateInit2 below.)
|
||||||
|
|
||||||
deflate() may update strm->data_type if it can make a good guess about
|
deflate() may update strm->data_type if it can make a good guess about
|
||||||
the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered
|
the input data type (Z_BINARY or Z_TEXT). If in doubt, the data is
|
||||||
binary. This field is only for information purposes and does not affect the
|
considered binary. This field is only for information purposes and does not
|
||||||
compression algorithm in any manner.
|
affect the compression algorithm in any manner.
|
||||||
|
|
||||||
deflate() returns Z_OK if some progress has been made (more input
|
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
|
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
|
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
|
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
||||||
if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
|
if next_in or next_out was Z_NULL or the state was inadvertently written over
|
||||||
(for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
|
by the application), or Z_BUF_ERROR if no progress is possible (for example
|
||||||
fatal, and deflate() can be called again with more input and more output
|
avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and
|
||||||
space to continue compressing.
|
deflate() can be called again with more input and more output space to
|
||||||
|
continue compressing.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -369,23 +379,21 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
|
||||||
|
|
||||||
Initializes the internal stream state for decompression. The fields
|
Initializes the internal stream state for decompression. The fields
|
||||||
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
|
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
|
||||||
the caller. If next_in is not Z_NULL and avail_in is large enough (the
|
the caller. In the current version of inflate, the provided input is not
|
||||||
exact value depends on the compression method), inflateInit determines the
|
read or consumed. The allocation of a sliding window will be deferred to
|
||||||
compression method from the zlib header and allocates all data structures
|
the first call of inflate (if the decompression does not complete on the
|
||||||
accordingly; otherwise the allocation will be deferred to the first call of
|
first call). If zalloc and zfree are set to Z_NULL, inflateInit updates
|
||||||
inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to
|
them to use default allocation functions.
|
||||||
use default allocation functions.
|
|
||||||
|
|
||||||
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||||
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
||||||
version assumed by the caller, or Z_STREAM_ERROR if the parameters are
|
version assumed by the caller, or Z_STREAM_ERROR if the parameters are
|
||||||
invalid, such as a null pointer to the structure. msg is set to null if
|
invalid, such as a null pointer to the structure. msg is set to null if
|
||||||
there is no error message. inflateInit does not perform any decompression
|
there is no error message. inflateInit does not perform any decompression.
|
||||||
apart from possibly reading the zlib header if present: actual decompression
|
Actual decompression will be done by inflate(). So next_in, and avail_in,
|
||||||
will be done by inflate(). (So next_in and avail_in may be modified, but
|
next_out, and avail_out are unused and unchanged. The current
|
||||||
next_out and avail_out are unused and unchanged.) The current implementation
|
implementation of inflateInit() does not process any header information --
|
||||||
of inflateInit() does not process any header information -- that is deferred
|
that is deferred until inflate() is called.
|
||||||
until inflate() is called.
|
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -401,17 +409,20 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||||
|
|
||||||
- Decompress more input starting at next_in and update next_in and avail_in
|
- 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
|
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
|
enough room in the output buffer), then next_in and avail_in are updated
|
||||||
resume at this point for the next call of inflate().
|
accordingly, 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
|
- Generate more output starting at next_out and update next_out and avail_out
|
||||||
accordingly. inflate() provides as much output as possible, until there is
|
accordingly. inflate() provides as much output as possible, until there is
|
||||||
no more input data or no more space in the output buffer (see below about
|
no more input data or no more space in the output buffer (see below about
|
||||||
the flush parameter).
|
the flush parameter).
|
||||||
|
|
||||||
Before the call of inflate(), the application should ensure that at least
|
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
|
one of the actions is possible, by providing more input and/or consuming more
|
||||||
output, and updating the next_* and avail_* values accordingly. The
|
output, and updating the next_* and avail_* values accordingly. If the
|
||||||
|
caller of inflate() does not provide both available input and available
|
||||||
|
output space, it is possible that there will be no progress made. The
|
||||||
application can consume the uncompressed output when it wants, for example
|
application can consume the uncompressed output when it wants, for example
|
||||||
when the output buffer is full (avail_out == 0), or after each call of
|
when the output buffer is full (avail_out == 0), or after each call of
|
||||||
inflate(). If inflate returns Z_OK and with zero avail_out, it must be
|
inflate(). If inflate returns Z_OK and with zero avail_out, it must be
|
||||||
|
|
@ -428,7 +439,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||||
gets to the end of that block, or when it runs out of data.
|
gets to the end of that block, or when it runs out of data.
|
||||||
|
|
||||||
The Z_BLOCK option assists in appending to or combining deflate streams.
|
The Z_BLOCK option assists in appending to or combining deflate streams.
|
||||||
Also to assist in this, on return inflate() will set strm->data_type to the
|
To assist in this, on return inflate() always sets strm->data_type to the
|
||||||
number of unused bits in the last byte taken from strm->next_in, plus 64 if
|
number of unused bits in the last byte taken from strm->next_in, plus 64 if
|
||||||
inflate() is currently decoding the last block in the deflate stream, plus
|
inflate() is currently decoding the last block in the deflate stream, plus
|
||||||
128 if inflate() returned immediately after decoding an end-of-block code or
|
128 if inflate() returned immediately after decoding an end-of-block code or
|
||||||
|
|
@ -454,7 +465,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||||
this case all pending input is processed and all pending output is flushed;
|
this case all pending input is processed and all pending output is flushed;
|
||||||
avail_out must be large enough to hold all of the uncompressed data for the
|
avail_out must be large enough to hold all of the uncompressed data for the
|
||||||
operation to complete. (The size of the uncompressed data may have been
|
operation to complete. (The size of the uncompressed data may have been
|
||||||
saved by the compressor for this purpose.) The use of Z_FINISH is not
|
saved by the compressor for this purpose.) The use of Z_FINISH is not
|
||||||
required to perform an inflation in one step. However it may be used to
|
required to perform an inflation in one step. However it may be used to
|
||||||
inform inflate that a faster approach can be used for the single inflate()
|
inform inflate that a faster approach can be used for the single inflate()
|
||||||
call. Z_FINISH also informs inflate to not maintain a sliding window if the
|
call. Z_FINISH also informs inflate to not maintain a sliding window if the
|
||||||
|
|
@ -476,32 +487,33 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||||
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
|
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
|
||||||
strm->adler to the Adler-32 checksum of all output produced so far (that is,
|
strm->adler to the Adler-32 checksum of all output produced so far (that is,
|
||||||
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
|
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
|
||||||
below. At the end of the stream, inflate() checks that its computed adler32
|
below. At the end of the stream, inflate() checks that its computed Adler-32
|
||||||
checksum is equal to that saved by the compressor and returns Z_STREAM_END
|
checksum is equal to that saved by the compressor and returns Z_STREAM_END
|
||||||
only if the checksum is correct.
|
only if the checksum is correct.
|
||||||
|
|
||||||
inflate() can decompress and check either zlib-wrapped or gzip-wrapped
|
inflate() can decompress and check either zlib-wrapped or gzip-wrapped
|
||||||
deflate data. The header type is detected automatically, if requested when
|
deflate data. The header type is detected automatically, if requested when
|
||||||
initializing with inflateInit2(). Any information contained in the gzip
|
initializing with inflateInit2(). Any information contained in the gzip
|
||||||
header is not retained, so applications that need that information should
|
header is not retained unless inflateGetHeader() is used. When processing
|
||||||
instead use raw inflate, see inflateInit2() below, or inflateBack() and
|
|
||||||
perform their own processing of the gzip header and trailer. When processing
|
|
||||||
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
|
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
|
||||||
producted so far. The CRC-32 is checked against the gzip trailer.
|
produced so far. The CRC-32 is checked against the gzip trailer, as is the
|
||||||
|
uncompressed length, modulo 2^32.
|
||||||
|
|
||||||
inflate() returns Z_OK if some progress has been made (more input processed
|
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
|
or more output produced), Z_STREAM_END if the end of the compressed data has
|
||||||
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
|
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
|
||||||
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
|
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
|
||||||
corrupted (input stream not conforming to the zlib format or incorrect check
|
corrupted (input stream not conforming to the zlib format or incorrect check
|
||||||
value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
value, in which case strm->msg points to a string with a more specific
|
||||||
next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
|
error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
||||||
Z_BUF_ERROR if no progress is possible or if there was not enough room in the
|
next_in or next_out was Z_NULL, or the state was inadvertently written over
|
||||||
output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
|
||||||
|
if no progress was possible or if there was not enough room in the output
|
||||||
|
buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
||||||
inflate() can be called again with more input and more output space to
|
inflate() can be called again with more input and more output space to
|
||||||
continue decompressing. If Z_DATA_ERROR is returned, the application may
|
continue decompressing. If Z_DATA_ERROR is returned, the application may
|
||||||
then call inflateSync() to look for a good compression block if a partial
|
then call inflateSync() to look for a good compression block if a partial
|
||||||
recovery of the data is desired.
|
recovery of the data is to be attempted.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -511,9 +523,8 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
|
||||||
This function discards any unprocessed input and does not flush any pending
|
This function discards any unprocessed input and does not flush any pending
|
||||||
output.
|
output.
|
||||||
|
|
||||||
inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
|
inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state
|
||||||
was inconsistent. In the error case, msg may be set but then points to a
|
was inconsistent.
|
||||||
static string (which must not be deallocated).
|
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -544,16 +555,29 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
|
||||||
compression at the expense of memory usage. The default value is 15 if
|
compression at the expense of memory usage. The default value is 15 if
|
||||||
deflateInit is used instead.
|
deflateInit is used instead.
|
||||||
|
|
||||||
|
For the current implementation of deflate(), a windowBits value of 8 (a
|
||||||
|
window size of 256 bytes) is not supported. As a result, a request for 8
|
||||||
|
will result in 9 (a 512-byte window). In that case, providing 8 to
|
||||||
|
inflateInit2() will result in an error when the zlib header with 9 is
|
||||||
|
checked against the initialization of inflate(). The remedy is to not use 8
|
||||||
|
with deflateInit2() with this initialization, or at least in that case use 9
|
||||||
|
with inflateInit2().
|
||||||
|
|
||||||
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
|
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
|
||||||
determines the window size. deflate() will then generate raw deflate data
|
determines the window size. deflate() will then generate raw deflate data
|
||||||
with no zlib header or trailer, and will not compute an adler32 check value.
|
with no zlib header or trailer, and will not compute a check value.
|
||||||
|
|
||||||
windowBits can also be greater than 15 for optional gzip encoding. Add
|
windowBits can also be greater than 15 for optional gzip encoding. Add
|
||||||
16 to windowBits to write a simple gzip header and trailer around the
|
16 to windowBits to write a simple gzip header and trailer around the
|
||||||
compressed data instead of a zlib wrapper. The gzip header will have no
|
compressed data instead of a zlib wrapper. The gzip header will have no
|
||||||
file name, no extra data, no comment, no modification time (set to zero), no
|
file name, no extra data, no comment, no modification time (set to zero), no
|
||||||
header crc, and the operating system will be set to 255 (unknown). If a
|
header crc, and the operating system will be set to the appropriate value,
|
||||||
gzip stream is being written, strm->adler is a crc32 instead of an adler32.
|
if the operating system was determined at compile time. If a gzip stream is
|
||||||
|
being written, strm->adler is a CRC-32 instead of an Adler-32.
|
||||||
|
|
||||||
|
For raw deflate or gzip encoding, a request for a 256-byte window is
|
||||||
|
rejected as invalid, since only the zlib header provides a means of
|
||||||
|
transmitting the window size to the decompressor.
|
||||||
|
|
||||||
The memLevel parameter specifies how much memory should be allocated
|
The memLevel parameter specifies how much memory should be allocated
|
||||||
for the internal compression state. memLevel=1 uses minimum memory but is
|
for the internal compression state. memLevel=1 uses minimum memory but is
|
||||||
|
|
@ -614,12 +638,12 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
||||||
addition, the current implementation of deflate will use at most the window
|
addition, the current implementation of deflate will use at most the window
|
||||||
size minus 262 bytes of the provided dictionary.
|
size minus 262 bytes of the provided dictionary.
|
||||||
|
|
||||||
Upon return of this function, strm->adler is set to the adler32 value
|
Upon return of this function, strm->adler is set to the Adler-32 value
|
||||||
of the dictionary; the decompressor may later use this value to determine
|
of the dictionary; the decompressor may later use this value to determine
|
||||||
which dictionary has been used by the compressor. (The adler32 value
|
which dictionary has been used by the compressor. (The Adler-32 value
|
||||||
applies to the whole dictionary even if only a subset of the dictionary is
|
applies to the whole dictionary even if only a subset of the dictionary is
|
||||||
actually used by the compressor.) If a raw deflate was requested, then the
|
actually used by the compressor.) If a raw deflate was requested, then the
|
||||||
adler32 value is not computed and strm->adler is not set.
|
Adler-32 value is not computed and strm->adler is not set.
|
||||||
|
|
||||||
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
||||||
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
||||||
|
|
@ -628,6 +652,28 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
||||||
not perform any compression: this will be done by deflate().
|
not perform any compression: this will be done by deflate().
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
|
||||||
|
Bytef *dictionary,
|
||||||
|
uInt *dictLength));
|
||||||
|
/*
|
||||||
|
Returns the sliding dictionary being maintained by deflate. dictLength is
|
||||||
|
set to the number of bytes in the dictionary, and that many bytes are copied
|
||||||
|
to dictionary. dictionary must have enough space, where 32768 bytes is
|
||||||
|
always enough. If deflateGetDictionary() is called with dictionary equal to
|
||||||
|
Z_NULL, then only the dictionary length is returned, and nothing is copied.
|
||||||
|
Similary, if dictLength is Z_NULL, then it is not set.
|
||||||
|
|
||||||
|
deflateGetDictionary() may return a length less than the window size, even
|
||||||
|
when more than the window size in input has been provided. It may return up
|
||||||
|
to 258 bytes less in that case, due to how zlib's implementation of deflate
|
||||||
|
manages the sliding window and lookahead for matches, where matches can be
|
||||||
|
up to 258 bytes long. If the application needs the last window-size bytes of
|
||||||
|
input, then that would need to be saved by the application outside of zlib.
|
||||||
|
|
||||||
|
deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
|
||||||
|
stream state is inconsistent.
|
||||||
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
|
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
|
||||||
z_streamp source));
|
z_streamp source));
|
||||||
/*
|
/*
|
||||||
|
|
@ -648,10 +694,10 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
|
ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
|
||||||
/*
|
/*
|
||||||
This function is equivalent to deflateEnd followed by deflateInit,
|
This function is equivalent to deflateEnd followed by deflateInit, but
|
||||||
but does not free and reallocate all the internal compression state. The
|
does not free and reallocate the internal compression state. The stream
|
||||||
stream will keep the same compression level and any other attributes that
|
will leave the compression level and any other attributes that may have been
|
||||||
may have been set by deflateInit2.
|
set unchanged.
|
||||||
|
|
||||||
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||||
stream state was inconsistent (such as zalloc or state being Z_NULL).
|
stream state was inconsistent (such as zalloc or state being Z_NULL).
|
||||||
|
|
@ -662,20 +708,36 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
|
||||||
int strategy));
|
int strategy));
|
||||||
/*
|
/*
|
||||||
Dynamically update the compression level and compression strategy. The
|
Dynamically update the compression level and compression strategy. The
|
||||||
interpretation of level and strategy is as in deflateInit2. This can be
|
interpretation of level and strategy is as in deflateInit2(). This can be
|
||||||
used to switch between compression and straight copy of the input data, or
|
used to switch between compression and straight copy of the input data, or
|
||||||
to switch to a different kind of input data requiring a different strategy.
|
to switch to a different kind of input data requiring a different strategy.
|
||||||
If the compression level is changed, the input available so far is
|
If the compression approach (which is a function of the level) or the
|
||||||
compressed with the old level (and may be flushed); the new level will take
|
strategy is changed, and if any input has been consumed in a previous
|
||||||
effect only at the next call of deflate().
|
deflate() call, then the input available so far is compressed with the old
|
||||||
|
level and strategy using deflate(strm, Z_BLOCK). There are three approaches
|
||||||
|
for the compression levels 0, 1..3, and 4..9 respectively. The new level
|
||||||
|
and strategy will take effect at the next call of deflate().
|
||||||
|
|
||||||
Before the call of deflateParams, the stream state must be set as for
|
If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
|
||||||
a call of deflate(), since the currently available input may have to be
|
not have enough output space to complete, then the parameter change will not
|
||||||
compressed and flushed. In particular, strm->avail_out must be non-zero.
|
take effect. In this case, deflateParams() can be called again with the
|
||||||
|
same parameters and more output space to try again.
|
||||||
|
|
||||||
deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
|
In order to assure a change in the parameters on the first try, the
|
||||||
stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
|
deflate stream should be flushed using deflate() with Z_BLOCK or other flush
|
||||||
strm->avail_out was zero.
|
request until strm.avail_out is not zero, before calling deflateParams().
|
||||||
|
Then no more input data should be provided before the deflateParams() call.
|
||||||
|
If this is done, the old level and strategy will be applied to the data
|
||||||
|
compressed before deflateParams(), and the new level and strategy will be
|
||||||
|
applied to the the data compressed after deflateParams().
|
||||||
|
|
||||||
|
deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
|
||||||
|
state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
|
||||||
|
there was not enough output space to complete the compression of the
|
||||||
|
available input data before a change in the strategy or approach. Note that
|
||||||
|
in the case of a Z_BUF_ERROR, the parameters are not changed. A return
|
||||||
|
value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
|
||||||
|
retried with more output space.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
|
ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
|
||||||
|
|
@ -793,7 +855,7 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
||||||
is for use with other formats that use the deflate compressed data format
|
is for use with other formats that use the deflate compressed data format
|
||||||
such as zip. Those formats provide their own check values. If a custom
|
such as zip. Those formats provide their own check values. If a custom
|
||||||
format is developed using the raw deflate format for compressed data, it is
|
format is developed using the raw deflate format for compressed data, it is
|
||||||
recommended that a check value such as an adler32 or a crc32 be applied to
|
recommended that a check value such as an Adler-32 or a CRC-32 be applied to
|
||||||
the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
||||||
most applications, the zlib format should be used as is. Note that comments
|
most applications, the zlib format should be used as is. Note that comments
|
||||||
above on the use in deflateInit2() applies to the magnitude of windowBits.
|
above on the use in deflateInit2() applies to the magnitude of windowBits.
|
||||||
|
|
@ -802,7 +864,10 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
||||||
32 to windowBits to enable zlib and gzip decoding with automatic header
|
32 to windowBits to enable zlib and gzip decoding with automatic header
|
||||||
detection, or add 16 to decode only the gzip format (the zlib format will
|
detection, or add 16 to decode only the gzip format (the zlib format will
|
||||||
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
|
return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a
|
||||||
crc32 instead of an adler32.
|
CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
|
||||||
|
below), inflate() will not automatically decode concatenated gzip streams.
|
||||||
|
inflate() will return Z_STREAM_END at the end of the gzip stream. The state
|
||||||
|
would need to be reset to continue decoding a subsequent gzip stream.
|
||||||
|
|
||||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||||
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
|
||||||
|
|
@ -823,7 +888,7 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
||||||
Initializes the decompression dictionary from the given uncompressed byte
|
Initializes the decompression dictionary from the given uncompressed byte
|
||||||
sequence. This function must be called immediately after a call of inflate,
|
sequence. This function must be called immediately after a call of inflate,
|
||||||
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
|
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
|
||||||
can be determined from the adler32 value returned by that call of inflate.
|
can be determined from the Adler-32 value returned by that call of inflate.
|
||||||
The compressor and decompressor must use exactly the same dictionary (see
|
The compressor and decompressor must use exactly the same dictionary (see
|
||||||
deflateSetDictionary). For raw inflate, this function can be called at any
|
deflateSetDictionary). For raw inflate, this function can be called at any
|
||||||
time to set the dictionary. If the provided dictionary is smaller than the
|
time to set the dictionary. If the provided dictionary is smaller than the
|
||||||
|
|
@ -834,7 +899,7 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
||||||
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
|
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
|
||||||
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is
|
||||||
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
|
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
|
||||||
expected one (incorrect adler32 value). inflateSetDictionary does not
|
expected one (incorrect Adler-32 value). inflateSetDictionary does not
|
||||||
perform any decompression: this will be done by subsequent calls of
|
perform any decompression: this will be done by subsequent calls of
|
||||||
inflate().
|
inflate().
|
||||||
*/
|
*/
|
||||||
|
|
@ -892,7 +957,7 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
|
||||||
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
||||||
/*
|
/*
|
||||||
This function is equivalent to inflateEnd followed by inflateInit,
|
This function is equivalent to inflateEnd followed by inflateInit,
|
||||||
but does not free and reallocate all the internal decompression state. The
|
but does not free and reallocate the internal decompression state. The
|
||||||
stream will keep attributes that may have been set by inflateInit2.
|
stream will keep attributes that may have been set by inflateInit2.
|
||||||
|
|
||||||
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||||
|
|
@ -904,7 +969,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
|
||||||
/*
|
/*
|
||||||
This function is the same as inflateReset, but it also permits changing
|
This function is the same as inflateReset, but it also permits changing
|
||||||
the wrap and window size requests. The windowBits parameter is interpreted
|
the wrap and window size requests. The windowBits parameter is interpreted
|
||||||
the same as it is for inflateInit2.
|
the same as it is for inflateInit2. If the window size is changed, then the
|
||||||
|
memory allocated for the window is freed, and the window will be reallocated
|
||||||
|
by inflate() if needed.
|
||||||
|
|
||||||
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
|
inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||||
stream state was inconsistent (such as zalloc or state being Z_NULL), or if
|
stream state was inconsistent (such as zalloc or state being Z_NULL), or if
|
||||||
|
|
@ -956,7 +1023,7 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
|
||||||
location in the input stream can be determined from avail_in and data_type
|
location in the input stream can be determined from avail_in and data_type
|
||||||
as noted in the description for the Z_BLOCK flush parameter for inflate.
|
as noted in the description for the Z_BLOCK flush parameter for inflate.
|
||||||
|
|
||||||
inflateMark returns the value noted above or -1 << 16 if the provided
|
inflateMark returns the value noted above, or -65536 if the provided
|
||||||
source stream state was inconsistent.
|
source stream state was inconsistent.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -1048,9 +1115,9 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
||||||
This routine would normally be used in a utility that reads zip or gzip
|
This routine would normally be used in a utility that reads zip or gzip
|
||||||
files and writes out uncompressed files. The utility would decode the
|
files and writes out uncompressed files. The utility would decode the
|
||||||
header and process the trailer on its own, hence this routine expects only
|
header and process the trailer on its own, hence this routine expects only
|
||||||
the raw deflate stream to decompress. This is different from the normal
|
the raw deflate stream to decompress. This is different from the default
|
||||||
behavior of inflate(), which expects either a zlib or gzip header and
|
behavior of inflate(), which expects a zlib header and trailer around the
|
||||||
trailer around the deflate stream.
|
deflate stream.
|
||||||
|
|
||||||
inflateBack() uses two subroutines supplied by the caller that are then
|
inflateBack() uses two subroutines supplied by the caller that are then
|
||||||
called by inflateBack() for input and output. inflateBack() calls those
|
called by inflateBack() for input and output. inflateBack() calls those
|
||||||
|
|
@ -1059,12 +1126,12 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
||||||
parameters and return types are defined above in the in_func and out_func
|
parameters and return types are defined above in the in_func and out_func
|
||||||
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
|
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
|
||||||
number of bytes of provided input, and a pointer to that input in buf. If
|
number of bytes of provided input, and a pointer to that input in buf. If
|
||||||
there is no input available, in() must return zero--buf is ignored in that
|
there is no input available, in() must return zero -- buf is ignored in that
|
||||||
case--and inflateBack() will return a buffer error. inflateBack() will call
|
case -- and inflateBack() will return a buffer error. inflateBack() will
|
||||||
out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
|
call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].
|
||||||
should return zero on success, or non-zero on failure. If out() returns
|
out() should return zero on success, or non-zero on failure. If out()
|
||||||
non-zero, inflateBack() will return with an error. Neither in() nor out()
|
returns non-zero, inflateBack() will return with an error. Neither in() nor
|
||||||
are permitted to change the contents of the window provided to
|
out() are permitted to change the contents of the window provided to
|
||||||
inflateBackInit(), which is also the buffer that out() uses to write from.
|
inflateBackInit(), which is also the buffer that out() uses to write from.
|
||||||
The length written by out() will be at most the window size. Any non-zero
|
The length written by out() will be at most the window size. Any non-zero
|
||||||
amount of input may be provided by in().
|
amount of input may be provided by in().
|
||||||
|
|
@ -1092,7 +1159,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
|
||||||
using strm->next_in which will be Z_NULL only if in() returned an error. If
|
using strm->next_in which will be Z_NULL only if in() returned an error. If
|
||||||
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
|
strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
|
||||||
non-zero. (in() will always be called before out(), so strm->next_in is
|
non-zero. (in() will always be called before out(), so strm->next_in is
|
||||||
assured to be defined if out() returns non-zero.) Note that inflateBack()
|
assured to be defined if out() returns non-zero.) Note that inflateBack()
|
||||||
cannot return Z_OK.
|
cannot return Z_OK.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -1114,7 +1181,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
|
||||||
7.6: size of z_off_t
|
7.6: size of z_off_t
|
||||||
|
|
||||||
Compiler, assembler, and debug options:
|
Compiler, assembler, and debug options:
|
||||||
8: DEBUG
|
8: ZLIB_DEBUG
|
||||||
9: ASMV or ASMINF -- use ASM code
|
9: ASMV or ASMINF -- use ASM code
|
||||||
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
|
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
|
||||||
11: 0 (reserved)
|
11: 0 (reserved)
|
||||||
|
|
@ -1164,7 +1231,8 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
|
||||||
the byte length of the source buffer. Upon entry, destLen is the total size
|
the byte length of the source buffer. Upon entry, destLen is the total size
|
||||||
of the destination buffer, which must be at least the value returned by
|
of the destination buffer, which must be at least the value returned by
|
||||||
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||||
compressed buffer.
|
compressed data. compress() is equivalent to compress2() with a level
|
||||||
|
parameter of Z_DEFAULT_COMPRESSION.
|
||||||
|
|
||||||
compress returns Z_OK if success, Z_MEM_ERROR if there was not
|
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
|
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
||||||
|
|
@ -1180,7 +1248,7 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
|
||||||
length of the source buffer. Upon entry, destLen is the total size of the
|
length of the source buffer. Upon entry, destLen is the total size of the
|
||||||
destination buffer, which must be at least the value returned by
|
destination buffer, which must be at least the value returned by
|
||||||
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||||
compressed buffer.
|
compressed data.
|
||||||
|
|
||||||
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
compress2 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,
|
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
|
||||||
|
|
@ -1203,7 +1271,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
||||||
uncompressed data. (The size of the uncompressed data must have been saved
|
uncompressed data. (The size of the uncompressed data must have been saved
|
||||||
previously by the compressor and transmitted to the decompressor by some
|
previously by the compressor and transmitted to the decompressor by some
|
||||||
mechanism outside the scope of this compression library.) Upon exit, destLen
|
mechanism outside the scope of this compression library.) Upon exit, destLen
|
||||||
is the actual size of the uncompressed buffer.
|
is the actual size of the uncompressed data.
|
||||||
|
|
||||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
|
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
|
enough memory, Z_BUF_ERROR if there was not enough room in the output
|
||||||
|
|
@ -1212,6 +1280,14 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
||||||
buffer with the uncompressed data up to that point.
|
buffer with the uncompressed data up to that point.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
|
||||||
|
const Bytef *source, uLong *sourceLen));
|
||||||
|
/*
|
||||||
|
Same as uncompress, except that sourceLen is a pointer, where the
|
||||||
|
length of the source is *sourceLen. On return, *sourceLen is the number of
|
||||||
|
source bytes consumed.
|
||||||
|
*/
|
||||||
|
|
||||||
/* gzip file access functions */
|
/* gzip file access functions */
|
||||||
|
|
||||||
/*
|
/*
|
||||||
|
|
@ -1290,10 +1366,9 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
|
||||||
default buffer size is 8192 bytes. This function must be called after
|
default buffer size is 8192 bytes. This function must be called after
|
||||||
gzopen() or gzdopen(), and before any other calls that read or write the
|
gzopen() or gzdopen(), and before any other calls that read or write the
|
||||||
file. The buffer memory allocation is always deferred to the first read or
|
file. The buffer memory allocation is always deferred to the first read or
|
||||||
write. Two buffers are allocated, either both of the specified size when
|
write. Three times that size in buffer space is allocated. A larger buffer
|
||||||
writing, or one of the specified size and the other twice that size when
|
size of, for example, 64K or 128K bytes will noticeably increase the speed
|
||||||
reading. A larger buffer size of, for example, 64K or 128K bytes will
|
of decompression (reading).
|
||||||
noticeably increase the speed of decompression (reading).
|
|
||||||
|
|
||||||
The new buffer size also affects the maximum length for gzprintf().
|
The new buffer size also affects the maximum length for gzprintf().
|
||||||
|
|
||||||
|
|
@ -1304,10 +1379,12 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
|
||||||
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
|
ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
|
||||||
/*
|
/*
|
||||||
Dynamically update the compression level or strategy. See the description
|
Dynamically update the compression level or strategy. See the description
|
||||||
of deflateInit2 for the meaning of these parameters.
|
of deflateInit2 for the meaning of these parameters. Previously provided
|
||||||
|
data is flushed before the parameter change.
|
||||||
|
|
||||||
gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
|
gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
|
||||||
opened for writing.
|
opened for writing, Z_ERRNO if there is an error writing the flushed data,
|
||||||
|
or Z_MEM_ERROR if there is a memory allocation error.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
||||||
|
|
@ -1335,7 +1412,35 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
||||||
case.
|
case.
|
||||||
|
|
||||||
gzread returns the number of uncompressed bytes actually read, less than
|
gzread returns the number of uncompressed bytes actually read, less than
|
||||||
len for end of file, or -1 for error.
|
len for end of file, or -1 for error. If len is too large to fit in an int,
|
||||||
|
then nothing is read, -1 is returned, and the error state is set to
|
||||||
|
Z_STREAM_ERROR.
|
||||||
|
*/
|
||||||
|
|
||||||
|
ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
|
||||||
|
gzFile file));
|
||||||
|
/*
|
||||||
|
Read up to nitems items of size size from file to buf, otherwise operating
|
||||||
|
as gzread() does. This duplicates the interface of stdio's fread(), with
|
||||||
|
size_t request and return types. If the library defines size_t, then
|
||||||
|
z_size_t is identical to size_t. If not, then z_size_t is an unsigned
|
||||||
|
integer type that can contain a pointer.
|
||||||
|
|
||||||
|
gzfread() returns the number of full items read of size size, or zero if
|
||||||
|
the end of the file was reached and a full item could not be read, or if
|
||||||
|
there was an error. gzerror() must be consulted if zero is returned in
|
||||||
|
order to determine if there was an error. If the multiplication of size and
|
||||||
|
nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
|
||||||
|
is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
|
||||||
|
|
||||||
|
In the event that the end of file is reached and only a partial item is
|
||||||
|
available at the end, i.e. the remaining uncompressed data length is not a
|
||||||
|
multiple of size, then the final partial item is nevetheless read into buf
|
||||||
|
and the end-of-file flag is set. The length of the partial item read is not
|
||||||
|
provided, but could be inferred from the result of gztell(). This behavior
|
||||||
|
is the same as the behavior of fread() implementations in common libraries,
|
||||||
|
but it prevents the direct use of gzfread() to read a concurrently written
|
||||||
|
file, reseting and retrying on end-of-file, when size is not 1.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
||||||
|
|
@ -1346,19 +1451,33 @@ ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
||||||
error.
|
error.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
|
||||||
|
z_size_t nitems, gzFile file));
|
||||||
|
/*
|
||||||
|
gzfwrite() writes nitems items of size size from buf to file, duplicating
|
||||||
|
the interface of stdio's fwrite(), with size_t request and return types. If
|
||||||
|
the library defines size_t, then z_size_t is identical to size_t. If not,
|
||||||
|
then z_size_t is an unsigned integer type that can contain a pointer.
|
||||||
|
|
||||||
|
gzfwrite() returns the number of full items written of size size, or zero
|
||||||
|
if there was an error. If the multiplication of size and nitems overflows,
|
||||||
|
i.e. the product does not fit in a z_size_t, then nothing is written, zero
|
||||||
|
is returned, and the error state is set to Z_STREAM_ERROR.
|
||||||
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
|
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...));
|
||||||
/*
|
/*
|
||||||
Converts, formats, and writes the arguments to the compressed file under
|
Converts, formats, and writes the arguments to the compressed file under
|
||||||
control of the format string, as in fprintf. gzprintf returns the number of
|
control of the format string, as in fprintf. gzprintf returns the number of
|
||||||
uncompressed bytes actually written, or 0 in case of error. The number of
|
uncompressed bytes actually written, or a negative zlib error code in case
|
||||||
uncompressed bytes written is limited to 8191, or one less than the buffer
|
of error. The number of uncompressed bytes written is limited to 8191, or
|
||||||
size given to gzbuffer(). The caller should assure that this limit is not
|
one less than the buffer size given to gzbuffer(). The caller should assure
|
||||||
exceeded. If it is exceeded, then gzprintf() will return an error (0) with
|
that this limit is not exceeded. If it is exceeded, then gzprintf() will
|
||||||
nothing written. In this case, there may also be a buffer overflow with
|
return an error (0) with nothing written. In this case, there may also be a
|
||||||
unpredictable consequences, which is possible only if zlib was compiled with
|
buffer overflow with unpredictable consequences, which is possible only if
|
||||||
the insecure functions sprintf() or vsprintf() because the secure snprintf()
|
zlib was compiled with the insecure functions sprintf() or vsprintf()
|
||||||
or vsnprintf() functions were not available. This can be determined using
|
because the secure snprintf() or vsnprintf() functions were not available.
|
||||||
zlibCompileFlags().
|
This can be determined using zlibCompileFlags().
|
||||||
*/
|
*/
|
||||||
|
|
||||||
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
|
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
|
||||||
|
|
@ -1418,7 +1537,7 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
|
||||||
If the flush parameter is Z_FINISH, the remaining data is written and the
|
If the flush parameter is Z_FINISH, the remaining data is written and the
|
||||||
gzip stream is completed in the output. If gzwrite() is called again, a new
|
gzip stream is completed in the output. If gzwrite() is called again, a new
|
||||||
gzip stream will be started in the output. gzread() is able to read such
|
gzip stream will be started in the output. gzread() is able to read such
|
||||||
concatented gzip streams.
|
concatenated gzip streams.
|
||||||
|
|
||||||
gzflush should be called only when strictly necessary because it will
|
gzflush should be called only when strictly necessary because it will
|
||||||
degrade compression if called too often.
|
degrade compression if called too often.
|
||||||
|
|
@ -1572,7 +1691,7 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
|
||||||
return the updated checksum. If buf is Z_NULL, this function returns the
|
return the updated checksum. If buf is Z_NULL, this function returns the
|
||||||
required initial value for the checksum.
|
required initial value for the checksum.
|
||||||
|
|
||||||
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
|
An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed
|
||||||
much faster.
|
much faster.
|
||||||
|
|
||||||
Usage example:
|
Usage example:
|
||||||
|
|
@ -1585,6 +1704,12 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
|
||||||
if (adler != original_adler) error();
|
if (adler != original_adler) error();
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
|
||||||
|
z_size_t len));
|
||||||
|
/*
|
||||||
|
Same as adler32(), but with a size_t length.
|
||||||
|
*/
|
||||||
|
|
||||||
/*
|
/*
|
||||||
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
|
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
|
||||||
z_off_t len2));
|
z_off_t len2));
|
||||||
|
|
@ -1614,6 +1739,12 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
|
||||||
if (crc != original_crc) error();
|
if (crc != original_crc) error();
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
|
||||||
|
z_size_t len));
|
||||||
|
/*
|
||||||
|
Same as crc32(), but with a size_t length.
|
||||||
|
*/
|
||||||
|
|
||||||
/*
|
/*
|
||||||
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
|
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
|
||||||
|
|
||||||
|
|
@ -1644,19 +1775,35 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
|
||||||
unsigned char FAR *window,
|
unsigned char FAR *window,
|
||||||
const char *version,
|
const char *version,
|
||||||
int stream_size));
|
int stream_size));
|
||||||
#define deflateInit(strm, level) \
|
#ifdef Z_PREFIX_SET
|
||||||
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
# define z_deflateInit(strm, level) \
|
||||||
#define inflateInit(strm) \
|
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
# define z_inflateInit(strm) \
|
||||||
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
||||||
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
||||||
#define inflateInit2(strm, windowBits) \
|
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
# define z_inflateInit2(strm, windowBits) \
|
||||||
(int)sizeof(z_stream))
|
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
||||||
#define inflateBackInit(strm, windowBits, window) \
|
(int)sizeof(z_stream))
|
||||||
inflateBackInit_((strm), (windowBits), (window), \
|
# define z_inflateBackInit(strm, windowBits, window) \
|
||||||
ZLIB_VERSION, (int)sizeof(z_stream))
|
inflateBackInit_((strm), (windowBits), (window), \
|
||||||
|
ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
|
#else
|
||||||
|
# define deflateInit(strm, level) \
|
||||||
|
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
|
# define inflateInit(strm) \
|
||||||
|
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
|
# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
|
||||||
|
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
|
||||||
|
(strategy), ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
|
# define inflateInit2(strm, windowBits) \
|
||||||
|
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
|
||||||
|
(int)sizeof(z_stream))
|
||||||
|
# define inflateBackInit(strm, windowBits, window) \
|
||||||
|
inflateBackInit_((strm), (windowBits), (window), \
|
||||||
|
ZLIB_VERSION, (int)sizeof(z_stream))
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifndef Z_SOLO
|
#ifndef Z_SOLO
|
||||||
|
|
||||||
|
|
@ -1676,10 +1823,10 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
|
||||||
#ifdef Z_PREFIX_SET
|
#ifdef Z_PREFIX_SET
|
||||||
# undef z_gzgetc
|
# undef z_gzgetc
|
||||||
# define z_gzgetc(g) \
|
# define z_gzgetc(g) \
|
||||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
|
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
|
||||||
#else
|
#else
|
||||||
# define gzgetc(g) \
|
# define gzgetc(g) \
|
||||||
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g))
|
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
|
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
|
||||||
|
|
@ -1737,19 +1884,16 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
|
||||||
|
|
||||||
#endif /* !Z_SOLO */
|
#endif /* !Z_SOLO */
|
||||||
|
|
||||||
/* hack for buggy compilers */
|
|
||||||
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
|
|
||||||
struct internal_state {int dummy;};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* undocumented functions */
|
/* undocumented functions */
|
||||||
ZEXTERN const char * ZEXPORT zError OF((int));
|
ZEXTERN const char * ZEXPORT zError OF((int));
|
||||||
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
|
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
|
||||||
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
|
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
|
||||||
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
|
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
|
||||||
|
ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
|
||||||
|
ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
|
||||||
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
|
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
|
||||||
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
|
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
|
||||||
#if defined(_WIN32) && !defined(Z_SOLO)
|
#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
|
||||||
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
|
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
|
||||||
const char *mode));
|
const char *mode));
|
||||||
#endif
|
#endif
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* zutil.c -- target dependent utility functions for the compression library
|
/* zutil.c -- target dependent utility functions for the compression library
|
||||||
* Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
|
* Copyright (C) 1995-2017 Jean-loup Gailly
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -10,21 +10,18 @@
|
||||||
# include "gzguts.h"
|
# include "gzguts.h"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef NO_DUMMY_DECL
|
|
||||||
struct internal_state {int dummy;}; /* for buggy compilers */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
z_const char * const z_errmsg[10] = {
|
z_const char * const z_errmsg[10] = {
|
||||||
"need dictionary", /* Z_NEED_DICT 2 */
|
(z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
|
||||||
"stream end", /* Z_STREAM_END 1 */
|
(z_const char *)"stream end", /* Z_STREAM_END 1 */
|
||||||
"", /* Z_OK 0 */
|
(z_const char *)"", /* Z_OK 0 */
|
||||||
"file error", /* Z_ERRNO (-1) */
|
(z_const char *)"file error", /* Z_ERRNO (-1) */
|
||||||
"stream error", /* Z_STREAM_ERROR (-2) */
|
(z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
|
||||||
"data error", /* Z_DATA_ERROR (-3) */
|
(z_const char *)"data error", /* Z_DATA_ERROR (-3) */
|
||||||
"insufficient memory", /* Z_MEM_ERROR (-4) */
|
(z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
|
||||||
"buffer error", /* Z_BUF_ERROR (-5) */
|
(z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
|
||||||
"incompatible version",/* Z_VERSION_ERROR (-6) */
|
(z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
|
||||||
""};
|
(z_const char *)""
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
const char * ZEXPORT zlibVersion()
|
const char * ZEXPORT zlibVersion()
|
||||||
|
|
@ -61,7 +58,7 @@ uLong ZEXPORT zlibCompileFlags()
|
||||||
case 8: flags += 2 << 6; break;
|
case 8: flags += 2 << 6; break;
|
||||||
default: flags += 3 << 6;
|
default: flags += 3 << 6;
|
||||||
}
|
}
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
flags += 1 << 8;
|
flags += 1 << 8;
|
||||||
#endif
|
#endif
|
||||||
#if defined(ASMV) || defined(ASMINF)
|
#if defined(ASMV) || defined(ASMINF)
|
||||||
|
|
@ -115,8 +112,8 @@ uLong ZEXPORT zlibCompileFlags()
|
||||||
return flags;
|
return flags;
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
|
#include <stdlib.h>
|
||||||
# ifndef verbose
|
# ifndef verbose
|
||||||
# define verbose 0
|
# define verbose 0
|
||||||
# endif
|
# endif
|
||||||
|
|
@ -219,9 +216,11 @@ local ptr_table table[MAX_PTR];
|
||||||
|
|
||||||
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
||||||
{
|
{
|
||||||
voidpf buf = opaque; /* just to make some compilers happy */
|
voidpf buf;
|
||||||
ulg bsize = (ulg)items*size;
|
ulg bsize = (ulg)items*size;
|
||||||
|
|
||||||
|
(void)opaque;
|
||||||
|
|
||||||
/* If we allocate less than 65520 bytes, we assume that farmalloc
|
/* If we allocate less than 65520 bytes, we assume that farmalloc
|
||||||
* will return a usable pointer which doesn't have to be normalized.
|
* will return a usable pointer which doesn't have to be normalized.
|
||||||
*/
|
*/
|
||||||
|
|
@ -244,6 +243,9 @@ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
||||||
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
{
|
{
|
||||||
int n;
|
int n;
|
||||||
|
|
||||||
|
(void)opaque;
|
||||||
|
|
||||||
if (*(ush*)&ptr != 0) { /* object < 64K */
|
if (*(ush*)&ptr != 0) { /* object < 64K */
|
||||||
farfree(ptr);
|
farfree(ptr);
|
||||||
return;
|
return;
|
||||||
|
|
@ -259,7 +261,6 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
next_ptr--;
|
next_ptr--;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
ptr = opaque; /* just to make some compilers happy */
|
|
||||||
Assert(0, "zcfree: ptr not found");
|
Assert(0, "zcfree: ptr not found");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -278,13 +279,13 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
|
|
||||||
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
|
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
|
||||||
{
|
{
|
||||||
if (opaque) opaque = 0; /* to make compiler happy */
|
(void)opaque;
|
||||||
return _halloc((long)items, size);
|
return _halloc((long)items, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
{
|
{
|
||||||
if (opaque) opaque = 0; /* to make compiler happy */
|
(void)opaque;
|
||||||
_hfree(ptr);
|
_hfree(ptr);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -306,7 +307,7 @@ voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
|
||||||
unsigned items;
|
unsigned items;
|
||||||
unsigned size;
|
unsigned size;
|
||||||
{
|
{
|
||||||
if (opaque) items += size - size; /* make compiler happy */
|
(void)opaque;
|
||||||
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
|
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
|
||||||
(voidpf)calloc(items, size);
|
(voidpf)calloc(items, size);
|
||||||
}
|
}
|
||||||
|
|
@ -315,8 +316,8 @@ void ZLIB_INTERNAL zcfree (opaque, ptr)
|
||||||
voidpf opaque;
|
voidpf opaque;
|
||||||
voidpf ptr;
|
voidpf ptr;
|
||||||
{
|
{
|
||||||
|
(void)opaque;
|
||||||
free(ptr);
|
free(ptr);
|
||||||
if (opaque) return; /* make compiler happy */
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif /* MY_ZCALLOC */
|
#endif /* MY_ZCALLOC */
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
/* zutil.h -- internal interface and configuration of the compression library
|
/* zutil.h -- internal interface and configuration of the compression library
|
||||||
* Copyright (C) 1995-2013 Jean-loup Gailly.
|
* Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
|
@ -36,7 +36,9 @@
|
||||||
#ifndef local
|
#ifndef local
|
||||||
# define local static
|
# define local static
|
||||||
#endif
|
#endif
|
||||||
/* compile with -Dlocal if your debugger can't find static symbols */
|
/* since "static" is used to mean two completely different things in C, we
|
||||||
|
define "local" for the non-static meaning of "static", for readability
|
||||||
|
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||||
|
|
||||||
typedef unsigned char uch;
|
typedef unsigned char uch;
|
||||||
typedef uch FAR uchf;
|
typedef uch FAR uchf;
|
||||||
|
|
@ -98,28 +100,38 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef AMIGA
|
#ifdef AMIGA
|
||||||
# define OS_CODE 0x01
|
# define OS_CODE 1
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(VAXC) || defined(VMS)
|
#if defined(VAXC) || defined(VMS)
|
||||||
# define OS_CODE 0x02
|
# define OS_CODE 2
|
||||||
# define F_OPEN(name, mode) \
|
# define F_OPEN(name, mode) \
|
||||||
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifdef __370__
|
||||||
|
# if __TARGET_LIB__ < 0x20000000
|
||||||
|
# define OS_CODE 4
|
||||||
|
# elif __TARGET_LIB__ < 0x40000000
|
||||||
|
# define OS_CODE 11
|
||||||
|
# else
|
||||||
|
# define OS_CODE 8
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
#if defined(ATARI) || defined(atarist)
|
#if defined(ATARI) || defined(atarist)
|
||||||
# define OS_CODE 0x05
|
# define OS_CODE 5
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef OS2
|
#ifdef OS2
|
||||||
# define OS_CODE 0x06
|
# define OS_CODE 6
|
||||||
# if defined(M_I86) && !defined(Z_SOLO)
|
# if defined(M_I86) && !defined(Z_SOLO)
|
||||||
# include <malloc.h>
|
# include <malloc.h>
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(MACOS) || defined(TARGET_OS_MAC)
|
#if defined(MACOS) || defined(TARGET_OS_MAC)
|
||||||
# define OS_CODE 0x07
|
# define OS_CODE 7
|
||||||
# ifndef Z_SOLO
|
# ifndef Z_SOLO
|
||||||
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
|
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
|
||||||
# include <unix.h> /* for fdopen */
|
# include <unix.h> /* for fdopen */
|
||||||
|
|
@ -131,18 +143,24 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
||||||
# endif
|
# endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef TOPS20
|
#ifdef __acorn
|
||||||
# define OS_CODE 0x0a
|
# define OS_CODE 13
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef WIN32
|
#if defined(WIN32) && !defined(__CYGWIN__)
|
||||||
# ifndef __CYGWIN__ /* Cygwin is Unix, not Win32 */
|
# define OS_CODE 10
|
||||||
# define OS_CODE 0x0b
|
|
||||||
# endif
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifdef __50SERIES /* Prime/PRIMOS */
|
#ifdef _BEOS_
|
||||||
# define OS_CODE 0x0f
|
# define OS_CODE 16
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __TOS_OS400__
|
||||||
|
# define OS_CODE 18
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
# define OS_CODE 19
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(_BEOS_) || defined(RISCOS)
|
#if defined(_BEOS_) || defined(RISCOS)
|
||||||
|
|
@ -177,7 +195,7 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
||||||
/* common defaults */
|
/* common defaults */
|
||||||
|
|
||||||
#ifndef OS_CODE
|
#ifndef OS_CODE
|
||||||
# define OS_CODE 0x03 /* assume Unix */
|
# define OS_CODE 3 /* assume Unix */
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef F_OPEN
|
#ifndef F_OPEN
|
||||||
|
|
@ -216,7 +234,7 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* Diagnostic functions */
|
/* Diagnostic functions */
|
||||||
#ifdef DEBUG
|
#ifdef ZLIB_DEBUG
|
||||||
# include <stdio.h>
|
# include <stdio.h>
|
||||||
extern int ZLIB_INTERNAL z_verbose;
|
extern int ZLIB_INTERNAL z_verbose;
|
||||||
extern void ZLIB_INTERNAL z_error OF((char *m));
|
extern void ZLIB_INTERNAL z_error OF((char *m));
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue