Skip to content

Commit 06e895f

Browse files
andrewc12andrewc12
committed
Replace zlib with near stock gnuwin zlib 1.2.3
By replacing most of the reformatted code with original code, we can take advantage of cleaner diffs while upgrading https://gnuwin32.sourceforge.net/packages/zlib.htm Signed-off-by: Andrew Innes <[email protected]>
1 parent 167ea96 commit 06e895f

33 files changed

+11685
-12523
lines changed

‎lib/os/windows/zlib-1.2.3/adler32.c

Lines changed: 116 additions & 120 deletions
Original file line numberDiff line numberDiff line change
@@ -1,153 +1,149 @@
1-
/*
2-
* adler32.c -- compute the Adler-32 checksum of a data stream
1+
/* adler32.c -- compute the Adler-32 checksum of a data stream
32
* Copyright (C) 1995-2004 Mark Adler
43
* For conditions of distribution and use, see copyright notice in zlib.h
54
*/
65

76
/* @(#) $Id$ */
87

9-
#define ZLIB_INTERNAL
8+
#define ZLIB_INTERNAL
109
#include "zlib.h"
1110

12-
#define BASE 65521UL /* largest prime smaller than 65536 */
13-
#define NMAX 5552
11+
#define BASE 65521UL /* largest prime smaller than 65536 */
12+
#define NMAX 5552
1413
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
1514

16-
#define DO1(buf, i) {adler += (buf)[i]; sum2 += adler; }
17-
#define DO2(buf, i) DO1(buf, i); DO1(buf, i+1);
18-
#define DO4(buf, i) DO2(buf, i); DO2(buf, i+2);
19-
#define DO8(buf, i) DO4(buf, i); DO4(buf, i+4);
20-
#define DO16(buf) DO8(buf, 0); DO8(buf, 8);
15+
#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
16+
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
17+
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
18+
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
19+
#define DO16(buf) DO8(buf,0); DO8(buf,8);
2120

2221
/* use NO_DIVIDE if your processor does not do division in hardware */
2322
#ifdef NO_DIVIDE
24-
#define MOD(a) \
23+
# define MOD(a) \
2524
do { \
26-
if (a >= (BASE << 16)) a -= (BASE << 16); \
27-
if (a >= (BASE << 15)) a -= (BASE << 15); \
28-
if (a >= (BASE << 14)) a -= (BASE << 14); \
29-
if (a >= (BASE << 13)) a -= (BASE << 13); \
30-
if (a >= (BASE << 12)) a -= (BASE << 12); \
31-
if (a >= (BASE << 11)) a -= (BASE << 11); \
32-
if (a >= (BASE << 10)) a -= (BASE << 10); \
33-
if (a >= (BASE << 9)) a -= (BASE << 9); \
34-
if (a >= (BASE << 8)) a -= (BASE << 8); \
35-
if (a >= (BASE << 7)) a -= (BASE << 7); \
36-
if (a >= (BASE << 6)) a -= (BASE << 6); \
37-
if (a >= (BASE << 5)) a -= (BASE << 5); \
38-
if (a >= (BASE << 4)) a -= (BASE << 4); \
39-
if (a >= (BASE << 3)) a -= (BASE << 3); \
40-
if (a >= (BASE << 2)) a -= (BASE << 2); \
41-
if (a >= (BASE << 1)) a -= (BASE << 1); \
42-
if (a >= BASE) a -= BASE; \
43-
} while (0)
44-
#define MOD4(a) \
25+
if (a >= (BASE << 16)) a -= (BASE << 16); \
26+
if (a >= (BASE << 15)) a -= (BASE << 15); \
27+
if (a >= (BASE << 14)) a -= (BASE << 14); \
28+
if (a >= (BASE << 13)) a -= (BASE << 13); \
29+
if (a >= (BASE << 12)) a -= (BASE << 12); \
30+
if (a >= (BASE << 11)) a -= (BASE << 11); \
31+
if (a >= (BASE << 10)) a -= (BASE << 10); \
32+
if (a >= (BASE << 9)) a -= (BASE << 9); \
33+
if (a >= (BASE << 8)) a -= (BASE << 8); \
34+
if (a >= (BASE << 7)) a -= (BASE << 7); \
35+
if (a >= (BASE << 6)) a -= (BASE << 6); \
36+
if (a >= (BASE << 5)) a -= (BASE << 5); \
37+
if (a >= (BASE << 4)) a -= (BASE << 4); \
38+
if (a >= (BASE << 3)) a -= (BASE << 3); \
39+
if (a >= (BASE << 2)) a -= (BASE << 2); \
40+
if (a >= (BASE << 1)) a -= (BASE << 1); \
41+
if (a >= BASE) a -= BASE; \
42+
} while (0)
43+
# define MOD4(a) \
4544
do { \
46-
if (a >= (BASE << 4)) a -= (BASE << 4); \
47-
if (a >= (BASE << 3)) a -= (BASE << 3); \
48-
if (a >= (BASE << 2)) a -= (BASE << 2); \
49-
if (a >= (BASE << 1)) a -= (BASE << 1); \
50-
if (a >= BASE) a -= BASE; \
51-
} while (0)
45+
if (a >= (BASE << 4)) a -= (BASE << 4); \
46+
if (a >= (BASE << 3)) a -= (BASE << 3); \
47+
if (a >= (BASE << 2)) a -= (BASE << 2); \
48+
if (a >= (BASE << 1)) a -= (BASE << 1); \
49+
if (a >= BASE) a -= BASE; \
50+
} while (0)
5251
#else
53-
#define MOD(a) a %= BASE
54-
#define MOD4(a) a %= BASE
52+
# define MOD(a) a %= BASE
53+
# define MOD4(a) a %= BASE
5554
#endif
5655

