aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c')
-rw-r--r--libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c850
1 files changed, 425 insertions, 425 deletions
diff --git a/libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c b/libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c
index 95a30f1..979a719 100644
--- a/libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c
+++ b/libraries/irrlicht-1.8/source/Irrlicht/zlib/crc32.c
@@ -1,425 +1,425 @@
1/* crc32.c -- compute the CRC-32 of a data stream 1/* crc32.c -- compute the CRC-32 of a data stream
2 * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler 2 * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h 3 * For conditions of distribution and use, see copyright notice in zlib.h
4 * 4 *
5 * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster 5 * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
6 * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing 6 * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
7 * tables for updating the shift register in one step with three exclusive-ors 7 * tables for updating the shift register in one step with three exclusive-ors
8 * instead of four steps with four exclusive-ors. This results in about a 8 * instead of four steps with four exclusive-ors. This results in about a
9 * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. 9 * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
10 */ 10 */
11 11
12/* @(#) $Id$ */ 12/* @(#) $Id$ */
13 13
14/* 14/*
15 Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore 15 Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
16 protection on the static variables used to control the first-use generation 16 protection on the static variables used to control the first-use generation
17 of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should 17 of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
18 first call get_crc_table() to initialize the tables before allowing more than 18 first call get_crc_table() to initialize the tables before allowing more than
19 one thread to use crc32(). 19 one thread to use crc32().
20 20
21 DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. 21 DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
22 */ 22 */
23 23
24#ifdef MAKECRCH 24#ifdef MAKECRCH
25# include <stdio.h> 25# include <stdio.h>
26# ifndef DYNAMIC_CRC_TABLE 26# ifndef DYNAMIC_CRC_TABLE
27# define DYNAMIC_CRC_TABLE 27# define DYNAMIC_CRC_TABLE
28# endif /* !DYNAMIC_CRC_TABLE */ 28# endif /* !DYNAMIC_CRC_TABLE */
29#endif /* MAKECRCH */ 29#endif /* MAKECRCH */
30 30
31#include "zutil.h" /* for STDC and FAR definitions */ 31#include "zutil.h" /* for STDC and FAR definitions */
32 32
33#define local static 33#define local static
34 34
35/* Definitions for doing the crc four data bytes at a time. */ 35/* Definitions for doing the crc four data bytes at a time. */
36#if !defined(NOBYFOUR) && defined(Z_U4) 36#if !defined(NOBYFOUR) && defined(Z_U4)
37# define BYFOUR 37# define BYFOUR
38#endif 38#endif
39#ifdef BYFOUR 39#ifdef BYFOUR
40 local unsigned long crc32_little OF((unsigned long, 40 local unsigned long crc32_little OF((unsigned long,
41 const unsigned char FAR *, unsigned)); 41 const unsigned char FAR *, unsigned));
42 local unsigned long crc32_big OF((unsigned long, 42 local unsigned long crc32_big OF((unsigned long,
43 const unsigned char FAR *, unsigned)); 43 const unsigned char FAR *, unsigned));
44# define TBLS 8 44# define TBLS 8
45#else 45#else
46# define TBLS 1 46# define TBLS 1
47#endif /* BYFOUR */ 47#endif /* BYFOUR */
48 48
49/* Local functions for crc concatenation */ 49/* Local functions for crc concatenation */
50local unsigned long gf2_matrix_times OF((unsigned long *mat, 50local unsigned long gf2_matrix_times OF((unsigned long *mat,
51 unsigned long vec)); 51 unsigned long vec));
52local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); 52local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
53local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); 53local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
54 54
55 55
56#ifdef DYNAMIC_CRC_TABLE 56#ifdef DYNAMIC_CRC_TABLE
57 57
58local volatile int crc_table_empty = 1; 58local volatile int crc_table_empty = 1;
59local z_crc_t FAR crc_table[TBLS][256]; 59local z_crc_t FAR crc_table[TBLS][256];
60local void make_crc_table OF((void)); 60local void make_crc_table OF((void));
61#ifdef MAKECRCH 61#ifdef MAKECRCH
62 local void write_table OF((FILE *, const z_crc_t FAR *)); 62 local void write_table OF((FILE *, const z_crc_t FAR *));
63#endif /* MAKECRCH */ 63#endif /* MAKECRCH */
64/* 64/*
65 Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: 65 Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
66 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. 66 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.
67 67
68 Polynomials over GF(2) are represented in binary, one bit per coefficient, 68 Polynomials over GF(2) are represented in binary, one bit per coefficient,
69 with the lowest powers in the most significant bit. Then adding polynomials 69 with the lowest powers in the most significant bit. Then adding polynomials
70 is just exclusive-or, and multiplying a polynomial by x is a right shift by 70 is just exclusive-or, and multiplying a polynomial by x is a right shift by
71 one. If we call the above polynomial p, and represent a byte as the 71 one. If we call the above polynomial p, and represent a byte as the
72 polynomial q, also with the lowest power in the most significant bit (so the 72 polynomial q, also with the lowest power in the most significant bit (so the
73 byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, 73 byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
74 where a mod b means the remainder after dividing a by b. 74 where a mod b means the remainder after dividing a by b.
75 75
76 This calculation is done using the shift-register method of multiplying and 76 This calculation is done using the shift-register method of multiplying and
77 taking the remainder. The register is initialized to zero, and for each 77 taking the remainder. The register is initialized to zero, and for each
78 incoming bit, x^32 is added mod p to the register if the bit is a one (where 78 incoming bit, x^32 is added mod p to the register if the bit is a one (where
79 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by 79 x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
80 x (which is shifting right by one and adding x^32 mod p if the bit shifted 80 x (which is shifting right by one and adding x^32 mod p if the bit shifted
81 out is a one). We start with the highest power (least significant bit) of 81 out is a one). We start with the highest power (least significant bit) of
82 q and repeat for all eight bits of q. 82 q and repeat for all eight bits of q.
83 83
84 The first table is simply the CRC of all possible eight bit values. This is 84 The first table is simply the CRC of all possible eight bit values. This is
85 all the information needed to generate CRCs on data a byte at a time for all 85 all the information needed to generate CRCs on data a byte at a time for all
86 combinations of CRC register values and incoming bytes. The remaining tables 86 combinations of CRC register values and incoming bytes. The remaining tables
87 allow for word-at-a-time CRC calculation for both big-endian and little- 87 allow for word-at-a-time CRC calculation for both big-endian and little-
88 endian machines, where a word is four bytes. 88 endian machines, where a word is four bytes.
89*/ 89*/
90local void make_crc_table() 90local void make_crc_table()
91{ 91{
92 z_crc_t c; 92 z_crc_t c;
93 int n, k; 93 int n, k;
94 z_crc_t poly; /* polynomial exclusive-or pattern */ 94 z_crc_t poly; /* polynomial exclusive-or pattern */
95 /* terms of polynomial defining this crc (except x^32): */ 95 /* terms of polynomial defining this crc (except x^32): */
96 static volatile int first = 1; /* flag to limit concurrent making */ 96 static volatile int first = 1; /* flag to limit concurrent making */
97 static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; 97 static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
98 98
99 /* See if another task is already doing this (not thread-safe, but better 99 /* See if another task is already doing this (not thread-safe, but better
100 than nothing -- significantly reduces duration of vulnerability in 100 than nothing -- significantly reduces duration of vulnerability in
101 case the advice about DYNAMIC_CRC_TABLE is ignored) */ 101 case the advice about DYNAMIC_CRC_TABLE is ignored) */
102 if (first) { 102 if (first) {
103 first = 0; 103 first = 0;
104 104
105 /* make exclusive-or pattern from polynomial (0xedb88320UL) */ 105 /* make exclusive-or pattern from polynomial (0xedb88320UL) */
106 poly = 0; 106 poly = 0;
107 for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) 107 for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
108 poly |= (z_crc_t)1 << (31 - p[n]); 108 poly |= (z_crc_t)1 << (31 - p[n]);
109 109
110 /* generate a crc for every 8-bit value */ 110 /* generate a crc for every 8-bit value */
111 for (n = 0; n < 256; n++) { 111 for (n = 0; n < 256; n++) {
112 c = (z_crc_t)n; 112 c = (z_crc_t)n;
113 for (k = 0; k < 8; k++) 113 for (k = 0; k < 8; k++)
114 c = c & 1 ? poly ^ (c >> 1) : c >> 1; 114 c = c & 1 ? poly ^ (c >> 1) : c >> 1;
115 crc_table[0][n] = c; 115 crc_table[0][n] = c;
116 } 116 }
117 117
118#ifdef BYFOUR 118#ifdef BYFOUR
119 /* generate crc for each value followed by one, two, and three zeros, 119 /* generate crc for each value followed by one, two, and three zeros,
120 and then the byte reversal of those as well as the first table */ 120 and then the byte reversal of those as well as the first table */
121 for (n = 0; n < 256; n++) { 121 for (n = 0; n < 256; n++) {
122 c = crc_table[0][n]; 122 c = crc_table[0][n];
123 crc_table[4][n] = ZSWAP32(c); 123 crc_table[4][n] = ZSWAP32(c);
124 for (k = 1; k < 4; k++) { 124 for (k = 1; k < 4; k++) {
125 c = crc_table[0][c & 0xff] ^ (c >> 8); 125 c = crc_table[0][c & 0xff] ^ (c >> 8);
126 crc_table[k][n] = c; 126 crc_table[k][n] = c;
127 crc_table[k + 4][n] = ZSWAP32(c); 127 crc_table[k + 4][n] = ZSWAP32(c);
128 } 128 }
129 } 129 }
130#endif /* BYFOUR */ 130#endif /* BYFOUR */
131 131
132 crc_table_empty = 0; 132 crc_table_empty = 0;
133 } 133 }
134 else { /* not first */ 134 else { /* not first */
135 /* wait for the other guy to finish (not efficient, but rare) */ 135 /* wait for the other guy to finish (not efficient, but rare) */
136 while (crc_table_empty) 136 while (crc_table_empty)
137 ; 137 ;
138 } 138 }
139 139
140#ifdef MAKECRCH 140#ifdef MAKECRCH
141 /* write out CRC tables to crc32.h */ 141 /* write out CRC tables to crc32.h */
142 { 142 {
143 FILE *out; 143 FILE *out;
144 144
145 out = fopen("crc32.h", "w"); 145 out = fopen("crc32.h", "w");
146 if (out == NULL) return; 146 if (out == NULL) return;
147 fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); 147 fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
148 fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); 148 fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
149 fprintf(out, "local const z_crc_t FAR "); 149 fprintf(out, "local const z_crc_t FAR ");
150 fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); 150 fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
151 write_table(out, crc_table[0]); 151 write_table(out, crc_table[0]);
152# ifdef BYFOUR 152# ifdef BYFOUR
153 fprintf(out, "#ifdef BYFOUR\n"); 153 fprintf(out, "#ifdef BYFOUR\n");
154 for (k = 1; k < 8; k++) { 154 for (k = 1; k < 8; k++) {
155 fprintf(out, " },\n {\n"); 155 fprintf(out, " },\n {\n");
156 write_table(out, crc_table[k]); 156 write_table(out, crc_table[k]);
157 } 157 }
158 fprintf(out, "#endif\n"); 158 fprintf(out, "#endif\n");
159# endif /* BYFOUR */ 159# endif /* BYFOUR */
160 fprintf(out, " }\n};\n"); 160 fprintf(out, " }\n};\n");
161 fclose(out); 161 fclose(out);
162 } 162 }
163#endif /* MAKECRCH */ 163#endif /* MAKECRCH */
164} 164}
165 165
166#ifdef MAKECRCH 166#ifdef MAKECRCH
167local void write_table(out, table) 167local void write_table(out, table)
168 FILE *out; 168 FILE *out;
169 const z_crc_t FAR *table; 169 const z_crc_t FAR *table;
170{ 170{
171 int n; 171 int n;
172 172
173 for (n = 0; n < 256; n++) 173 for (n = 0; n < 256; n++)
174 fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", 174 fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ",
175 (unsigned long)(table[n]), 175 (unsigned long)(table[n]),
176 n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); 176 n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
177} 177}
178#endif /* MAKECRCH */ 178#endif /* MAKECRCH */
179 179
180#else /* !DYNAMIC_CRC_TABLE */ 180#else /* !DYNAMIC_CRC_TABLE */
181/* ======================================================================== 181/* ========================================================================
182 * Tables of CRC-32s of all single-byte values, made by make_crc_table(). 182 * Tables of CRC-32s of all single-byte values, made by make_crc_table().
183 */ 183 */
184#include "crc32.h" 184#include "crc32.h"
185#endif /* DYNAMIC_CRC_TABLE */ 185#endif /* DYNAMIC_CRC_TABLE */
186 186
187/* ========================================================================= 187/* =========================================================================
188 * This function can be used by asm versions of crc32() 188 * This function can be used by asm versions of crc32()
189 */ 189 */
190const z_crc_t FAR * ZEXPORT get_crc_table() 190const z_crc_t FAR * ZEXPORT get_crc_table()
191{ 191{
192#ifdef DYNAMIC_CRC_TABLE 192#ifdef DYNAMIC_CRC_TABLE
193 if (crc_table_empty) 193 if (crc_table_empty)
194 make_crc_table(); 194 make_crc_table();
195#endif /* DYNAMIC_CRC_TABLE */ 195#endif /* DYNAMIC_CRC_TABLE */
196 return (const z_crc_t FAR *)crc_table; 196 return (const z_crc_t FAR *)crc_table;
197} 197}
198 198
199/* ========================================================================= */ 199/* ========================================================================= */
200#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) 200#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
201#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 201#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
202 202
203/* ========================================================================= */ 203/* ========================================================================= */
204unsigned long ZEXPORT crc32(crc, buf, len) 204unsigned long ZEXPORT crc32(crc, buf, len)
205 unsigned long crc; 205 unsigned long crc;
206 const unsigned char FAR *buf; 206 const unsigned char FAR *buf;
207 uInt len; 207 uInt len;
208{ 208{
209 if (buf == Z_NULL) return 0UL; 209 if (buf == Z_NULL) return 0UL;
210 210
211#ifdef DYNAMIC_CRC_TABLE 211#ifdef DYNAMIC_CRC_TABLE
212 if (crc_table_empty) 212 if (crc_table_empty)
213 make_crc_table(); 213 make_crc_table();
214#endif /* DYNAMIC_CRC_TABLE */ 214#endif /* DYNAMIC_CRC_TABLE */
215 215
216#ifdef BYFOUR 216#ifdef BYFOUR
217 if (sizeof(void *) == sizeof(ptrdiff_t)) { 217 if (sizeof(void *) == sizeof(ptrdiff_t)) {
218 z_crc_t endian; 218 z_crc_t endian;
219 219
220 endian = 1; 220 endian = 1;
221 if (*((unsigned char *)(&endian))) 221 if (*((unsigned char *)(&endian)))
222 return crc32_little(crc, buf, len); 222 return crc32_little(crc, buf, len);
223 else 223 else
224 return crc32_big(crc, buf, len); 224 return crc32_big(crc, buf, len);
225 } 225 }
226#endif /* BYFOUR */ 226#endif /* BYFOUR */
227 crc = crc ^ 0xffffffffUL; 227 crc = crc ^ 0xffffffffUL;
228 while (len >= 8) { 228 while (len >= 8) {
229 DO8; 229 DO8;
230 len -= 8; 230 len -= 8;
231 } 231 }
232 if (len) do { 232 if (len) do {
233 DO1; 233 DO1;
234 } while (--len); 234 } while (--len);
235 return crc ^ 0xffffffffUL; 235 return crc ^ 0xffffffffUL;
236} 236}
237 237
238#ifdef BYFOUR 238#ifdef BYFOUR
239 239
240/* ========================================================================= */ 240/* ========================================================================= */
241#define DOLIT4 c ^= *buf4++; \ 241#define DOLIT4 c ^= *buf4++; \
242 c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ 242 c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
243 crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] 243 crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
244#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 244#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
245 245
246/* ========================================================================= */ 246/* ========================================================================= */
247local unsigned long crc32_little(crc, buf, len) 247local unsigned long crc32_little(crc, buf, len)
248 unsigned long crc; 248 unsigned long crc;
249 const unsigned char FAR *buf; 249 const unsigned char FAR *buf;
250 unsigned len; 250 unsigned len;
251{ 251{
252 register z_crc_t c; 252 register z_crc_t c;
253 register const z_crc_t FAR *buf4; 253 register const z_crc_t FAR *buf4;
254 254
255 c = (z_crc_t)crc; 255 c = (z_crc_t)crc;
256 c = ~c; 256 c = ~c;
257 while (len && ((ptrdiff_t)buf & 3)) { 257 while (len && ((ptrdiff_t)buf & 3)) {
258 c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 258 c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
259 len--; 259 len--;
260 } 260 }
261 261
262 buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 262 buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
263 while (len >= 32) { 263 while (len >= 32) {
264 DOLIT32; 264 DOLIT32;
265 len -= 32; 265 len -= 32;
266 } 266 }
267 while (len >= 4) { 267 while (len >= 4) {
268 DOLIT4; 268 DOLIT4;
269 len -= 4; 269 len -= 4;
270 } 270 }
271 buf = (const unsigned char FAR *)buf4; 271 buf = (const unsigned char FAR *)buf4;
272 272
273 if (len) do { 273 if (len) do {
274 c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); 274 c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
275 } while (--len); 275 } while (--len);
276 c = ~c; 276 c = ~c;
277 return (unsigned long)c; 277 return (unsigned long)c;
278} 278}
279 279
280/* ========================================================================= */ 280/* ========================================================================= */
281#define DOBIG4 c ^= *++buf4; \ 281#define DOBIG4 c ^= *++buf4; \
282 c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ 282 c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
283 crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] 283 crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
284#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 284#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
285 285
286/* ========================================================================= */ 286/* ========================================================================= */
287local unsigned long crc32_big(crc, buf, len) 287local unsigned long crc32_big(crc, buf, len)
288 unsigned long crc; 288 unsigned long crc;
289 const unsigned char FAR *buf; 289 const unsigned char FAR *buf;
290 unsigned len; 290 unsigned len;
291{ 291{
292 register z_crc_t c; 292 register z_crc_t c;
293 register const z_crc_t FAR *buf4; 293 register const z_crc_t FAR *buf4;
294 294
295 c = ZSWAP32((z_crc_t)crc); 295 c = ZSWAP32((z_crc_t)crc);
296 c = ~c; 296 c = ~c;
297 while (len && ((ptrdiff_t)buf & 3)) { 297 while (len && ((ptrdiff_t)buf & 3)) {
298 c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 298 c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
299 len--; 299 len--;
300 } 300 }
301 301
302 buf4 = (const z_crc_t FAR *)(const void FAR *)buf; 302 buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
303 buf4--; 303 buf4--;
304 while (len >= 32) { 304 while (len >= 32) {
305 DOBIG32; 305 DOBIG32;
306 len -= 32; 306 len -= 32;
307 } 307 }
308 while (len >= 4) { 308 while (len >= 4) {
309 DOBIG4; 309 DOBIG4;
310 len -= 4; 310 len -= 4;
311 } 311 }
312 buf4++; 312 buf4++;
313 buf = (const unsigned char FAR *)buf4; 313 buf = (const unsigned char FAR *)buf4;
314 314
315 if (len) do { 315 if (len) do {
316 c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); 316 c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
317 } while (--len); 317 } while (--len);
318 c = ~c; 318 c = ~c;
319 return (unsigned long)(ZSWAP32(c)); 319 return (unsigned long)(ZSWAP32(c));
320} 320}
321 321
322#endif /* BYFOUR */ 322#endif /* BYFOUR */
323 323
324#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ 324#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
325 325
326/* ========================================================================= */ 326/* ========================================================================= */
327local unsigned long gf2_matrix_times(mat, vec) 327local unsigned long gf2_matrix_times(mat, vec)
328 unsigned long *mat; 328 unsigned long *mat;
329 unsigned long vec; 329 unsigned long vec;
330{ 330{
331 unsigned long sum; 331 unsigned long sum;
332 332
333 sum = 0; 333 sum = 0;
334 while (vec) { 334 while (vec) {
335 if (vec & 1) 335 if (vec & 1)
336 sum ^= *mat; 336 sum ^= *mat;
337 vec >>= 1; 337 vec >>= 1;
338 mat++; 338 mat++;
339 } 339 }
340 return sum; 340 return sum;
341} 341}
342 342
343/* ========================================================================= */ 343/* ========================================================================= */
344local void gf2_matrix_square(square, mat) 344local void gf2_matrix_square(square, mat)
345 unsigned long *square; 345 unsigned long *square;
346 unsigned long *mat; 346 unsigned long *mat;
347{ 347{
348 int n; 348 int n;
349 349
350 for (n = 0; n < GF2_DIM; n++) 350 for (n = 0; n < GF2_DIM; n++)
351 square[n] = gf2_matrix_times(mat, mat[n]); 351 square[n] = gf2_matrix_times(mat, mat[n]);
352} 352}
353 353
354/* ========================================================================= */ 354/* ========================================================================= */
355local uLong crc32_combine_(crc1, crc2, len2) 355local uLong crc32_combine_(crc1, crc2, len2)
356 uLong crc1; 356 uLong crc1;
357 uLong crc2; 357 uLong crc2;
358 z_off64_t len2; 358 z_off64_t len2;
359{ 359{
360 int n; 360 int n;
361 unsigned long row; 361 unsigned long row;
362 unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ 362 unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
363 unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ 363 unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
364 364
365 /* degenerate case (also disallow negative lengths) */ 365 /* degenerate case (also disallow negative lengths) */
366 if (len2 <= 0) 366 if (len2 <= 0)
367 return crc1; 367 return crc1;
368 368
369 /* put operator for one zero bit in odd */ 369 /* put operator for one zero bit in odd */
370 odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ 370 odd[0] = 0xedb88320UL; /* CRC-32 polynomial */
371 row = 1; 371 row = 1;
372 for (n = 1; n < GF2_DIM; n++) { 372 for (n = 1; n < GF2_DIM; n++) {
373 odd[n] = row; 373 odd[n] = row;
374 row <<= 1; 374 row <<= 1;
375 } 375 }
376 376
377 /* put operator for two zero bits in even */ 377 /* put operator for two zero bits in even */
378 gf2_matrix_square(even, odd); 378 gf2_matrix_square(even, odd);
379 379
380 /* put operator for four zero bits in odd */ 380 /* put operator for four zero bits in odd */
381 gf2_matrix_square(odd, even); 381 gf2_matrix_square(odd, even);
382 382
383 /* apply len2 zeros to crc1 (first square will put the operator for one 383 /* apply len2 zeros to crc1 (first square will put the operator for one
384 zero byte, eight zero bits, in even) */ 384 zero byte, eight zero bits, in even) */
385 do { 385 do {
386 /* apply zeros operator for this bit of len2 */ 386 /* apply zeros operator for this bit of len2 */
387 gf2_matrix_square(even, odd); 387 gf2_matrix_square(even, odd);
388 if (len2 & 1) 388 if (len2 & 1)
389 crc1 = gf2_matrix_times(even, crc1); 389 crc1 = gf2_matrix_times(even, crc1);
390 len2 >>= 1; 390 len2 >>= 1;
391 391
392 /* if no more bits set, then done */ 392 /* if no more bits set, then done */
393 if (len2 == 0) 393 if (len2 == 0)
394 break; 394 break;
395 395
396 /* another iteration of the loop with odd and even swapped */ 396 /* another iteration of the loop with odd and even swapped */
397 gf2_matrix_square(odd, even); 397 gf2_matrix_square(odd, even);
398 if (len2 & 1) 398 if (len2 & 1)
399 crc1 = gf2_matrix_times(odd, crc1); 399 crc1 = gf2_matrix_times(odd, crc1);
400 len2 >>= 1; 400 len2 >>= 1;
401 401
402 /* if no more bits set, then done */ 402 /* if no more bits set, then done */
403 } while (len2 != 0); 403 } while (len2 != 0);
404 404
405 /* return combined crc */ 405 /* return combined crc */
406 crc1 ^= crc2; 406 crc1 ^= crc2;
407 return crc1; 407 return crc1;
408} 408}
409 409
410/* ========================================================================= */ 410/* ========================================================================= */
411uLong ZEXPORT crc32_combine(crc1, crc2, len2) 411uLong ZEXPORT crc32_combine(crc1, crc2, len2)
412 uLong crc1; 412 uLong crc1;
413 uLong crc2; 413 uLong crc2;
414 z_off_t len2; 414 z_off_t len2;
415{ 415{
416 return crc32_combine_(crc1, crc2, len2); 416 return crc32_combine_(crc1, crc2, len2);
417} 417}
418 418
419uLong ZEXPORT crc32_combine64(crc1, crc2, len2) 419uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
420 uLong crc1; 420 uLong crc1;
421 uLong crc2; 421 uLong crc2;
422 z_off64_t len2; 422 z_off64_t len2;
423{ 423{
424 return crc32_combine_(crc1, crc2, len2); 424 return crc32_combine_(crc1, crc2, len2);
425} 425}
generated by cgit v1.1 at 2024-07-12 05:11:17 +0000