Commit | Line | Data |
---|---|---|
25f0751f | 1 | /* zutil.c -- target dependent utility functions for the compression library |
6b93e4bc | 2 | * Copyright (C) 1995-2017 Jean-loup Gailly |
25f0751f PM |
3 | * For conditions of distribution and use, see copyright notice in zlib.h |
4 | */ | |
5 | ||
6 | /* @(#) $Id$ */ | |
7 | ||
8 | #include "zutil.h" | |
7c8257d9 CBW |
9 | #ifndef Z_SOLO |
10 | # include "gzguts.h" | |
11 | #endif | |
25f0751f | 12 | |
1cae2293 | 13 | z_const char * const z_errmsg[10] = { |
6b93e4bc PM |
14 | (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */ |
15 | (z_const char *)"stream end", /* Z_STREAM_END 1 */ | |
16 | (z_const char *)"", /* Z_OK 0 */ | |
17 | (z_const char *)"file error", /* Z_ERRNO (-1) */ | |
18 | (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */ | |
19 | (z_const char *)"data error", /* Z_DATA_ERROR (-3) */ | |
20 | (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ | |
21 | (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */ | |
22 | (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ | |
23 | (z_const char *)"" | |
24 | }; | |
25f0751f PM |
25 | |
26 | ||
27 | const char * ZEXPORT zlibVersion() | |
28 | { | |
29 | return ZLIB_VERSION; | |
30 | } | |
31 | ||
32 | uLong ZEXPORT zlibCompileFlags() | |
33 | { | |
34 | uLong flags; | |
35 | ||
36 | flags = 0; | |
f02c02ec | 37 | switch ((int)(sizeof(uInt))) { |
25f0751f PM |
38 | case 2: break; |
39 | case 4: flags += 1; break; | |
40 | case 8: flags += 2; break; | |
41 | default: flags += 3; | |
42 | } | |
f02c02ec | 43 | switch ((int)(sizeof(uLong))) { |
25f0751f PM |
44 | case 2: break; |
45 | case 4: flags += 1 << 2; break; | |
46 | case 8: flags += 2 << 2; break; | |
47 | default: flags += 3 << 2; | |
48 | } | |
f02c02ec | 49 | switch ((int)(sizeof(voidpf))) { |
25f0751f PM |
50 | case 2: break; |
51 | case 4: flags += 1 << 4; break; | |
52 | case 8: flags += 2 << 4; break; | |
53 | default: flags += 3 << 4; | |
54 | } | |
f02c02ec | 55 | switch ((int)(sizeof(z_off_t))) { |
25f0751f PM |
56 | case 2: break; |
57 | case 4: flags += 1 << 6; break; | |
58 | case 8: flags += 2 << 6; break; | |
59 | default: flags += 3 << 6; | |
60 | } | |
6b93e4bc | 61 | #ifdef ZLIB_DEBUG |
25f0751f PM |
62 | flags += 1 << 8; |
63 | #endif | |
a98bbd4e | 64 | /* |
25f0751f PM |
65 | #if defined(ASMV) || defined(ASMINF) |
66 | flags += 1 << 9; | |
67 | #endif | |
a98bbd4e | 68 | */ |
25f0751f PM |
69 | #ifdef ZLIB_WINAPI |
70 | flags += 1 << 10; | |
71 | #endif | |
72 | #ifdef BUILDFIXED | |
73 | flags += 1 << 12; | |
74 | #endif | |
75 | #ifdef DYNAMIC_CRC_TABLE | |
76 | flags += 1 << 13; | |
77 | #endif | |
78 | #ifdef NO_GZCOMPRESS | |
79 | flags += 1L << 16; | |
80 | #endif | |
81 | #ifdef NO_GZIP | |
82 | flags += 1L << 17; | |
83 | #endif | |
84 | #ifdef PKZIP_BUG_WORKAROUND | |
85 | flags += 1L << 20; | |
86 | #endif | |
87 | #ifdef FASTEST | |
88 | flags += 1L << 21; | |
89 | #endif | |
7c8257d9 | 90 | #if defined(STDC) || defined(Z_HAVE_STDARG_H) |
30faa565 | 91 | # ifdef NO_vsnprintf |
7c8257d9 | 92 | flags += 1L << 25; |
30faa565 | 93 | # ifdef HAS_vsprintf_void |
7c8257d9 | 94 | flags += 1L << 26; |
30faa565 RS |
95 | # endif |
96 | # else | |
97 | # ifdef HAS_vsnprintf_void | |
7c8257d9 | 98 | flags += 1L << 26; |
30faa565 RS |
99 | # endif |
100 | # endif | |
25f0751f | 101 | #else |
7c8257d9 | 102 | flags += 1L << 24; |
30faa565 | 103 | # ifdef NO_snprintf |
7c8257d9 | 104 | flags += 1L << 25; |
30faa565 | 105 | # ifdef HAS_sprintf_void |
7c8257d9 | 106 | flags += 1L << 26; |
30faa565 RS |
107 | # endif |
108 | # else | |
109 | # ifdef HAS_snprintf_void | |
7c8257d9 | 110 | flags += 1L << 26; |
30faa565 RS |
111 | # endif |
112 | # endif | |
25f0751f | 113 | #endif |
30faa565 | 114 | return flags; |
25f0751f PM |
115 | } |
116 | ||
6b93e4bc PM |
117 | #ifdef ZLIB_DEBUG |
118 | #include <stdlib.h> | |
25f0751f PM |
119 | # ifndef verbose |
120 | # define verbose 0 | |
121 | # endif | |
f02c02ec | 122 | int ZLIB_INTERNAL z_verbose = verbose; |
25f0751f | 123 | |
a7026383 CBW |
124 | void ZLIB_INTERNAL z_error ( |
125 | char *m) | |
25f0751f PM |
126 | { |
127 | fprintf(stderr, "%s\n", m); | |
128 | exit(1); | |
129 | } | |
130 | #endif | |
131 | ||
132 | /* exported to allow conversion of error code to string for compress() and | |
133 | * uncompress() | |
134 | */ | |
a7026383 CBW |
135 | const char * ZEXPORT zError( |
136 | int err) | |
25f0751f PM |
137 | { |
138 | return ERR_MSG(err); | |
139 | } | |
140 | ||
b864a746 PM |
141 | #if defined(_WIN32_WCE) && _WIN32_WCE < 0x800 |
142 | /* The older Microsoft C Run-Time Library for Windows CE doesn't have | |
25f0751f PM |
143 | * errno. We define it as a global variable to simplify porting. |
144 | * Its value is always 0 and should not be used. | |
145 | */ | |
146 | int errno = 0; | |
147 | #endif | |
148 | ||
149 | #ifndef HAVE_MEMCPY | |
150 | ||
a7026383 CBW |
151 | void ZLIB_INTERNAL zmemcpy( |
152 | Bytef* dest, | |
153 | const Bytef* source, | |
154 | uInt len) | |
25f0751f PM |
155 | { |
156 | if (len == 0) return; | |
157 | do { | |
158 | *dest++ = *source++; /* ??? to be unrolled */ | |
159 | } while (--len != 0); | |
160 | } | |
161 | ||
a7026383 CBW |
162 | int ZLIB_INTERNAL zmemcmp( |
163 | const Bytef* s1, | |
164 | const Bytef* s2, | |
165 | uInt len) | |
25f0751f PM |
166 | { |
167 | uInt j; | |
168 | ||
169 | for (j = 0; j < len; j++) { | |
170 | if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; | |
171 | } | |
172 | return 0; | |
173 | } | |
174 | ||
a7026383 CBW |
175 | void ZLIB_INTERNAL zmemzero( |
176 | Bytef* dest, | |
177 | uInt len) | |
25f0751f PM |
178 | { |
179 | if (len == 0) return; | |
180 | do { | |
181 | *dest++ = 0; /* ??? to be unrolled */ | |
182 | } while (--len != 0); | |
183 | } | |
184 | #endif | |
185 | ||
7c8257d9 | 186 | #ifndef Z_SOLO |
25f0751f PM |
187 | |
188 | #ifdef SYS16BIT | |
189 | ||
190 | #ifdef __TURBOC__ | |
191 | /* Turbo C in 16-bit mode */ | |
192 | ||
193 | # define MY_ZCALLOC | |
194 | ||
195 | /* Turbo C malloc() does not allow dynamic allocation of 64K bytes | |
196 | * and farmalloc(64K) returns a pointer with an offset of 8, so we | |
197 | * must fix the pointer. Warning: the pointer must be put back to its | |
198 | * original form in order to free it, use zcfree(). | |
199 | */ | |
200 | ||
201 | #define MAX_PTR 10 | |
202 | /* 10*64K = 640K */ | |
203 | ||
204 | local int next_ptr = 0; | |
205 | ||
206 | typedef struct ptr_table_s { | |
207 | voidpf org_ptr; | |
208 | voidpf new_ptr; | |
209 | } ptr_table; | |
210 | ||
211 | local ptr_table table[MAX_PTR]; | |
212 | /* This table is used to remember the original form of pointers | |
213 | * to large buffers (64K). Such pointers are normalized with a zero offset. | |
214 | * Since MSDOS is not a preemptive multitasking OS, this table is not | |
215 | * protected from concurrent access. This hack doesn't work anyway on | |
216 | * a protected system like OS/2. Use Microsoft C instead. | |
217 | */ | |
218 | ||
a98bbd4e | 219 | voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) |
25f0751f | 220 | { |
6b93e4bc | 221 | voidpf buf; |
25f0751f PM |
222 | ulg bsize = (ulg)items*size; |
223 | ||
6b93e4bc PM |
224 | (void)opaque; |
225 | ||
25f0751f PM |
226 | /* If we allocate less than 65520 bytes, we assume that farmalloc |
227 | * will return a usable pointer which doesn't have to be normalized. | |
228 | */ | |
229 | if (bsize < 65520L) { | |
230 | buf = farmalloc(bsize); | |
231 | if (*(ush*)&buf != 0) return buf; | |
232 | } else { | |
233 | buf = farmalloc(bsize + 16L); | |
234 | } | |
235 | if (buf == NULL || next_ptr >= MAX_PTR) return NULL; | |
236 | table[next_ptr].org_ptr = buf; | |
237 | ||
238 | /* Normalize the pointer to seg:0 */ | |
239 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; | |
240 | *(ush*)&buf = 0; | |
241 | table[next_ptr++].new_ptr = buf; | |
242 | return buf; | |
243 | } | |
244 | ||
a98bbd4e | 245 | void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) |
25f0751f PM |
246 | { |
247 | int n; | |
6b93e4bc PM |
248 | |
249 | (void)opaque; | |
250 | ||
25f0751f PM |
251 | if (*(ush*)&ptr != 0) { /* object < 64K */ |
252 | farfree(ptr); | |
253 | return; | |
254 | } | |
255 | /* Find the original pointer */ | |
256 | for (n = 0; n < next_ptr; n++) { | |
257 | if (ptr != table[n].new_ptr) continue; | |
258 | ||
259 | farfree(table[n].org_ptr); | |
260 | while (++n < next_ptr) { | |
261 | table[n-1] = table[n]; | |
262 | } | |
263 | next_ptr--; | |
264 | return; | |
265 | } | |
25f0751f PM |
266 | Assert(0, "zcfree: ptr not found"); |
267 | } | |
268 | ||
269 | #endif /* __TURBOC__ */ | |
270 | ||
271 | ||
272 | #ifdef M_I86 | |
273 | /* Microsoft C in 16-bit mode */ | |
274 | ||
275 | # define MY_ZCALLOC | |
276 | ||
277 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600)) | |
278 | # define _halloc halloc | |
279 | # define _hfree hfree | |
280 | #endif | |
281 | ||
a98bbd4e | 282 | voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uInt items, uInt size) |
25f0751f | 283 | { |
6b93e4bc | 284 | (void)opaque; |
25f0751f PM |
285 | return _halloc((long)items, size); |
286 | } | |
287 | ||
a98bbd4e | 288 | void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) |
25f0751f | 289 | { |
6b93e4bc | 290 | (void)opaque; |
25f0751f PM |
291 | _hfree(ptr); |
292 | } | |
293 | ||
294 | #endif /* M_I86 */ | |
295 | ||
296 | #endif /* SYS16BIT */ | |
297 | ||
298 | ||
299 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */ | |
300 | ||
301 | #ifndef STDC | |
302 | extern voidp malloc OF((uInt size)); | |
303 | extern voidp calloc OF((uInt items, uInt size)); | |
304 | extern void free OF((voidpf ptr)); | |
305 | #endif | |
306 | ||
a7026383 CBW |
307 | voidpf ZLIB_INTERNAL zcalloc ( |
308 | voidpf opaque, | |
309 | unsigned items, | |
310 | unsigned size) | |
25f0751f | 311 | { |
6b93e4bc | 312 | (void)opaque; |
25f0751f PM |
313 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : |
314 | (voidpf)calloc(items, size); | |
315 | } | |
316 | ||
a7026383 CBW |
317 | void ZLIB_INTERNAL zcfree ( |
318 | voidpf opaque, | |
319 | voidpf ptr) | |
25f0751f | 320 | { |
6b93e4bc | 321 | (void)opaque; |
25f0751f | 322 | free(ptr); |
25f0751f PM |
323 | } |
324 | ||
325 | #endif /* MY_ZCALLOC */ | |
7c8257d9 CBW |
326 | |
327 | #endif /* !Z_SOLO */ |