5756
/* ========================================================================= */
58-
uLong ZEXPORT
59-
adler32(
60-
uLong adler,
61-
const Bytef *buf,
62-
uInt len)
57+
uLong ZEXPORT adler32(adler, buf, len)
58+
uLong adler;
59+
const Bytef *buf;
60+
uInt len;
6361
{
64-
unsigned long sum2;
65-
unsigned n;
62+
unsigned long sum2;
63+
unsigned n;
6664

67-
/* split Adler-32 into component sums */
68-
sum2 = (adler >> 16) & 0xffff;
69-
adler &= 0xffff;
65+
/* split Adler-32 into component sums */
66+
sum2 = (adler >> 16) & 0xffff;
67+
adler &= 0xffff;
7068

71-
/* in case user likes doing a byte at a time, keep it fast */
72-
if (len == 1) {
73-
adler += buf[0];
74-
if (adler >= BASE)
75-
adler -= BASE;
76-
sum2 += adler;
77-
if (sum2 >= BASE)
78-
sum2 -= BASE;
79-
return (adler | (sum2 << 16));
80-
}
69+
/* in case user likes doing a byte at a time, keep it fast */
70+
if (len == 1) {
71+
adler += buf[0];
72+
if (adler >= BASE)
73+
adler -= BASE;
74+
sum2 += adler;
75+
if (sum2 >= BASE)
76+
sum2 -= BASE;
77+
return adler | (sum2 << 16);
78+
}
8179

82-
/* initial Adler-32 value (deferred check for len == 1 speed) */
83-
if (buf == Z_NULL)
84-
return (1L);
80+
/* initial Adler-32 value (deferred check for len == 1 speed) */
81+
if (buf == Z_NULL)
82+
return 1L;
8583

86-
/* in case short lengths are provided, keep it somewhat fast */
87-
if (len < 16) {
88-
while (len--) {
89-
adler += *buf++;
90-
sum2 += adler;
91-
}
92-
if (adler >= BASE)
93-
adler -= BASE;
94-
MOD4(sum2); /* only added so many BASE's */
95-
return (adler | (sum2 << 16));
96-
}
84+
/* in case short lengths are provided, keep it somewhat fast */
85+
if (len < 16) {
86+
while (len--) {
87+
adler += *buf++;
88+
sum2 += adler;
89+
}
90+
if (adler >= BASE)
91+
adler -= BASE;
92+
MOD4(sum2); /* only added so many BASE's */
93+
return adler | (sum2 << 16);
94+
}
9795

98-
/* do length NMAX blocks -- requires just one modulo operation */
99-
while (len >= NMAX) {
100-
len -= NMAX;
101-
n = NMAX / 16; /* NMAX is divisible by 16 */
102-
do {
103-
DO16(buf); /* 16 sums unrolled */
104-
buf += 16;
105-
} while (--n);
106-
MOD(adler);
107-
MOD(sum2);
108-
}
96+
/* do length NMAX blocks -- requires just one modulo operation */
97+
while (len >= NMAX) {
98+
len -= NMAX;
99+
n = NMAX / 16; /* NMAX is divisible by 16 */
100+
do {
101+
DO16(buf); /* 16 sums unrolled */
102+
buf += 16;
103+
} while (--n);
104+
MOD(adler);
105+
MOD(sum2);
106+
}
109107

110-
/* do remaining bytes (less than NMAX, still just one modulo) */
111-
if (len) { /* avoid modulos if none remaining */
112-
while (len >= 16) {
113-
len -= 16;
114-
DO16(buf);
115-
buf += 16;
116-
}
117-
while (len--) {
118-
adler += *buf++;
119-
sum2 += adler;
120-
}
121-
MOD(adler);
122-
MOD(sum2);
123-
}
108+
/* do remaining bytes (less than NMAX, still just one modulo) */
109+
if (len) { /* avoid modulos if none remaining */
110+
while (len >= 16) {
111+
len -= 16;
112+
DO16(buf);
113+
buf += 16;
114+
}
115+
while (len--) {
116+
adler += *buf++;
117+
sum2 += adler;
118+
}
119+
MOD(adler);
120+
MOD(sum2);
121+
}
124122

125-
/* return recombined sums */
126-
return (adler | (sum2 << 16));
123+
/* return recombined sums */
124+
return adler | (sum2 << 16);
127125
}
128126

