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