Index: third_party/zlib/crc32.c |
diff --git a/third_party/zlib/crc32.c b/third_party/zlib/crc32.c |
index 75f2290d83c23978afb645fe677871a8f4ba88db..09228ed9c76fbac076932fcf7c79214e10dd2bc5 100644 |
--- a/third_party/zlib/crc32.c |
+++ b/third_party/zlib/crc32.c |
@@ -1,5 +1,5 @@ |
/* crc32.c -- compute the CRC-32 of a data stream |
- * Copyright (C) 1995-2006, 2010 Mark Adler |
+ * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler |
* 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 |
@@ -17,6 +17,8 @@ |
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 |
@@ -32,31 +34,11 @@ |
#define local static |
-/* Find a four-byte integer type for crc32_little() and crc32_big(). */ |
-#ifndef NOBYFOUR |
-# ifdef STDC /* need ANSI C limits.h to determine sizes */ |
-# include <limits.h> |
-# define BYFOUR |
-# if (UINT_MAX == 0xffffffffUL) |
- typedef unsigned int u4; |
-# else |
-# if (ULONG_MAX == 0xffffffffUL) |
- typedef unsigned long u4; |
-# else |
-# if (USHRT_MAX == 0xffffffffUL) |
- typedef unsigned short u4; |
-# else |
-# undef BYFOUR /* can't find a four-byte integer type! */ |
-# endif |
-# endif |
-# endif |
-# endif /* STDC */ |
-#endif /* !NOBYFOUR */ |
- |
/* Definitions for doing the crc four data bytes at a time. */ |
+#if !defined(NOBYFOUR) && defined(Z_U4) |
+# define BYFOUR |
+#endif |
#ifdef BYFOUR |
-# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ |
- (((w)&0xff00)<<8)+(((w)&0xff)<<24)) |
local unsigned long crc32_little OF((unsigned long, |
const unsigned char FAR *, unsigned)); |
local unsigned long crc32_big OF((unsigned long, |
@@ -70,16 +52,16 @@ |
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_(uLong crc1, uLong crc2, z_off64_t len2); |
+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 unsigned long FAR crc_table[TBLS][256]; |
+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 unsigned long FAR *)); |
+ 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: |
@@ -109,9 +91,9 @@ local void make_crc_table OF((void)); |
*/ |
local void make_crc_table() |
{ |
- unsigned long c; |
+ z_crc_t c; |
int n, k; |
- unsigned long poly; /* polynomial exclusive-or pattern */ |
+ 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}; |
@@ -123,13 +105,13 @@ local void make_crc_table() |
first = 0; |
/* make exclusive-or pattern from polynomial (0xedb88320UL) */ |
- poly = 0UL; |
- for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) |
- poly |= 1UL << (31 - p[n]); |
+ 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 = (unsigned long)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; |
@@ -140,11 +122,11 @@ local void make_crc_table() |
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] = REV(c); |
+ 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] = REV(c); |
+ crc_table[k + 4][n] = ZSWAP32(c); |
} |
} |
#endif /* BYFOUR */ |
@@ -166,7 +148,7 @@ local void make_crc_table() |
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 unsigned long FAR "); |
+ 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 |
@@ -186,12 +168,13 @@ local void make_crc_table() |
#ifdef MAKECRCH |
local void write_table(out, table) |
FILE *out; |
- const unsigned long FAR *table; |
+ const z_crc_t FAR *table; |
{ |
int n; |
for (n = 0; n < 256; n++) |
- fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], |
+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", |
+ (unsigned long)(table[n]), |
n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); |
} |
#endif /* MAKECRCH */ |
@@ -206,13 +189,13 @@ local void write_table(out, table) |
/* ========================================================================= |
* This function can be used by asm versions of crc32() |
*/ |
-const unsigned long 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 unsigned long FAR *)crc_table; |
+ return (const z_crc_t FAR *)crc_table; |
} |
/* ========================================================================= */ |
@@ -234,7 +217,7 @@ unsigned long ZEXPORT crc32(crc, buf, len) |
#ifdef BYFOUR |
if (sizeof(void *) == sizeof(ptrdiff_t)) { |
- u4 endian; |
+ z_crc_t endian; |
endian = 1; |
if (*((unsigned char *)(&endian))) |
@@ -268,17 +251,17 @@ local unsigned long crc32_little(crc, buf, len) |
const unsigned char FAR *buf; |
unsigned len; |
{ |
- register u4 c; |
- register const u4 FAR *buf4; |
+ register z_crc_t c; |
+ register const z_crc_t FAR *buf4; |
- c = (u4)crc; |
+ 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 u4 FAR *)(const void FAR *)buf; |
+ buf4 = (const z_crc_t FAR *)(const void FAR *)buf; |
while (len >= 32) { |
DOLIT32; |
len -= 32; |
@@ -308,17 +291,17 @@ local unsigned long crc32_big(crc, buf, len) |
const unsigned char FAR *buf; |
unsigned len; |
{ |
- register u4 c; |
- register const u4 FAR *buf4; |
+ register z_crc_t c; |
+ register const z_crc_t FAR *buf4; |
- c = REV((u4)crc); |
+ 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 u4 FAR *)(const void FAR *)buf; |
+ buf4 = (const z_crc_t FAR *)(const void FAR *)buf; |
buf4--; |
while (len >= 32) { |
DOBIG32; |
@@ -335,7 +318,7 @@ local unsigned long crc32_big(crc, buf, len) |
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); |
} while (--len); |
c = ~c; |
- return (unsigned long)(REV(c)); |
+ return (unsigned long)(ZSWAP32(c)); |
} |
#endif /* BYFOUR */ |