129127
/* ========================================================================= */
130-
uLong ZEXPORT
131-
adler32_combine(
132-
uLong adler1,
133-
uLong adler2,
134-
z_off_t len2)
128+
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
129+
uLong adler1;
130+
uLong adler2;
131+
z_off_t len2;
135132
{
136-
unsigned long sum1;
137-
unsigned long sum2;
138-
unsigned rem;
133+
unsigned long sum1;
134+
unsigned long sum2;
135+
unsigned rem;
139136

140-
/* the derivation of this formula is left as an exercise for the reader */
141-
rem = (unsigned)(len2 % BASE);
142-
sum1 = adler1 & 0xffff;
143-
sum2 = rem * sum1;
144-
MOD(sum2);
145-
sum1 += (adler2 & 0xffff) + BASE - 1;
146-
sum2 += ((adler1 >> 16) & 0xffff) +
147-
((adler2 >> 16) & 0xffff) + BASE - rem;
148-
if (sum1 > BASE) sum1 -= BASE;
149-
if (sum1 > BASE) sum1 -= BASE;
150-
if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
151-
if (sum2 > BASE) sum2 -= BASE;
152-
return (sum1 | (sum2 << 16));
137+
/* the derivation of this formula is left as an exercise for the reader */
138+
rem = (unsigned)(len2 % BASE);
139+
sum1 = adler1 & 0xffff;
140+
sum2 = rem * sum1;
141+
MOD(sum2);
142+
sum1 += (adler2 & 0xffff) + BASE - 1;
143+
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
144+
if (sum1 > BASE) sum1 -= BASE;
145+
if (sum1 > BASE) sum1 -= BASE;
146+
if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
147+
if (sum2 > BASE) sum2 -= BASE;
148+
return sum1 | (sum2 << 16);
153149
}

0 commit comments

Comments
 (0)