mirror of
https://github.com/libretro/libretro-atari800.git
synced 2024-12-03 13:21:17 +00:00
(zlib) Cleanups
This commit is contained in:
twinaphex
parent
cd61841777
commit
478a8ec99a
90
deps/zlib/adler32.c
vendored
90
deps/zlib/adler32.c
vendored
@ -9,8 +9,6 @@
|
|||||||
|
|
||||||
#define local static
|
#define local static
|
||||||
|
|
||||||
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
|
||||||
|
|
||||||
#define BASE 65521 /* largest prime smaller than 65536 */
|
#define BASE 65521 /* 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 */
|
||||||
@ -21,45 +19,9 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
|||||||
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
||||||
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
||||||
|
|
||||||
/* use NO_DIVIDE if your processor does not do division in hardware --
|
#define MOD(a) a %= BASE
|
||||||
try it both ways to see which is faster */
|
#define MOD28(a) a %= BASE
|
||||||
#ifdef NO_DIVIDE
|
#define MOD63(a) a %= BASE
|
||||||
/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
|
|
||||||
(thank you to John Reiser for pointing this out) */
|
|
||||||
# define CHOP(a) \
|
|
||||||
do { \
|
|
||||||
unsigned long tmp = a >> 16; \
|
|
||||||
a &= 0xffffUL; \
|
|
||||||
a += (tmp << 4) - tmp; \
|
|
||||||
} while (0)
|
|
||||||
# define MOD28(a) \
|
|
||||||
do { \
|
|
||||||
CHOP(a); \
|
|
||||||
if (a >= BASE) a -= BASE; \
|
|
||||||
} while (0)
|
|
||||||
# define MOD(a) \
|
|
||||||
do { \
|
|
||||||
CHOP(a); \
|
|
||||||
MOD28(a); \
|
|
||||||
} while (0)
|
|
||||||
# define MOD63(a) \
|
|
||||||
do { /* this assumes a is not negative */ \
|
|
||||||
z_off64_t tmp = a >> 32; \
|
|
||||||
a &= 0xffffffffL; \
|
|
||||||
a += (tmp << 8) - (tmp << 5) + tmp; \
|
|
||||||
tmp = a >> 16; \
|
|
||||||
a &= 0xffffL; \
|
|
||||||
a += (tmp << 4) - tmp; \
|
|
||||||
tmp = a >> 16; \
|
|
||||||
a &= 0xffffL; \
|
|
||||||
a += (tmp << 4) - tmp; \
|
|
||||||
if (a >= BASE) a -= BASE; \
|
|
||||||
} while (0)
|
|
||||||
#else
|
|
||||||
# define MOD(a) a %= BASE
|
|
||||||
# define MOD28(a) a %= BASE
|
|
||||||
# define MOD63(a) a %= BASE
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
/* ========================================================================= */
|
||||||
uLong ZEXPORT adler32(adler, buf, len)
|
uLong ZEXPORT adler32(adler, buf, len)
|
||||||
@ -131,49 +93,3 @@ uLong ZEXPORT adler32(adler, buf, len)
|
|||||||
/* return recombined sums */
|
/* return recombined sums */
|
||||||
return adler | (sum2 << 16);
|
return adler | (sum2 << 16);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local uLong adler32_combine_(adler1, adler2, len2)
|
|
||||||
uLong adler1;
|
|
||||||
uLong adler2;
|
|
||||||
z_off64_t len2;
|
|
||||||
{
|
|
||||||
unsigned long sum1;
|
|
||||||
unsigned long sum2;
|
|
||||||
unsigned rem;
|
|
||||||
|
|
||||||
/* for negative len, return invalid adler32 as a clue for debugging */
|
|
||||||
if (len2 < 0)
|
|
||||||
return 0xffffffffUL;
|
|
||||||
|
|
||||||
/* the derivation of this formula is left as an exercise for the reader */
|
|
||||||
MOD63(len2); /* assumes len2 >= 0 */
|
|
||||||
rem = (unsigned)len2;
|
|
||||||
sum1 = adler1 & 0xffff;
|
|
||||||
sum2 = rem * sum1;
|
|
||||||
MOD(sum2);
|
|
||||||
sum1 += (adler2 & 0xffff) + BASE - 1;
|
|
||||||
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
|
||||||
if (sum1 >= BASE) sum1 -= BASE;
|
|
||||||
if (sum1 >= BASE) sum1 -= BASE;
|
|
||||||
if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
|
|
||||||
if (sum2 >= BASE) sum2 -= BASE;
|
|
||||||
return sum1 | (sum2 << 16);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
|
|
||||||
uLong adler1;
|
|
||||||
uLong adler2;
|
|
||||||
z_off_t len2;
|
|
||||||
{
|
|
||||||
return adler32_combine_(adler1, adler2, len2);
|
|
||||||
}
|
|
||||||
|
|
||||||
uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
|
|
||||||
uLong adler1;
|
|
||||||
uLong adler2;
|
|
||||||
z_off64_t len2;
|
|
||||||
{
|
|
||||||
return adler32_combine_(adler1, adler2, len2);
|
|
||||||
}
|
|
||||||
|
|||||||
373
deps/zlib/crc32.c
vendored
373
deps/zlib/crc32.c
vendored
@ -11,188 +11,22 @@
|
|||||||
|
|
||||||
/* @(#) $Id$ */
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
/*
|
|
||||||
Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
|
|
||||||
protection on the static variables used to control the first-use generation
|
|
||||||
of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
|
|
||||||
first call get_crc_table() to initialize the tables before allowing more than
|
|
||||||
one thread to use crc32().
|
|
||||||
|
|
||||||
DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifdef MAKECRCH
|
|
||||||
# include <stdio.h>
|
|
||||||
# ifndef DYNAMIC_CRC_TABLE
|
|
||||||
# define DYNAMIC_CRC_TABLE
|
|
||||||
# endif /* !DYNAMIC_CRC_TABLE */
|
|
||||||
#endif /* MAKECRCH */
|
|
||||||
|
|
||||||
#include "zutil.h" /* for STDC and FAR definitions */
|
#include "zutil.h" /* for STDC and FAR definitions */
|
||||||
|
|
||||||
#define local static
|
#define local static
|
||||||
|
|
||||||
/* Definitions for doing the crc four data bytes at a time. */
|
#define TBLS 1
|
||||||
#if !defined(NOBYFOUR) && defined(Z_U4)
|
|
||||||
# define BYFOUR
|
|
||||||
#endif
|
|
||||||
#ifdef BYFOUR
|
|
||||||
local unsigned long crc32_little OF((unsigned long,
|
|
||||||
const unsigned char FAR *, unsigned));
|
|
||||||
local unsigned long crc32_big OF((unsigned long,
|
|
||||||
const unsigned char FAR *, unsigned));
|
|
||||||
# define TBLS 8
|
|
||||||
#else
|
|
||||||
# define TBLS 1
|
|
||||||
#endif /* BYFOUR */
|
|
||||||
|
|
||||||
/* Local functions for crc concatenation */
|
|
||||||
local unsigned long gf2_matrix_times OF((unsigned long *mat,
|
|
||||||
unsigned long vec));
|
|
||||||
local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
|
|
||||||
local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
|
|
||||||
|
|
||||||
|
|
||||||
#ifdef DYNAMIC_CRC_TABLE
|
|
||||||
|
|
||||||
local volatile int crc_table_empty = 1;
|
|
||||||
local z_crc_t FAR crc_table[TBLS][256];
|
|
||||||
local void make_crc_table OF((void));
|
|
||||||
#ifdef MAKECRCH
|
|
||||||
local void write_table OF((FILE *, const z_crc_t FAR *));
|
|
||||||
#endif /* MAKECRCH */
|
|
||||||
/*
|
|
||||||
Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
|
|
||||||
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
|
|
||||||
|
|
||||||
Polynomials over GF(2) are represented in binary, one bit per coefficient,
|
|
||||||
with the lowest powers in the most significant bit. Then adding polynomials
|
|
||||||
is just exclusive-or, and multiplying a polynomial by x is a right shift by
|
|
||||||
one. If we call the above polynomial p, and represent a byte as the
|
|
||||||
polynomial q, also with the lowest power in the most significant bit (so the
|
|
||||||
byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
|
|
||||||
where a mod b means the remainder after dividing a by b.
|
|
||||||
|
|
||||||
This calculation is done using the shift-register method of multiplying and
|
|
||||||
taking the remainder. The register is initialized to zero, and for each
|
|
||||||
incoming bit, x^32 is added mod p to the register if the bit is a one (where
|
|
||||||
x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
|
|
||||||
x (which is shifting right by one and adding x^32 mod p if the bit shifted
|
|
||||||
out is a one). We start with the highest power (least significant bit) of
|
|
||||||
q and repeat for all eight bits of q.
|
|
||||||
|
|
||||||
The first table is simply the CRC of all possible eight bit values. This is
|
|
||||||
all the information needed to generate CRCs on data a byte at a time for all
|
|
||||||
combinations of CRC register values and incoming bytes. The remaining tables
|
|
||||||
allow for word-at-a-time CRC calculation for both big-endian and little-
|
|
||||||
endian machines, where a word is four bytes.
|
|
||||||
*/
|
|
||||||
local void make_crc_table()
|
|
||||||
{
|
|
||||||
z_crc_t c;
|
|
||||||
int n, k;
|
|
||||||
z_crc_t poly; /* polynomial exclusive-or pattern */
|
|
||||||
/* terms of polynomial defining this crc (except x^32): */
|
|
||||||
static volatile int first = 1; /* flag to limit concurrent making */
|
|
||||||
static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
|
|
||||||
|
|
||||||
/* See if another task is already doing this (not thread-safe, but better
|
|
||||||
than nothing -- significantly reduces duration of vulnerability in
|
|
||||||
case the advice about DYNAMIC_CRC_TABLE is ignored) */
|
|
||||||
if (first) {
|
|
||||||
first = 0;
|
|
||||||
|
|
||||||
/* make exclusive-or pattern from polynomial (0xedb88320UL) */
|
|
||||||
poly = 0;
|
|
||||||
for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
|
|
||||||
poly |= (z_crc_t)1 << (31 - p[n]);
|
|
||||||
|
|
||||||
/* generate a crc for every 8-bit value */
|
|
||||||
for (n = 0; n < 256; n++) {
|
|
||||||
c = (z_crc_t)n;
|
|
||||||
for (k = 0; k < 8; k++)
|
|
||||||
c = c & 1 ? poly ^ (c >> 1) : c >> 1;
|
|
||||||
crc_table[0][n] = c;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef BYFOUR
|
|
||||||
/* generate crc for each value followed by one, two, and three zeros,
|
|
||||||
and then the byte reversal of those as well as the first table */
|
|
||||||
for (n = 0; n < 256; n++) {
|
|
||||||
c = crc_table[0][n];
|
|
||||||
crc_table[4][n] = ZSWAP32(c);
|
|
||||||
for (k = 1; k < 4; k++) {
|
|
||||||
c = crc_table[0][c & 0xff] ^ (c >> 8);
|
|
||||||
crc_table[k][n] = c;
|
|
||||||
crc_table[k + 4][n] = ZSWAP32(c);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif /* BYFOUR */
|
|
||||||
|
|
||||||
crc_table_empty = 0;
|
|
||||||
}
|
|
||||||
else { /* not first */
|
|
||||||
/* wait for the other guy to finish (not efficient, but rare) */
|
|
||||||
while (crc_table_empty)
|
|
||||||
;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef MAKECRCH
|
|
||||||
/* write out CRC tables to crc32.h */
|
|
||||||
{
|
|
||||||
FILE *out;
|
|
||||||
|
|
||||||
out = fopen("crc32.h", "w");
|
|
||||||
if (out == NULL) return;
|
|
||||||
fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
|
|
||||||
fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
|
|
||||||
fprintf(out, "local const z_crc_t FAR ");
|
|
||||||
fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
|
|
||||||
write_table(out, crc_table[0]);
|
|
||||||
# ifdef BYFOUR
|
|
||||||
fprintf(out, "#ifdef BYFOUR\n");
|
|
||||||
for (k = 1; k < 8; k++) {
|
|
||||||
fprintf(out, " },\n {\n");
|
|
||||||
write_table(out, crc_table[k]);
|
|
||||||
}
|
|
||||||
fprintf(out, "#endif\n");
|
|
||||||
# endif /* BYFOUR */
|
|
||||||
fprintf(out, " }\n};\n");
|
|
||||||
fclose(out);
|
|
||||||
}
|
|
||||||
#endif /* MAKECRCH */
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef MAKECRCH
|
|
||||||
local void write_table(out, table)
|
|
||||||
FILE *out;
|
|
||||||
const z_crc_t FAR *table;
|
|
||||||
{
|
|
||||||
int n;
|
|
||||||
|
|
||||||
for (n = 0; n < 256; n++)
|
|
||||||
fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ",
|
|
||||||
(unsigned long)(table[n]),
|
|
||||||
n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
|
|
||||||
}
|
|
||||||
#endif /* MAKECRCH */
|
|
||||||
|
|
||||||
#else /* !DYNAMIC_CRC_TABLE */
|
|
||||||
/* ========================================================================
|
/* ========================================================================
|
||||||
* Tables of CRC-32s of all single-byte values, made by make_crc_table().
|
* Tables of CRC-32s of all single-byte values, made by make_crc_table().
|
||||||
*/
|
*/
|
||||||
#include "crc32.h"
|
#include "crc32.h"
|
||||||
#endif /* DYNAMIC_CRC_TABLE */
|
|
||||||
|
|
||||||
/* =========================================================================
|
/* =========================================================================
|
||||||
* This function can be used by asm versions of crc32()
|
* This function can be used by asm versions of crc32()
|
||||||
*/
|
*/
|
||||||
const z_crc_t FAR * ZEXPORT get_crc_table()
|
const z_crc_t FAR * ZEXPORT get_crc_table()
|
||||||
{
|
{
|
||||||
#ifdef DYNAMIC_CRC_TABLE
|
|
||||||
if (crc_table_empty)
|
|
||||||
make_crc_table();
|
|
||||||
#endif /* DYNAMIC_CRC_TABLE */
|
|
||||||
return (const z_crc_t FAR *)crc_table;
|
return (const z_crc_t FAR *)crc_table;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -208,22 +42,6 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
|||||||
{
|
{
|
||||||
if (buf == Z_NULL) return 0UL;
|
if (buf == Z_NULL) return 0UL;
|
||||||
|
|
||||||
#ifdef DYNAMIC_CRC_TABLE
|
|
||||||
if (crc_table_empty)
|
|
||||||
make_crc_table();
|
|
||||||
#endif /* DYNAMIC_CRC_TABLE */
|
|
||||||
|
|
||||||
#ifdef BYFOUR
|
|
||||||
if (sizeof(void *) == sizeof(ptrdiff_t)) {
|
|
||||||
z_crc_t endian;
|
|
||||||
|
|
||||||
endian = 1;
|
|
||||||
if (*((unsigned char *)(&endian)))
|
|
||||||
return crc32_little(crc, buf, len);
|
|
||||||
else
|
|
||||||
return crc32_big(crc, buf, len);
|
|
||||||
}
|
|
||||||
#endif /* BYFOUR */
|
|
||||||
crc = crc ^ 0xffffffffUL;
|
crc = crc ^ 0xffffffffUL;
|
||||||
while (len >= 8) {
|
while (len >= 8) {
|
||||||
DO8;
|
DO8;
|
||||||
@ -234,192 +52,3 @@ unsigned long ZEXPORT crc32(crc, buf, len)
|
|||||||
} while (--len);
|
} while (--len);
|
||||||
return crc ^ 0xffffffffUL;
|
return crc ^ 0xffffffffUL;
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef BYFOUR
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
#define DOLIT4 c ^= *buf4++; \
|
|
||||||
c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
|
|
||||||
crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
|
|
||||||
#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local unsigned long crc32_little(crc, buf, len)
|
|
||||||
unsigned long crc;
|
|
||||||
const unsigned char FAR *buf;
|
|
||||||
unsigned len;
|
|
||||||
{
|
|
||||||
register z_crc_t c;
|
|
||||||
register const z_crc_t FAR *buf4;
|
|
||||||
|
|
||||||
c = (z_crc_t)crc;
|
|
||||||
c = ~c;
|
|
||||||
while (len && ((ptrdiff_t)buf & 3)) {
|
|
||||||
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
|
|
||||||
len--;
|
|
||||||
}
|
|
||||||
|
|
||||||
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
|
|
||||||
while (len >= 32) {
|
|
||||||
DOLIT32;
|
|
||||||
len -= 32;
|
|
||||||
}
|
|
||||||
while (len >= 4) {
|
|
||||||
DOLIT4;
|
|
||||||
len -= 4;
|
|
||||||
}
|
|
||||||
buf = (const unsigned char FAR *)buf4;
|
|
||||||
|
|
||||||
if (len) do {
|
|
||||||
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
|
|
||||||
} while (--len);
|
|
||||||
c = ~c;
|
|
||||||
return (unsigned long)c;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
#define DOBIG4 c ^= *++buf4; \
|
|
||||||
c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
|
|
||||||
crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
|
|
||||||
#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local unsigned long crc32_big(crc, buf, len)
|
|
||||||
unsigned long crc;
|
|
||||||
const unsigned char FAR *buf;
|
|
||||||
unsigned len;
|
|
||||||
{
|
|
||||||
register z_crc_t c;
|
|
||||||
register const z_crc_t FAR *buf4;
|
|
||||||
|
|
||||||
c = ZSWAP32((z_crc_t)crc);
|
|
||||||
c = ~c;
|
|
||||||
while (len && ((ptrdiff_t)buf & 3)) {
|
|
||||||
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
|
|
||||||
len--;
|
|
||||||
}
|
|
||||||
|
|
||||||
buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
|
|
||||||
buf4--;
|
|
||||||
while (len >= 32) {
|
|
||||||
DOBIG32;
|
|
||||||
len -= 32;
|
|
||||||
}
|
|
||||||
while (len >= 4) {
|
|
||||||
DOBIG4;
|
|
||||||
len -= 4;
|
|
||||||
}
|
|
||||||
buf4++;
|
|
||||||
buf = (const unsigned char FAR *)buf4;
|
|
||||||
|
|
||||||
if (len) do {
|
|
||||||
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
|
|
||||||
} while (--len);
|
|
||||||
c = ~c;
|
|
||||||
return (unsigned long)(ZSWAP32(c));
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif /* BYFOUR */
|
|
||||||
|
|
||||||
#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local unsigned long gf2_matrix_times(mat, vec)
|
|
||||||
unsigned long *mat;
|
|
||||||
unsigned long vec;
|
|
||||||
{
|
|
||||||
unsigned long sum;
|
|
||||||
|
|
||||||
sum = 0;
|
|
||||||
while (vec) {
|
|
||||||
if (vec & 1)
|
|
||||||
sum ^= *mat;
|
|
||||||
vec >>= 1;
|
|
||||||
mat++;
|
|
||||||
}
|
|
||||||
return sum;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local void gf2_matrix_square(square, mat)
|
|
||||||
unsigned long *square;
|
|
||||||
unsigned long *mat;
|
|
||||||
{
|
|
||||||
int n;
|
|
||||||
|
|
||||||
for (n = 0; n < GF2_DIM; n++)
|
|
||||||
square[n] = gf2_matrix_times(mat, mat[n]);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
local uLong crc32_combine_(crc1, crc2, len2)
|
|
||||||
uLong crc1;
|
|
||||||
uLong crc2;
|
|
||||||
z_off64_t len2;
|
|
||||||
{
|
|
||||||
int n;
|
|
||||||
unsigned long row;
|
|
||||||
unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
|
|
||||||
unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
|
|
||||||
|
|
||||||
/* degenerate case (also disallow negative lengths) */
|
|
||||||
if (len2 <= 0)
|
|
||||||
return crc1;
|
|
||||||
|
|
||||||
/* put operator for one zero bit in odd */
|
|
||||||
odd[0] = 0xedb88320UL; /* CRC-32 polynomial */
|
|
||||||
row = 1;
|
|
||||||
for (n = 1; n < GF2_DIM; n++) {
|
|
||||||
odd[n] = row;
|
|
||||||
row <<= 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* put operator for two zero bits in even */
|
|
||||||
gf2_matrix_square(even, odd);
|
|
||||||
|
|
||||||
/* put operator for four zero bits in odd */
|
|
||||||
gf2_matrix_square(odd, even);
|
|
||||||
|
|
||||||
/* apply len2 zeros to crc1 (first square will put the operator for one
|
|
||||||
zero byte, eight zero bits, in even) */
|
|
||||||
do {
|
|
||||||
/* apply zeros operator for this bit of len2 */
|
|
||||||
gf2_matrix_square(even, odd);
|
|
||||||
if (len2 & 1)
|
|
||||||
crc1 = gf2_matrix_times(even, crc1);
|
|
||||||
len2 >>= 1;
|
|
||||||
|
|
||||||
/* if no more bits set, then done */
|
|
||||||
if (len2 == 0)
|
|
||||||
break;
|
|
||||||
|
|
||||||
/* another iteration of the loop with odd and even swapped */
|
|
||||||
gf2_matrix_square(odd, even);
|
|
||||||
if (len2 & 1)
|
|
||||||
crc1 = gf2_matrix_times(odd, crc1);
|
|
||||||
len2 >>= 1;
|
|
||||||
|
|
||||||
/* if no more bits set, then done */
|
|
||||||
} while (len2 != 0);
|
|
||||||
|
|
||||||
/* return combined crc */
|
|
||||||
crc1 ^= crc2;
|
|
||||||
return crc1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ========================================================================= */
|
|
||||||
uLong ZEXPORT crc32_combine(crc1, crc2, len2)
|
|
||||||
uLong crc1;
|
|
||||||
uLong crc2;
|
|
||||||
z_off_t len2;
|
|
||||||
{
|
|
||||||
return crc32_combine_(crc1, crc2, len2);
|
|
||||||
}
|
|
||||||
|
|
||||||
uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
|
|
||||||
uLong crc1;
|
|
||||||
uLong crc2;
|
|
||||||
z_off64_t len2;
|
|
||||||
{
|
|
||||||
return crc32_combine_(crc1, crc2, len2);
|
|
||||||
}
|
|
||||||
|
|||||||
640
deps/zlib/infback.c
vendored
640
deps/zlib/infback.c
vendored
@ -1,640 +0,0 @@
|
|||||||
/* infback.c -- inflate using a call-back interface
|
|
||||||
* Copyright (C) 1995-2011 Mark Adler
|
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
This code is largely copied from inflate.c. Normally either infback.o or
|
|
||||||
inflate.o would be linked into an application--not both. The interface
|
|
||||||
with inffast.c is retained so that optimized assembler-coded versions of
|
|
||||||
inflate_fast() can be used with either inflate.c or infback.c.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "zutil.h"
|
|
||||||
#include "inftrees.h"
|
|
||||||
#include "inflate.h"
|
|
||||||
#include "inffast.h"
|
|
||||||
|
|
||||||
/* function prototypes */
|
|
||||||
local void fixedtables OF((struct inflate_state FAR *state));
|
|
||||||
|
|
||||||
/*
|
|
||||||
strm provides memory allocation functions in zalloc and zfree, or
|
|
||||||
Z_NULL to use the library memory allocation functions.
|
|
||||||
|
|
||||||
windowBits is in the range 8..15, and window is a user-supplied
|
|
||||||
window and output buffer that is 2**windowBits bytes.
|
|
||||||
*/
|
|
||||||
int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
|
|
||||||
z_streamp strm;
|
|
||||||
int windowBits;
|
|
||||||
unsigned char FAR *window;
|
|
||||||
const char *version;
|
|
||||||
int stream_size;
|
|
||||||
{
|
|
||||||
struct inflate_state FAR *state;
|
|
||||||
|
|
||||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
|
||||||
stream_size != (int)(sizeof(z_stream)))
|
|
||||||
return Z_VERSION_ERROR;
|
|
||||||
if (strm == Z_NULL || window == Z_NULL ||
|
|
||||||
windowBits < 8 || windowBits > 15)
|
|
||||||
return Z_STREAM_ERROR;
|
|
||||||
strm->msg = Z_NULL; /* in case we return an error */
|
|
||||||
if (strm->zalloc == (alloc_func)0) {
|
|
||||||
#ifdef Z_SOLO
|
|
||||||
return Z_STREAM_ERROR;
|
|
||||||
#else
|
|
||||||
strm->zalloc = zcalloc;
|
|
||||||
strm->opaque = (voidpf)0;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
if (strm->zfree == (free_func)0)
|
|
||||||
#ifdef Z_SOLO
|
|
||||||
return Z_STREAM_ERROR;
|
|
||||||
#else
|
|
||||||
strm->zfree = zcfree;
|
|
||||||
#endif
|
|
||||||
state = (struct inflate_state FAR *)ZALLOC(strm, 1,
|
|
||||||
sizeof(struct inflate_state));
|
|
||||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
|
||||||
Tracev((stderr, "inflate: allocated\n"));
|
|
||||||
strm->state = (struct internal_state FAR *)state;
|
|
||||||
state->dmax = 32768U;
|
|
||||||
state->wbits = windowBits;
|
|
||||||
state->wsize = 1U << windowBits;
|
|
||||||
state->window = window;
|
|
||||||
state->wnext = 0;
|
|
||||||
state->whave = 0;
|
|
||||||
return Z_OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
Return state with length and distance decoding tables and index sizes set to
|
|
||||||
fixed code decoding. Normally this returns fixed tables from inffixed.h.
|
|
||||||
If BUILDFIXED is defined, then instead this routine builds the tables the
|
|
||||||
first time it's called, and returns those tables the first time and
|
|
||||||
thereafter. This reduces the size of the code by about 2K bytes, in
|
|
||||||
exchange for a little execution time. However, BUILDFIXED should not be
|
|
||||||
used for threaded applications, since the rewriting of the tables and virgin
|
|
||||||
may not be thread-safe.
|
|
||||||
*/
|
|
||||||
local void fixedtables(state)
|
|
||||||
struct inflate_state FAR *state;
|
|
||||||
{
|
|
||||||
#ifdef BUILDFIXED
|
|
||||||
static int virgin = 1;
|
|
||||||
static code *lenfix, *distfix;
|
|
||||||
static code fixed[544];
|
|
||||||
|
|
||||||
/* build fixed huffman tables if first call (may not be thread safe) */
|
|
||||||
if (virgin) {
|
|
||||||
unsigned sym, bits;
|
|
||||||
static code *next;
|
|
||||||
|
|
||||||
/* literal/length table */
|
|
||||||
sym = 0;
|
|
||||||
while (sym < 144) state->lens[sym++] = 8;
|
|
||||||
while (sym < 256) state->lens[sym++] = 9;
|
|
||||||
while (sym < 280) state->lens[sym++] = 7;
|
|
||||||
while (sym < 288) state->lens[sym++] = 8;
|
|
||||||
next = fixed;
|
|
||||||
lenfix = next;
|
|
||||||
bits = 9;
|
|
||||||
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
|
|
||||||
|
|
||||||
/* distance table */
|
|
||||||
sym = 0;
|
|
||||||
while (sym < 32) state->lens[sym++] = 5;
|
|
||||||
distfix = next;
|
|
||||||
bits = 5;
|
|
||||||
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
|
||||||
|
|
||||||
/* do this just once */
|
|
||||||
virgin = 0;
|
|
||||||
}
|
|
||||||
#else /* !BUILDFIXED */
|
|
||||||
# include "inffixed.h"
|
|
||||||
#endif /* BUILDFIXED */
|
|
||||||
state->lencode = lenfix;
|
|
||||||
state->lenbits = 9;
|
|
||||||
state->distcode = distfix;
|
|
||||||
state->distbits = 5;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Macros for inflateBack(): */
|
|
||||||
|
|
||||||
/* Load returned state from inflate_fast() */
|
|
||||||
#define LOAD() \
|
|
||||||
do { \
|
|
||||||
put = strm->next_out; \
|
|
||||||
left = strm->avail_out; \
|
|
||||||
next = strm->next_in; \
|
|
||||||
have = strm->avail_in; \
|
|
||||||
hold = state->hold; \
|
|
||||||
bits = state->bits; \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Set state from registers for inflate_fast() */
|
|
||||||
#define RESTORE() \
|
|
||||||
do { \
|
|
||||||
strm->next_out = put; \
|
|
||||||
strm->avail_out = left; \
|
|
||||||
strm->next_in = next; \
|
|
||||||
strm->avail_in = have; \
|
|
||||||
state->hold = hold; \
|
|
||||||
state->bits = bits; \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Clear the input bit accumulator */
|
|
||||||
#define INITBITS() \
|
|
||||||
do { \
|
|
||||||
hold = 0; \
|
|
||||||
bits = 0; \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Assure that some input is available. If input is requested, but denied,
|
|
||||||
then return a Z_BUF_ERROR from inflateBack(). */
|
|
||||||
#define PULL() \
|
|
||||||
do { \
|
|
||||||
if (have == 0) { \
|
|
||||||
have = in(in_desc, &next); \
|
|
||||||
if (have == 0) { \
|
|
||||||
next = Z_NULL; \
|
|
||||||
ret = Z_BUF_ERROR; \
|
|
||||||
goto inf_leave; \
|
|
||||||
} \
|
|
||||||
} \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Get a byte of input into the bit accumulator, or return from inflateBack()
|
|
||||||
with an error if there is no input available. */
|
|
||||||
#define PULLBYTE() \
|
|
||||||
do { \
|
|
||||||
PULL(); \
|
|
||||||
have--; \
|
|
||||||
hold += (unsigned long)(*next++) << bits; \
|
|
||||||
bits += 8; \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Assure that there are at least n bits in the bit accumulator. If there is
|
|
||||||
not enough available input to do that, then return from inflateBack() with
|
|
||||||
an error. */
|
|
||||||
#define NEEDBITS(n) \
|
|
||||||
do { \
|
|
||||||
while (bits < (unsigned)(n)) \
|
|
||||||
PULLBYTE(); \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Return the low n bits of the bit accumulator (n < 16) */
|
|
||||||
#define BITS(n) \
|
|
||||||
((unsigned)hold & ((1U << (n)) - 1))
|
|
||||||
|
|
||||||
/* Remove n bits from the bit accumulator */
|
|
||||||
#define DROPBITS(n) \
|
|
||||||
do { \
|
|
||||||
hold >>= (n); \
|
|
||||||
bits -= (unsigned)(n); \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Remove zero to seven bits as needed to go to a byte boundary */
|
|
||||||
#define BYTEBITS() \
|
|
||||||
do { \
|
|
||||||
hold >>= bits & 7; \
|
|
||||||
bits -= bits & 7; \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/* Assure that some output space is available, by writing out the window
|
|
||||||
if it's full. If the write fails, return from inflateBack() with a
|
|
||||||
Z_BUF_ERROR. */
|
|
||||||
#define ROOM() \
|
|
||||||
do { \
|
|
||||||
if (left == 0) { \
|
|
||||||
put = state->window; \
|
|
||||||
left = state->wsize; \
|
|
||||||
state->whave = left; \
|
|
||||||
if (out(out_desc, put, left)) { \
|
|
||||||
ret = Z_BUF_ERROR; \
|
|
||||||
goto inf_leave; \
|
|
||||||
} \
|
|
||||||
} \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
/*
|
|
||||||
strm provides the memory allocation functions and window buffer on input,
|
|
||||||
and provides information on the unused input on return. For Z_DATA_ERROR
|
|
||||||
returns, strm will also provide an error message.
|
|
||||||
|
|
||||||
in() and out() are the call-back input and output functions. When
|
|
||||||
inflateBack() needs more input, it calls in(). When inflateBack() has
|
|
||||||
filled the window with output, or when it completes with data in the
|
|
||||||
window, it calls out() to write out the data. The application must not
|
|
||||||
change the provided input until in() is called again or inflateBack()
|
|
||||||
returns. The application must not change the window/output buffer until
|
|
||||||
inflateBack() returns.
|
|
||||||
|
|
||||||
in() and out() are called with a descriptor parameter provided in the
|
|
||||||
inflateBack() call. This parameter can be a structure that provides the
|
|
||||||
information required to do the read or write, as well as accumulated
|
|
||||||
information on the input and output such as totals and check values.
|
|
||||||
|
|
||||||
in() should return zero on failure. out() should return non-zero on
|
|
||||||
failure. If either in() or out() fails, than inflateBack() returns a
|
|
||||||
Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
|
|
||||||
was in() or out() that caused in the error. Otherwise, inflateBack()
|
|
||||||
returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
|
|
||||||
error, or Z_MEM_ERROR if it could not allocate memory for the state.
|
|
||||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
|
||||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
|
||||||
*/
|
|
||||||
int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
|
|
||||||
z_streamp strm;
|
|
||||||
in_func in;
|
|
||||||
void FAR *in_desc;
|
|
||||||
out_func out;
|
|
||||||
void FAR *out_desc;
|
|
||||||
{
|
|
||||||
struct inflate_state FAR *state;
|
|
||||||
unsigned char FAR *next; /* next input */
|
|
||||||
unsigned char FAR *put; /* next output */
|
|
||||||
unsigned have, left; /* available input and output */
|
|
||||||
unsigned long hold; /* bit buffer */
|
|
||||||
unsigned bits; /* bits in bit buffer */
|
|
||||||
unsigned copy; /* number of stored or match bytes to copy */
|
|
||||||
unsigned char FAR *from; /* where to copy match bytes from */
|
|
||||||
code here; /* current decoding table entry */
|
|
||||||
code last; /* parent table entry */
|
|
||||||
unsigned len; /* length to copy for repeats, bits to drop */
|
|
||||||
int ret; /* return code */
|
|
||||||
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};
|
|
||||||
|
|
||||||
/* Check that the strm exists and that the state was initialized */
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL)
|
|
||||||
return Z_STREAM_ERROR;
|
|
||||||
state = (struct inflate_state FAR *)strm->state;
|
|
||||||
|
|
||||||
/* Reset the state */
|
|
||||||
strm->msg = Z_NULL;
|
|
||||||
state->mode = TYPE;
|
|
||||||
state->last = 0;
|
|
||||||
state->whave = 0;
|
|
||||||
next = strm->next_in;
|
|
||||||
have = next != Z_NULL ? strm->avail_in : 0;
|
|
||||||
hold = 0;
|
|
||||||
bits = 0;
|
|
||||||
put = state->window;
|
|
||||||
left = state->wsize;
|
|
||||||
|
|
||||||
/* Inflate until end of block marked as last */
|
|
||||||
for (;;)
|
|
||||||
switch (state->mode) {
|
|
||||||
case TYPE:
|
|
||||||
/* determine and dispatch block type */
|
|
||||||
if (state->last) {
|
|
||||||
BYTEBITS();
|
|
||||||
state->mode = DONE;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
NEEDBITS(3);
|
|
||||||
state->last = BITS(1);
|
|
||||||
DROPBITS(1);
|
|
||||||
switch (BITS(2)) {
|
|
||||||
case 0: /* stored block */
|
|
||||||
Tracev((stderr, "inflate: stored block%s\n",
|
|
||||||
state->last ? " (last)" : ""));
|
|
||||||
state->mode = STORED;
|
|
||||||
break;
|
|
||||||
case 1: /* fixed block */
|
|
||||||
fixedtables(state);
|
|
||||||
Tracev((stderr, "inflate: fixed codes block%s\n",
|
|
||||||
state->last ? " (last)" : ""));
|
|
||||||
state->mode = LEN; /* decode codes */
|
|
||||||
break;
|
|
||||||
case 2: /* dynamic block */
|
|
||||||
Tracev((stderr, "inflate: dynamic codes block%s\n",
|
|
||||||
state->last ? " (last)" : ""));
|
|
||||||
state->mode = TABLE;
|
|
||||||
break;
|
|
||||||
case 3:
|
|
||||||
strm->msg = (char *)"invalid block type";
|
|
||||||
state->mode = BAD;
|
|
||||||
}
|
|
||||||
DROPBITS(2);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case STORED:
|
|
||||||
/* get and verify stored block length */
|
|
||||||
BYTEBITS(); /* go to byte boundary */
|
|
||||||
NEEDBITS(32);
|
|
||||||
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
|
|
||||||
strm->msg = (char *)"invalid stored block lengths";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
state->length = (unsigned)hold & 0xffff;
|
|
||||||
Tracev((stderr, "inflate: stored length %u\n",
|
|
||||||
state->length));
|
|
||||||
INITBITS();
|
|
||||||
|
|
||||||
/* copy stored block from input to output */
|
|
||||||
while (state->length != 0) {
|
|
||||||
copy = state->length;
|
|
||||||
PULL();
|
|
||||||
ROOM();
|
|
||||||
if (copy > have) copy = have;
|
|
||||||
if (copy > left) copy = left;
|
|
||||||
zmemcpy(put, next, copy);
|
|
||||||
have -= copy;
|
|
||||||
next += copy;
|
|
||||||
left -= copy;
|
|
||||||
put += copy;
|
|
||||||
state->length -= copy;
|
|
||||||
}
|
|
||||||
Tracev((stderr, "inflate: stored end\n"));
|
|
||||||
state->mode = TYPE;
|
|
||||||
break;
|
|
||||||
|
|
||||||
case TABLE:
|
|
||||||
/* get dynamic table entries descriptor */
|
|
||||||
NEEDBITS(14);
|
|
||||||
state->nlen = BITS(5) + 257;
|
|
||||||
DROPBITS(5);
|
|
||||||
state->ndist = BITS(5) + 1;
|
|
||||||
DROPBITS(5);
|
|
||||||
state->ncode = BITS(4) + 4;
|
|
||||||
DROPBITS(4);
|
|
||||||
#ifndef PKZIP_BUG_WORKAROUND
|
|
||||||
if (state->nlen > 286 || state->ndist > 30) {
|
|
||||||
strm->msg = (char *)"too many length or distance symbols";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
|
||||||
|
|
||||||
/* get code length code lengths (not a typo) */
|
|
||||||
state->have = 0;
|
|
||||||
while (state->have < state->ncode) {
|
|
||||||
NEEDBITS(3);
|
|
||||||
state->lens[order[state->have++]] = (unsigned short)BITS(3);
|
|
||||||
DROPBITS(3);
|
|
||||||
}
|
|
||||||
while (state->have < 19)
|
|
||||||
state->lens[order[state->have++]] = 0;
|
|
||||||
state->next = state->codes;
|
|
||||||
state->lencode = (code const FAR *)(state->next);
|
|
||||||
state->lenbits = 7;
|
|
||||||
ret = inflate_table(CODES, state->lens, 19, &(state->next),
|
|
||||||
&(state->lenbits), state->work);
|
|
||||||
if (ret) {
|
|
||||||
strm->msg = (char *)"invalid code lengths set";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
Tracev((stderr, "inflate: code lengths ok\n"));
|
|
||||||
|
|
||||||
/* get length and distance code code lengths */
|
|
||||||
state->have = 0;
|
|
||||||
while (state->have < state->nlen + state->ndist) {
|
|
||||||
for (;;) {
|
|
||||||
here = state->lencode[BITS(state->lenbits)];
|
|
||||||
if ((unsigned)(here.bits) <= bits) break;
|
|
||||||
PULLBYTE();
|
|
||||||
}
|
|
||||||
if (here.val < 16) {
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
state->lens[state->have++] = here.val;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (here.val == 16) {
|
|
||||||
NEEDBITS(here.bits + 2);
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
if (state->have == 0) {
|
|
||||||
strm->msg = (char *)"invalid bit length repeat";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
len = (unsigned)(state->lens[state->have - 1]);
|
|
||||||
copy = 3 + BITS(2);
|
|
||||||
DROPBITS(2);
|
|
||||||
}
|
|
||||||
else if (here.val == 17) {
|
|
||||||
NEEDBITS(here.bits + 3);
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
len = 0;
|
|
||||||
copy = 3 + BITS(3);
|
|
||||||
DROPBITS(3);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
NEEDBITS(here.bits + 7);
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
len = 0;
|
|
||||||
copy = 11 + BITS(7);
|
|
||||||
DROPBITS(7);
|
|
||||||
}
|
|
||||||
if (state->have + copy > state->nlen + state->ndist) {
|
|
||||||
strm->msg = (char *)"invalid bit length repeat";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
while (copy--)
|
|
||||||
state->lens[state->have++] = (unsigned short)len;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* handle error breaks in while */
|
|
||||||
if (state->mode == BAD) break;
|
|
||||||
|
|
||||||
/* check for end-of-block code (better have one) */
|
|
||||||
if (state->lens[256] == 0) {
|
|
||||||
strm->msg = (char *)"invalid code -- missing end-of-block";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* build code tables -- note: do not change the lenbits or distbits
|
|
||||||
values here (9 and 6) without reading the comments in inftrees.h
|
|
||||||
concerning the ENOUGH constants, which depend on those values */
|
|
||||||
state->next = state->codes;
|
|
||||||
state->lencode = (code const FAR *)(state->next);
|
|
||||||
state->lenbits = 9;
|
|
||||||
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
|
|
||||||
&(state->lenbits), state->work);
|
|
||||||
if (ret) {
|
|
||||||
strm->msg = (char *)"invalid literal/lengths set";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
state->distcode = (code const FAR *)(state->next);
|
|
||||||
state->distbits = 6;
|
|
||||||
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
|
|
||||||
&(state->next), &(state->distbits), state->work);
|
|
||||||
if (ret) {
|
|
||||||
strm->msg = (char *)"invalid distances set";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
Tracev((stderr, "inflate: codes ok\n"));
|
|
||||||
state->mode = LEN;
|
|
||||||
|
|
||||||
case LEN:
|
|
||||||
/* use inflate_fast() if we have enough input and output */
|
|
||||||
if (have >= 6 && left >= 258) {
|
|
||||||
RESTORE();
|
|
||||||
if (state->whave < state->wsize)
|
|
||||||
state->whave = state->wsize - left;
|
|
||||||
inflate_fast(strm, state->wsize);
|
|
||||||
LOAD();
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* get a literal, length, or end-of-block code */
|
|
||||||
for (;;) {
|
|
||||||
here = state->lencode[BITS(state->lenbits)];
|
|
||||||
if ((unsigned)(here.bits) <= bits) break;
|
|
||||||
PULLBYTE();
|
|
||||||
}
|
|
||||||
if (here.op && (here.op & 0xf0) == 0) {
|
|
||||||
last = here;
|
|
||||||
for (;;) {
|
|
||||||
here = state->lencode[last.val +
|
|
||||||
(BITS(last.bits + last.op) >> last.bits)];
|
|
||||||
if ((unsigned)(last.bits + here.bits) <= bits) break;
|
|
||||||
PULLBYTE();
|
|
||||||
}
|
|
||||||
DROPBITS(last.bits);
|
|
||||||
}
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
state->length = (unsigned)here.val;
|
|
||||||
|
|
||||||
/* process literal */
|
|
||||||
if (here.op == 0) {
|
|
||||||
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
|
||||||
"inflate: literal '%c'\n" :
|
|
||||||
"inflate: literal 0x%02x\n", here.val));
|
|
||||||
ROOM();
|
|
||||||
*put++ = (unsigned char)(state->length);
|
|
||||||
left--;
|
|
||||||
state->mode = LEN;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* process end of block */
|
|
||||||
if (here.op & 32) {
|
|
||||||
Tracevv((stderr, "inflate: end of block\n"));
|
|
||||||
state->mode = TYPE;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* invalid code */
|
|
||||||
if (here.op & 64) {
|
|
||||||
strm->msg = (char *)"invalid literal/length code";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* length code -- get extra bits, if any */
|
|
||||||
state->extra = (unsigned)(here.op) & 15;
|
|
||||||
if (state->extra != 0) {
|
|
||||||
NEEDBITS(state->extra);
|
|
||||||
state->length += BITS(state->extra);
|
|
||||||
DROPBITS(state->extra);
|
|
||||||
}
|
|
||||||
Tracevv((stderr, "inflate: length %u\n", state->length));
|
|
||||||
|
|
||||||
/* get distance code */
|
|
||||||
for (;;) {
|
|
||||||
here = state->distcode[BITS(state->distbits)];
|
|
||||||
if ((unsigned)(here.bits) <= bits) break;
|
|
||||||
PULLBYTE();
|
|
||||||
}
|
|
||||||
if ((here.op & 0xf0) == 0) {
|
|
||||||
last = here;
|
|
||||||
for (;;) {
|
|
||||||
here = state->distcode[last.val +
|
|
||||||
(BITS(last.bits + last.op) >> last.bits)];
|
|
||||||
if ((unsigned)(last.bits + here.bits) <= bits) break;
|
|
||||||
PULLBYTE();
|
|
||||||
}
|
|
||||||
DROPBITS(last.bits);
|
|
||||||
}
|
|
||||||
DROPBITS(here.bits);
|
|
||||||
if (here.op & 64) {
|
|
||||||
strm->msg = (char *)"invalid distance code";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
state->offset = (unsigned)here.val;
|
|
||||||
|
|
||||||
/* get distance extra bits, if any */
|
|
||||||
state->extra = (unsigned)(here.op) & 15;
|
|
||||||
if (state->extra != 0) {
|
|
||||||
NEEDBITS(state->extra);
|
|
||||||
state->offset += BITS(state->extra);
|
|
||||||
DROPBITS(state->extra);
|
|
||||||
}
|
|
||||||
if (state->offset > state->wsize - (state->whave < state->wsize ?
|
|
||||||
left : 0)) {
|
|
||||||
strm->msg = (char *)"invalid distance too far back";
|
|
||||||
state->mode = BAD;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
Tracevv((stderr, "inflate: distance %u\n", state->offset));
|
|
||||||
|
|
||||||
/* copy match from window to output */
|
|
||||||
do {
|
|
||||||
ROOM();
|
|
||||||
copy = state->wsize - state->offset;
|
|
||||||
if (copy < left) {
|
|
||||||
from = put + copy;
|
|
||||||
copy = left - copy;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
from = put - state->offset;
|
|
||||||
copy = left;
|
|
||||||
}
|
|
||||||
if (copy > state->length) copy = state->length;
|
|
||||||
state->length -= copy;
|
|
||||||
left -= copy;
|
|
||||||
do {
|
|
||||||
*put++ = *from++;
|
|
||||||
} while (--copy);
|
|
||||||
} while (state->length != 0);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case DONE:
|
|
||||||
/* inflate stream terminated properly -- write leftover output */
|
|
||||||
ret = Z_STREAM_END;
|
|
||||||
if (left < state->wsize) {
|
|
||||||
if (out(out_desc, state->window, state->wsize - left))
|
|
||||||
ret = Z_BUF_ERROR;
|
|
||||||
}
|
|
||||||
goto inf_leave;
|
|
||||||
|
|
||||||
case BAD:
|
|
||||||
ret = Z_DATA_ERROR;
|
|
||||||
goto inf_leave;
|
|
||||||
|
|
||||||
default: /* can't happen, but makes compilers happy */
|
|
||||||
ret = Z_STREAM_ERROR;
|
|
||||||
goto inf_leave;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Return unused input */
|
|
||||||
inf_leave:
|
|
||||||
strm->next_in = next;
|
|
||||||
strm->avail_in = have;
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
int ZEXPORT inflateBackEnd(strm)
|
|
||||||
z_streamp strm;
|
|
||||||
{
|
|
||||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
|
||||||
return Z_STREAM_ERROR;
|
|
||||||
ZFREE(strm, strm->state);
|
|
||||||
strm->state = Z_NULL;
|
|
||||||
Tracev((stderr, "inflate: end\n"));
|
|
||||||
return Z_OK;
|
|
||||||
}
|
|
||||||
192
deps/zlib/trees.c
vendored
192
deps/zlib/trees.c
vendored
@ -32,8 +32,6 @@
|
|||||||
|
|
||||||
/* @(#) $Id$ */
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
/* #define GEN_TREES_H */
|
|
||||||
|
|
||||||
#include "deflate.h"
|
#include "deflate.h"
|
||||||
|
|
||||||
#ifdef DEBUG
|
#ifdef DEBUG
|
||||||
@ -80,39 +78,7 @@ local const uch bl_order[BL_CODES]
|
|||||||
|
|
||||||
#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
|
#define DIST_CODE_LEN 512 /* see definition of array dist_code below */
|
||||||
|
|
||||||
#if defined(GEN_TREES_H) || !defined(STDC)
|
#include "trees.h"
|
||||||
/* non ANSI compilers may not accept trees.h */
|
|
||||||
|
|
||||||
local ct_data static_ltree[L_CODES+2];
|
|
||||||
/* The static literal tree. Since the bit lengths are imposed, there is no
|
|
||||||
* need for the L_CODES extra codes used during heap construction. However
|
|
||||||
* The codes 286 and 287 are needed to build a canonical tree (see _tr_init
|
|
||||||
* below).
|
|
||||||
*/
|
|
||||||
|
|
||||||
local ct_data static_dtree[D_CODES];
|
|
||||||
/* The static distance tree. (Actually a trivial tree since all codes use
|
|
||||||
* 5 bits.)
|
|
||||||
*/
|
|
||||||
|
|
||||||
uch _dist_code[DIST_CODE_LEN];
|
|
||||||
/* Distance codes. The first 256 values correspond to the distances
|
|
||||||
* 3 .. 258, the last 256 values correspond to the top 8 bits of
|
|
||||||
* the 15 bit distances.
|
|
||||||
*/
|
|
||||||
|
|
||||||
uch _length_code[MAX_MATCH-MIN_MATCH+1];
|
|
||||||
/* length code for each normalized match length (0 == MIN_MATCH) */
|
|
||||||
|
|
||||||
local int base_length[LENGTH_CODES];
|
|
||||||
/* First normalized length for each code (0 = MIN_MATCH) */
|
|
||||||
|
|
||||||
local int base_dist[D_CODES];
|
|
||||||
/* First normalized distance for each code (0 = distance of 1) */
|
|
||||||
|
|
||||||
#else
|
|
||||||
# include "trees.h"
|
|
||||||
#endif /* GEN_TREES_H */
|
|
||||||
|
|
||||||
struct static_tree_desc_s {
|
struct static_tree_desc_s {
|
||||||
const ct_data *static_tree; /* static tree or NULL */
|
const ct_data *static_tree; /* static tree or NULL */
|
||||||
@ -135,7 +101,6 @@ local static_tree_desc static_bl_desc =
|
|||||||
* Local (static) routines in this file.
|
* Local (static) routines in this file.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
local void tr_static_init OF((void));
|
|
||||||
local void init_block OF((deflate_state *s));
|
local void init_block OF((deflate_state *s));
|
||||||
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
|
local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
|
||||||
local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
|
local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
|
||||||
@ -155,10 +120,6 @@ local void bi_flush OF((deflate_state *s));
|
|||||||
local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
|
local void copy_block OF((deflate_state *s, charf *buf, unsigned len,
|
||||||
int header));
|
int header));
|
||||||
|
|
||||||
#ifdef GEN_TREES_H
|
|
||||||
local void gen_trees_header OF((void));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef DEBUG
|
#ifndef 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 */
|
||||||
@ -226,163 +187,12 @@ local void send_bits(s, value, length)
|
|||||||
#endif /* DEBUG */
|
#endif /* DEBUG */
|
||||||
|
|
||||||
|
|
||||||
/* the arguments must not have side effects */
|
|
||||||
|
|
||||||
/* ===========================================================================
|
|
||||||
* Initialize the various 'constant' tables.
|
|
||||||
*/
|
|
||||||
local void tr_static_init()
|
|
||||||
{
|
|
||||||
#if defined(GEN_TREES_H) || !defined(STDC)
|
|
||||||
static int static_init_done = 0;
|
|
||||||
int n; /* iterates over tree elements */
|
|
||||||
int bits; /* bit counter */
|
|
||||||
int length; /* length value */
|
|
||||||
int code; /* code value */
|
|
||||||
int dist; /* distance index */
|
|
||||||
ush bl_count[MAX_BITS+1];
|
|
||||||
/* number of codes at each bit length for an optimal tree */
|
|
||||||
|
|
||||||
if (static_init_done) return;
|
|
||||||
|
|
||||||
/* For some embedded targets, global variables are not initialized: */
|
|
||||||
#ifdef NO_INIT_GLOBAL_POINTERS
|
|
||||||
static_l_desc.static_tree = static_ltree;
|
|
||||||
static_l_desc.extra_bits = extra_lbits;
|
|
||||||
static_d_desc.static_tree = static_dtree;
|
|
||||||
static_d_desc.extra_bits = extra_dbits;
|
|
||||||
static_bl_desc.extra_bits = extra_blbits;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Initialize the mapping length (0..255) -> length code (0..28) */
|
|
||||||
length = 0;
|
|
||||||
for (code = 0; code < LENGTH_CODES-1; code++) {
|
|
||||||
base_length[code] = length;
|
|
||||||
for (n = 0; n < (1<<extra_lbits[code]); n++) {
|
|
||||||
_length_code[length++] = (uch)code;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Assert (length == 256, "tr_static_init: length != 256");
|
|
||||||
/* Note that the length 255 (match length 258) can be represented
|
|
||||||
* in two different ways: code 284 + 5 bits or code 285, so we
|
|
||||||
* overwrite length_code[255] to use the best encoding:
|
|
||||||
*/
|
|
||||||
_length_code[length-1] = (uch)code;
|
|
||||||
|
|
||||||
/* Initialize the mapping dist (0..32K) -> dist code (0..29) */
|
|
||||||
dist = 0;
|
|
||||||
for (code = 0 ; code < 16; code++) {
|
|
||||||
base_dist[code] = dist;
|
|
||||||
for (n = 0; n < (1<<extra_dbits[code]); n++) {
|
|
||||||
_dist_code[dist++] = (uch)code;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Assert (dist == 256, "tr_static_init: dist != 256");
|
|
||||||
dist >>= 7; /* from now on, all distances are divided by 128 */
|
|
||||||
for ( ; code < D_CODES; code++) {
|
|
||||||
base_dist[code] = dist << 7;
|
|
||||||
for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
|
|
||||||
_dist_code[256 + dist++] = (uch)code;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Assert (dist == 256, "tr_static_init: 256+dist != 512");
|
|
||||||
|
|
||||||
/* Construct the codes of the static literal tree */
|
|
||||||
for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
|
|
||||||
n = 0;
|
|
||||||
while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
|
|
||||||
while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
|
|
||||||
while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
|
|
||||||
while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
|
|
||||||
/* Codes 286 and 287 do not exist, but we must include them in the
|
|
||||||
* tree construction to get a canonical Huffman tree (longest code
|
|
||||||
* all ones)
|
|
||||||
*/
|
|
||||||
gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
|
|
||||||
|
|
||||||
/* The static distance tree is trivial: */
|
|
||||||
for (n = 0; n < D_CODES; n++) {
|
|
||||||
static_dtree[n].Len = 5;
|
|
||||||
static_dtree[n].Code = bi_reverse((unsigned)n, 5);
|
|
||||||
}
|
|
||||||
static_init_done = 1;
|
|
||||||
|
|
||||||
# ifdef GEN_TREES_H
|
|
||||||
gen_trees_header();
|
|
||||||
# endif
|
|
||||||
#endif /* defined(GEN_TREES_H) || !defined(STDC) */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ===========================================================================
|
|
||||||
* Genererate the file trees.h describing the static trees.
|
|
||||||
*/
|
|
||||||
#ifdef GEN_TREES_H
|
|
||||||
# ifndef DEBUG
|
|
||||||
# include <stdio.h>
|
|
||||||
# endif
|
|
||||||
|
|
||||||
# define SEPARATOR(i, last, width) \
|
|
||||||
((i) == (last)? "\n};\n\n" : \
|
|
||||||
((i) % (width) == (width)-1 ? ",\n" : ", "))
|
|
||||||
|
|
||||||
void gen_trees_header()
|
|
||||||
{
|
|
||||||
FILE *header = fopen("trees.h", "w");
|
|
||||||
int i;
|
|
||||||
|
|
||||||
Assert (header != NULL, "Can't open trees.h");
|
|
||||||
fprintf(header,
|
|
||||||
"/* header created automatically with -DGEN_TREES_H */\n\n");
|
|
||||||
|
|
||||||
fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
|
|
||||||
for (i = 0; i < L_CODES+2; i++) {
|
|
||||||
fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
|
|
||||||
static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
|
|
||||||
for (i = 0; i < D_CODES; i++) {
|
|
||||||
fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
|
|
||||||
static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
|
|
||||||
for (i = 0; i < DIST_CODE_LEN; i++) {
|
|
||||||
fprintf(header, "%2u%s", _dist_code[i],
|
|
||||||
SEPARATOR(i, DIST_CODE_LEN-1, 20));
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(header,
|
|
||||||
"const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
|
|
||||||
for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
|
|
||||||
fprintf(header, "%2u%s", _length_code[i],
|
|
||||||
SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
|
|
||||||
for (i = 0; i < LENGTH_CODES; i++) {
|
|
||||||
fprintf(header, "%1u%s", base_length[i],
|
|
||||||
SEPARATOR(i, LENGTH_CODES-1, 20));
|
|
||||||
}
|
|
||||||
|
|
||||||
fprintf(header, "local const int base_dist[D_CODES] = {\n");
|
|
||||||
for (i = 0; i < D_CODES; i++) {
|
|
||||||
fprintf(header, "%5u%s", base_dist[i],
|
|
||||||
SEPARATOR(i, D_CODES-1, 10));
|
|
||||||
}
|
|
||||||
|
|
||||||
fclose(header);
|
|
||||||
}
|
|
||||||
#endif /* GEN_TREES_H */
|
|
||||||
|
|
||||||
/* ===========================================================================
|
/* ===========================================================================
|
||||||
* Initialize the tree data structures for a new zlib stream.
|
* Initialize the tree data structures for a new zlib stream.
|
||||||
*/
|
*/
|
||||||
void ZLIB_INTERNAL _tr_init(s)
|
void ZLIB_INTERNAL _tr_init(s)
|
||||||
deflate_state *s;
|
deflate_state *s;
|
||||||
{
|
{
|
||||||
tr_static_init();
|
|
||||||
|
|
||||||
s->l_desc.dyn_tree = s->dyn_ltree;
|
s->l_desc.dyn_tree = s->dyn_ltree;
|
||||||
s->l_desc.stat_desc = &static_l_desc;
|
s->l_desc.stat_desc = &static_l_desc;
|
||||||
|
|
||||||
|
|||||||
506
deps/zlib/zconf.h.in
vendored
506
deps/zlib/zconf.h.in
vendored
@ -1,506 +0,0 @@
|
|||||||
/* zconf.h -- configuration of the zlib compression library
|
|
||||||
* Copyright (C) 1995-2012 Jean-loup Gailly.
|
|
||||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* @(#) $Id$ */
|
|
||||||
|
|
||||||
#ifndef ZCONF_H
|
|
||||||
#define ZCONF_H
|
|
||||||
|
|
||||||
/*
|
|
||||||
* If you *really* need a unique prefix for all types and library functions,
|
|
||||||
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
|
|
||||||
* Even better than compiling with -DZ_PREFIX would be to use configure to set
|
|
||||||
* this permanently in zconf.h using "./configure --zprefix".
|
|
||||||
*/
|
|
||||||
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
|
|
||||||
# define Z_PREFIX_SET
|
|
||||||
|
|
||||||
/* all linked symbols */
|
|
||||||
# define _dist_code z__dist_code
|
|
||||||
# define _length_code z__length_code
|
|
||||||
# define _tr_align z__tr_align
|
|
||||||
# define _tr_flush_block z__tr_flush_block
|
|
||||||
# define _tr_init z__tr_init
|
|
||||||
# define _tr_stored_block z__tr_stored_block
|
|
||||||
# define _tr_tally z__tr_tally
|
|
||||||
# define adler32 z_adler32
|
|
||||||
# define adler32_combine z_adler32_combine
|
|
||||||
# define adler32_combine64 z_adler32_combine64
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# define compress z_compress
|
|
||||||
# define compress2 z_compress2
|
|
||||||
# define compressBound z_compressBound
|
|
||||||
# endif
|
|
||||||
# define crc32 z_crc32
|
|
||||||
# define crc32_combine z_crc32_combine
|
|
||||||
# define crc32_combine64 z_crc32_combine64
|
|
||||||
# define deflate z_deflate
|
|
||||||
# define deflateBound z_deflateBound
|
|
||||||
# define deflateCopy z_deflateCopy
|
|
||||||
# define deflateEnd z_deflateEnd
|
|
||||||
# define deflateInit2_ z_deflateInit2_
|
|
||||||
# define deflateInit_ z_deflateInit_
|
|
||||||
# define deflateParams z_deflateParams
|
|
||||||
# define deflatePending z_deflatePending
|
|
||||||
# define deflatePrime z_deflatePrime
|
|
||||||
# define deflateReset z_deflateReset
|
|
||||||
# define deflateResetKeep z_deflateResetKeep
|
|
||||||
# define deflateSetDictionary z_deflateSetDictionary
|
|
||||||
# define deflateSetHeader z_deflateSetHeader
|
|
||||||
# define deflateTune z_deflateTune
|
|
||||||
# define deflate_copyright z_deflate_copyright
|
|
||||||
# define get_crc_table z_get_crc_table
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# define gz_error z_gz_error
|
|
||||||
# define gz_intmax z_gz_intmax
|
|
||||||
# define gz_strwinerror z_gz_strwinerror
|
|
||||||
# define gzbuffer z_gzbuffer
|
|
||||||
# define gzclearerr z_gzclearerr
|
|
||||||
# define gzclose z_gzclose
|
|
||||||
# define gzclose_r z_gzclose_r
|
|
||||||
# define gzclose_w z_gzclose_w
|
|
||||||
# define gzdirect z_gzdirect
|
|
||||||
# define gzdopen z_gzdopen
|
|
||||||
# define gzeof z_gzeof
|
|
||||||
# define gzerror z_gzerror
|
|
||||||
# define gzflush z_gzflush
|
|
||||||
# define gzgetc z_gzgetc
|
|
||||||
# define gzgetc_ z_gzgetc_
|
|
||||||
# define gzgets z_gzgets
|
|
||||||
# define gzoffset z_gzoffset
|
|
||||||
# define gzoffset64 z_gzoffset64
|
|
||||||
# define gzopen z_gzopen
|
|
||||||
# define gzopen64 z_gzopen64
|
|
||||||
# ifdef _WIN32
|
|
||||||
# define gzopen_w z_gzopen_w
|
|
||||||
# endif
|
|
||||||
# define gzprintf z_gzprintf
|
|
||||||
# define gzputc z_gzputc
|
|
||||||
# define gzputs z_gzputs
|
|
||||||
# define gzread z_gzread
|
|
||||||
# define gzrewind z_gzrewind
|
|
||||||
# define gzseek z_gzseek
|
|
||||||
# define gzseek64 z_gzseek64
|
|
||||||
# define gzsetparams z_gzsetparams
|
|
||||||
# define gztell z_gztell
|
|
||||||
# define gztell64 z_gztell64
|
|
||||||
# define gzungetc z_gzungetc
|
|
||||||
# define gzwrite z_gzwrite
|
|
||||||
# endif
|
|
||||||
# define inflate z_inflate
|
|
||||||
# define inflateBack z_inflateBack
|
|
||||||
# define inflateBackEnd z_inflateBackEnd
|
|
||||||
# define inflateBackInit_ z_inflateBackInit_
|
|
||||||
# define inflateCopy z_inflateCopy
|
|
||||||
# define inflateEnd z_inflateEnd
|
|
||||||
# define inflateGetHeader z_inflateGetHeader
|
|
||||||
# define inflateInit2_ z_inflateInit2_
|
|
||||||
# define inflateInit_ z_inflateInit_
|
|
||||||
# define inflateMark z_inflateMark
|
|
||||||
# define inflatePrime z_inflatePrime
|
|
||||||
# define inflateReset z_inflateReset
|
|
||||||
# define inflateReset2 z_inflateReset2
|
|
||||||
# define inflateSetDictionary z_inflateSetDictionary
|
|
||||||
# define inflateSync z_inflateSync
|
|
||||||
# define inflateSyncPoint z_inflateSyncPoint
|
|
||||||
# define inflateUndermine z_inflateUndermine
|
|
||||||
# define inflateResetKeep z_inflateResetKeep
|
|
||||||
# define inflate_copyright z_inflate_copyright
|
|
||||||
# define inflate_fast z_inflate_fast
|
|
||||||
# define inflate_table z_inflate_table
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# define uncompress z_uncompress
|
|
||||||
# endif
|
|
||||||
# define zError z_zError
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# define zcalloc z_zcalloc
|
|
||||||
# define zcfree z_zcfree
|
|
||||||
# endif
|
|
||||||
# define zlibCompileFlags z_zlibCompileFlags
|
|
||||||
# define zlibVersion z_zlibVersion
|
|
||||||
|
|
||||||
/* all zlib typedefs in zlib.h and zconf.h */
|
|
||||||
# define Byte z_Byte
|
|
||||||
# define Bytef z_Bytef
|
|
||||||
# define alloc_func z_alloc_func
|
|
||||||
# define charf z_charf
|
|
||||||
# define free_func z_free_func
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# define gzFile z_gzFile
|
|
||||||
# endif
|
|
||||||
# define gz_header z_gz_header
|
|
||||||
# define gz_headerp z_gz_headerp
|
|
||||||
# define in_func z_in_func
|
|
||||||
# define intf z_intf
|
|
||||||
# define out_func z_out_func
|
|
||||||
# define uInt z_uInt
|
|
||||||
# define uIntf z_uIntf
|
|
||||||
# define uLong z_uLong
|
|
||||||
# define uLongf z_uLongf
|
|
||||||
# define voidp z_voidp
|
|
||||||
# define voidpc z_voidpc
|
|
||||||
# define voidpf z_voidpf
|
|
||||||
|
|
||||||
/* all zlib structs in zlib.h and zconf.h */
|
|
||||||
# define gz_header_s z_gz_header_s
|
|
||||||
# define internal_state z_internal_state
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__MSDOS__) && !defined(MSDOS)
|
|
||||||
# define MSDOS
|
|
||||||
#endif
|
|
||||||
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
|
|
||||||
# define OS2
|
|
||||||
#endif
|
|
||||||
#if defined(_WINDOWS) && !defined(WINDOWS)
|
|
||||||
# define WINDOWS
|
|
||||||
#endif
|
|
||||||
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
|
|
||||||
# ifndef WIN32
|
|
||||||
# define WIN32
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
|
|
||||||
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
|
|
||||||
# ifndef SYS16BIT
|
|
||||||
# define SYS16BIT
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more
|
|
||||||
* than 64k bytes at a time (needed on systems with 16-bit int).
|
|
||||||
*/
|
|
||||||
#ifdef SYS16BIT
|
|
||||||
# define MAXSEG_64K
|
|
||||||
#endif
|
|
||||||
#ifdef MSDOS
|
|
||||||
# define UNALIGNED_OK
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef __STDC_VERSION__
|
|
||||||
# ifndef STDC
|
|
||||||
# define STDC
|
|
||||||
# endif
|
|
||||||
# if __STDC_VERSION__ >= 199901L
|
|
||||||
# ifndef STDC99
|
|
||||||
# define STDC99
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
|
|
||||||
# define STDC
|
|
||||||
#endif
|
|
||||||
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
|
|
||||||
# define STDC
|
|
||||||
#endif
|
|
||||||
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
|
|
||||||
# define STDC
|
|
||||||
#endif
|
|
||||||
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
|
|
||||||
# define STDC
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
|
|
||||||
# define STDC
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef STDC
|
|
||||||
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
|
|
||||||
# define const /* note: need a more gentle solution here */
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(ZLIB_CONST) && !defined(z_const)
|
|
||||||
# define z_const const
|
|
||||||
#else
|
|
||||||
# define z_const
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Some Mac compilers merge all .h files incorrectly: */
|
|
||||||
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
|
|
||||||
# define NO_DUMMY_DECL
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Maximum value for memLevel in deflateInit2 */
|
|
||||||
#ifndef MAX_MEM_LEVEL
|
|
||||||
# ifdef MAXSEG_64K
|
|
||||||
# define MAX_MEM_LEVEL 8
|
|
||||||
# else
|
|
||||||
# define MAX_MEM_LEVEL 9
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
|
|
||||||
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
|
|
||||||
* created by gzip. (Files created by minigzip can still be extracted by
|
|
||||||
* gzip.)
|
|
||||||
*/
|
|
||||||
#ifndef MAX_WBITS
|
|
||||||
# define MAX_WBITS 15 /* 32K LZ77 window */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* The memory requirements for deflate are (in bytes):
|
|
||||||
(1 << (windowBits+2)) + (1 << (memLevel+9))
|
|
||||||
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
|
|
||||||
plus a few kilobytes for small objects. For example, if you want to reduce
|
|
||||||
the default memory requirements from 256K to 128K, compile with
|
|
||||||
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
|
|
||||||
Of course this will generally degrade compression (there's no free lunch).
|
|
||||||
|
|
||||||
The memory requirements for inflate are (in bytes) 1 << windowBits
|
|
||||||
that is, 32K for windowBits=15 (default value) plus a few kilobytes
|
|
||||||
for small objects.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Type declarations */
|
|
||||||
|
|
||||||
#ifndef OF /* function prototypes */
|
|
||||||
# ifdef STDC
|
|
||||||
# define OF(args) args
|
|
||||||
# else
|
|
||||||
# define OF(args) ()
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef Z_ARG /* function prototypes for stdarg */
|
|
||||||
# if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
|
||||||
# define Z_ARG(args) args
|
|
||||||
# else
|
|
||||||
# define Z_ARG(args) ()
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* The following definitions for FAR are needed only for MSDOS mixed
|
|
||||||
* model programming (small or medium model with some far allocations).
|
|
||||||
* This was tested only with MSC; for other MSDOS compilers you may have
|
|
||||||
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
|
|
||||||
* just define FAR to be empty.
|
|
||||||
*/
|
|
||||||
#ifdef SYS16BIT
|
|
||||||
# if defined(M_I86SM) || defined(M_I86MM)
|
|
||||||
/* MSC small or medium model */
|
|
||||||
# define SMALL_MEDIUM
|
|
||||||
# ifdef _MSC_VER
|
|
||||||
# define FAR _far
|
|
||||||
# else
|
|
||||||
# define FAR far
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
# if (defined(__SMALL__) || defined(__MEDIUM__))
|
|
||||||
/* Turbo C small or medium model */
|
|
||||||
# define SMALL_MEDIUM
|
|
||||||
# ifdef __BORLANDC__
|
|
||||||
# define FAR _far
|
|
||||||
# else
|
|
||||||
# define FAR far
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(WINDOWS) || defined(WIN32)
|
|
||||||
/* If building or using zlib as a DLL, define ZLIB_DLL.
|
|
||||||
* This is not mandatory, but it offers a little performance increase.
|
|
||||||
*/
|
|
||||||
# ifdef ZLIB_DLL
|
|
||||||
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
|
|
||||||
# ifdef ZLIB_INTERNAL
|
|
||||||
# define ZEXTERN extern __declspec(dllexport)
|
|
||||||
# else
|
|
||||||
# define ZEXTERN extern __declspec(dllimport)
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
# endif /* ZLIB_DLL */
|
|
||||||
/* If building or using zlib with the WINAPI/WINAPIV calling convention,
|
|
||||||
* define ZLIB_WINAPI.
|
|
||||||
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
|
|
||||||
*/
|
|
||||||
# ifdef ZLIB_WINAPI
|
|
||||||
# ifdef FAR
|
|
||||||
# undef FAR
|
|
||||||
# endif
|
|
||||||
# include <windows.h>
|
|
||||||
/* No need for _export, use ZLIB.DEF instead. */
|
|
||||||
/* For complete Windows compatibility, use WINAPI, not __stdcall. */
|
|
||||||
# define ZEXPORT WINAPI
|
|
||||||
# ifdef WIN32
|
|
||||||
# define ZEXPORTVA WINAPIV
|
|
||||||
# else
|
|
||||||
# define ZEXPORTVA FAR CDECL
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined (__BEOS__)
|
|
||||||
# ifdef ZLIB_DLL
|
|
||||||
# ifdef ZLIB_INTERNAL
|
|
||||||
# define ZEXPORT __declspec(dllexport)
|
|
||||||
# define ZEXPORTVA __declspec(dllexport)
|
|
||||||
# else
|
|
||||||
# define ZEXPORT __declspec(dllimport)
|
|
||||||
# define ZEXPORTVA __declspec(dllimport)
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef ZEXTERN
|
|
||||||
# define ZEXTERN extern
|
|
||||||
#endif
|
|
||||||
#ifndef ZEXPORT
|
|
||||||
# define ZEXPORT
|
|
||||||
#endif
|
|
||||||
#ifndef ZEXPORTVA
|
|
||||||
# define ZEXPORTVA
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef FAR
|
|
||||||
# define FAR
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(__MACTYPES__)
|
|
||||||
typedef unsigned char Byte; /* 8 bits */
|
|
||||||
#endif
|
|
||||||
typedef unsigned int uInt; /* 16 bits or more */
|
|
||||||
typedef unsigned long uLong; /* 32 bits or more */
|
|
||||||
|
|
||||||
#ifdef SMALL_MEDIUM
|
|
||||||
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
|
|
||||||
# define Bytef Byte FAR
|
|
||||||
#else
|
|
||||||
typedef Byte FAR Bytef;
|
|
||||||
#endif
|
|
||||||
typedef char FAR charf;
|
|
||||||
typedef int FAR intf;
|
|
||||||
typedef uInt FAR uIntf;
|
|
||||||
typedef uLong FAR uLongf;
|
|
||||||
|
|
||||||
#ifdef STDC
|
|
||||||
typedef void const *voidpc;
|
|
||||||
typedef void FAR *voidpf;
|
|
||||||
typedef void *voidp;
|
|
||||||
#else
|
|
||||||
typedef Byte const *voidpc;
|
|
||||||
typedef Byte FAR *voidpf;
|
|
||||||
typedef Byte *voidp;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* ./configure may #define Z_U4 here */
|
|
||||||
|
|
||||||
#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
|
|
||||||
# include <limits.h>
|
|
||||||
# if (UINT_MAX == 0xffffffffUL)
|
|
||||||
# define Z_U4 unsigned
|
|
||||||
# else
|
|
||||||
# if (ULONG_MAX == 0xffffffffUL)
|
|
||||||
# define Z_U4 unsigned long
|
|
||||||
# else
|
|
||||||
# if (USHRT_MAX == 0xffffffffUL)
|
|
||||||
# define Z_U4 unsigned short
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef Z_U4
|
|
||||||
typedef Z_U4 z_crc_t;
|
|
||||||
#else
|
|
||||||
typedef unsigned long z_crc_t;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
|
|
||||||
# define Z_HAVE_UNISTD_H
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
|
|
||||||
# define Z_HAVE_STDARG_H
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef STDC
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# include <sys/types.h> /* for off_t */
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
# include <stddef.h> /* for wchar_t */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
|
|
||||||
* "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
|
|
||||||
* though the former does not conform to the LFS document), but considering
|
|
||||||
* both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
|
|
||||||
* equivalently requesting no 64-bit operations
|
|
||||||
*/
|
|
||||||
#if defined(LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
|
|
||||||
# undef _LARGEFILE64_SOURCE
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
|
|
||||||
# define Z_HAVE_UNISTD_H
|
|
||||||
#endif
|
|
||||||
#ifndef Z_SOLO
|
|
||||||
# if defined(Z_HAVE_UNISTD_H) || defined(LARGEFILE64_SOURCE)
|
|
||||||
# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
|
|
||||||
# ifdef VMS
|
|
||||||
# include <unixio.h> /* for off_t */
|
|
||||||
# endif
|
|
||||||
# ifndef z_off_t
|
|
||||||
# define z_off_t off_t
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
|
|
||||||
# define Z_LFS64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
|
|
||||||
# define Z_LARGE64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
|
|
||||||
# define Z_WANT64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(SEEK_SET) && !defined(Z_SOLO)
|
|
||||||
# define SEEK_SET 0 /* Seek from beginning of file. */
|
|
||||||
# define SEEK_CUR 1 /* Seek from current position. */
|
|
||||||
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef z_off_t
|
|
||||||
# define z_off_t long
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(_WIN32) && defined(Z_LARGE64)
|
|
||||||
# define z_off64_t off64_t
|
|
||||||
#else
|
|
||||||
# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
|
|
||||||
# define z_off64_t __int64
|
|
||||||
# else
|
|
||||||
# define z_off64_t z_off_t
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* MVS linker does not support external names larger than 8 bytes */
|
|
||||||
#if defined(__MVS__)
|
|
||||||
#pragma map(deflateInit_,"DEIN")
|
|
||||||
#pragma map(deflateInit2_,"DEIN2")
|
|
||||||
#pragma map(deflateEnd,"DEEND")
|
|
||||||
#pragma map(deflateBound,"DEBND")
|
|
||||||
#pragma map(inflateInit_,"ININ")
|
|
||||||
#pragma map(inflateInit2_,"ININ2")
|
|
||||||
#pragma map(inflateEnd,"INEND")
|
|
||||||
#pragma map(inflateSync,"INSY")
|
|
||||||
#pragma map(inflateSetDictionary,"INSEDI")
|
|
||||||
#pragma map(compressBound,"CMBND")
|
|
||||||
#pragma map(inflate_table,"INTABL")
|
|
||||||
#pragma map(inflate_fast,"INFA")
|
|
||||||
#pragma map(inflate_copyright,"INCOPY")
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* ZCONF_H */
|
|
||||||
113
deps/zlib/zutil.c
vendored
113
deps/zlib/zutil.c
vendored
@ -26,119 +26,6 @@ const char * const z_errmsg[10] = {
|
|||||||
"incompatible version",/* Z_VERSION_ERROR (-6) */
|
"incompatible version",/* Z_VERSION_ERROR (-6) */
|
||||||
""};
|
""};
|
||||||
|
|
||||||
|
|
||||||
const char * ZEXPORT zlibVersion()
|
|
||||||
{
|
|
||||||
return ZLIB_VERSION;
|
|
||||||
}
|
|
||||||
|
|
||||||
uLong ZEXPORT zlibCompileFlags()
|
|
||||||
{
|
|
||||||
uLong flags;
|
|
||||||
|
|
||||||
flags = 0;
|
|
||||||
switch ((int)(sizeof(uInt))) {
|
|
||||||
case 2: break;
|
|
||||||
case 4: flags += 1; break;
|
|
||||||
case 8: flags += 2; break;
|
|
||||||
default: flags += 3;
|
|
||||||
}
|
|
||||||
switch ((int)(sizeof(uLong))) {
|
|
||||||
case 2: break;
|
|
||||||
case 4: flags += 1 << 2; break;
|
|
||||||
case 8: flags += 2 << 2; break;
|
|
||||||
default: flags += 3 << 2;
|
|
||||||
}
|
|
||||||
switch ((int)(sizeof(voidpf))) {
|
|
||||||
case 2: break;
|
|
||||||
case 4: flags += 1 << 4; break;
|
|
||||||
case 8: flags += 2 << 4; break;
|
|
||||||
default: flags += 3 << 4;
|
|
||||||
}
|
|
||||||
switch ((int)(sizeof(z_off_t))) {
|
|
||||||
case 2: break;
|
|
||||||
case 4: flags += 1 << 6; break;
|
|
||||||
case 8: flags += 2 << 6; break;
|
|
||||||
default: flags += 3 << 6;
|
|
||||||
}
|
|
||||||
#ifdef DEBUG
|
|
||||||
flags += 1 << 8;
|
|
||||||
#endif
|
|
||||||
#if defined(ASMV) || defined(ASMINF)
|
|
||||||
flags += 1 << 9;
|
|
||||||
#endif
|
|
||||||
#ifdef ZLIB_WINAPI
|
|
||||||
flags += 1 << 10;
|
|
||||||
#endif
|
|
||||||
#ifdef BUILDFIXED
|
|
||||||
flags += 1 << 12;
|
|
||||||
#endif
|
|
||||||
#ifdef DYNAMIC_CRC_TABLE
|
|
||||||
flags += 1 << 13;
|
|
||||||
#endif
|
|
||||||
#ifdef NO_GZCOMPRESS
|
|
||||||
flags += 1L << 16;
|
|
||||||
#endif
|
|
||||||
#ifdef NO_GZIP
|
|
||||||
flags += 1L << 17;
|
|
||||||
#endif
|
|
||||||
#ifdef PKZIP_BUG_WORKAROUND
|
|
||||||
flags += 1L << 20;
|
|
||||||
#endif
|
|
||||||
#ifdef FASTEST
|
|
||||||
flags += 1L << 21;
|
|
||||||
#endif
|
|
||||||
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
|
||||||
# ifdef NO_vsnprintf
|
|
||||||
flags += 1L << 25;
|
|
||||||
# ifdef HAS_vsprintf_void
|
|
||||||
flags += 1L << 26;
|
|
||||||
# endif
|
|
||||||
# else
|
|
||||||
# ifdef HAS_vsnprintf_void
|
|
||||||
flags += 1L << 26;
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#else
|
|
||||||
flags += 1L << 24;
|
|
||||||
# ifdef NO_snprintf
|
|
||||||
flags += 1L << 25;
|
|
||||||
# ifdef HAS_sprintf_void
|
|
||||||
flags += 1L << 26;
|
|
||||||
# endif
|
|
||||||
# else
|
|
||||||
# ifdef HAS_snprintf_void
|
|
||||||
flags += 1L << 26;
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
return flags;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef DEBUG
|
|
||||||
|
|
||||||
# ifndef verbose
|
|
||||||
# define verbose 0
|
|
||||||
# endif
|
|
||||||
int ZLIB_INTERNAL z_verbose = verbose;
|
|
||||||
|
|
||||||
void ZLIB_INTERNAL z_error (m)
|
|
||||||
char *m;
|
|
||||||
{
|
|
||||||
fprintf(stderr, "%s\n", m);
|
|
||||||
exit(1);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* exported to allow conversion of error code to string for compress() and
|
|
||||||
* uncompress()
|
|
||||||
*/
|
|
||||||
const char * ZEXPORT zError(err)
|
|
||||||
int err;
|
|
||||||
{
|
|
||||||
return ERR_MSG(err);
|
|
||||||
}
|
|
||||||
|
|
||||||
#if defined(_WIN32_WCE)
|
#if defined(_WIN32_WCE)
|
||||||
/* The Microsoft C Run-Time Library for Windows CE doesn't have
|
/* The Microsoft C Run-Time Library for Windows CE doesn't have
|
||||||
* errno. We define it as a global variable to simplify porting.
|
* errno. We define it as a global variable to simplify porting.
|
||||||
|
|||||||
35
deps/zlib/zutil.h
vendored
35
deps/zlib/zutil.h
vendored
@ -21,13 +21,9 @@
|
|||||||
|
|
||||||
#include "zlib.h"
|
#include "zlib.h"
|
||||||
|
|
||||||
#if defined(STDC) && !defined(Z_SOLO)
|
#include <stddef.h>
|
||||||
# if !(defined(_WIN32_WCE) && defined(_MSC_VER))
|
#include <string.h>
|
||||||
# include <stddef.h>
|
#include <stdlib.h>
|
||||||
# endif
|
|
||||||
# include <string.h>
|
|
||||||
# include <stdlib.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef Z_SOLO
|
#ifdef Z_SOLO
|
||||||
typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */
|
typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */
|
||||||
@ -80,31 +76,12 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||||||
|
|
||||||
/* target dependencies */
|
/* target dependencies */
|
||||||
|
|
||||||
#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
|
|
||||||
# define OS_CODE 0x00
|
|
||||||
# ifndef Z_SOLO
|
|
||||||
# if defined(__TURBOC__) || defined(__BORLANDC__)
|
|
||||||
# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
|
|
||||||
/* Allow compilation with ANSI keywords only enabled */
|
|
||||||
void _Cdecl farfree( void *block );
|
|
||||||
void *_Cdecl farmalloc( unsigned long nbytes );
|
|
||||||
# else
|
|
||||||
# include <alloc.h>
|
|
||||||
# endif
|
|
||||||
# else /* MSC or DJGPP */
|
|
||||||
# include <malloc.h>
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef AMIGA
|
#ifdef AMIGA
|
||||||
# define OS_CODE 0x01
|
# define OS_CODE 0x01
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(VAXC) || defined(VMS)
|
#if defined(VAXC) || defined(VMS)
|
||||||
# define OS_CODE 0x02
|
# define OS_CODE 0x02
|
||||||
# define F_OPEN(name, mode) \
|
|
||||||
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(ATARI) || defined(atarist)
|
#if defined(ATARI) || defined(atarist)
|
||||||
@ -179,11 +156,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
|||||||
# define OS_CODE 0x03 /* assume Unix */
|
# define OS_CODE 0x03 /* assume Unix */
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#ifndef F_OPEN
|
/* functions */
|
||||||
# define F_OPEN(name, mode) fopen((name), (mode))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* functions */
|
|
||||||
|
|
||||||
#if defined(pyr) || defined(Z_SOLO)
|
#if defined(pyr) || defined(Z_SOLO)
|
||||||
# define NO_MEMCPY
|
# define NO_MEMCPY
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user