Line data Source code
1 : /* zutil.c -- target dependent utility functions for the compression library
2 : * Copyright (C) 1995-2017 Jean-loup Gailly
3 : * For conditions of distribution and use, see copyright notice in zlib.h
4 : */
5 :
6 : /* @(#) $Id$ */
7 :
8 : #include "zutil.h"
9 : #ifndef Z_SOLO
10 : # include "gzguts.h"
11 : #endif
12 :
13 : z_const char * const z_errmsg[10] = {
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 : };
25 :
26 :
27 0 : const char * ZEXPORT zlibVersion()
28 : {
29 0 : return ZLIB_VERSION;
30 : }
31 :
32 0 : uLong ZEXPORT zlibCompileFlags()
33 : {
34 : uLong flags;
35 :
36 0 : flags = 0;
37 : switch ((int)(sizeof(uInt))) {
38 : case 2: break;
39 0 : case 4: flags += 1; break;
40 : case 8: flags += 2; break;
41 : default: flags += 3;
42 : }
43 : switch ((int)(sizeof(uLong))) {
44 : case 2: break;
45 : case 4: flags += 1 << 2; break;
46 0 : case 8: flags += 2 << 2; break;
47 : default: flags += 3 << 2;
48 : }
49 : switch ((int)(sizeof(voidpf))) {
50 : case 2: break;
51 : case 4: flags += 1 << 4; break;
52 0 : case 8: flags += 2 << 4; break;
53 : default: flags += 3 << 4;
54 : }
55 : switch ((int)(sizeof(z_off_t))) {
56 : case 2: break;
57 : case 4: flags += 1 << 6; break;
58 0 : case 8: flags += 2 << 6; break;
59 : default: flags += 3 << 6;
60 : }
61 : #ifdef ZLIB_DEBUG
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
77 : flags += 1L << 16;
78 : #endif
79 : #ifdef NO_GZIP
80 : flags += 1L << 17;
81 : #endif
82 : #ifdef PKZIP_BUG_WORKAROUND
83 : flags += 1L << 20;
84 : #endif
85 : #ifdef FASTEST
86 : flags += 1L << 21;
87 : #endif
88 : #if defined(STDC) || defined(Z_HAVE_STDARG_H)
89 : # ifdef NO_vsnprintf
90 : flags += 1L << 25;
91 : # ifdef HAS_vsprintf_void
92 : flags += 1L << 26;
93 : # endif
94 : # else
95 : # ifdef HAS_vsnprintf_void
96 : flags += 1L << 26;
97 : # endif
98 : # endif
99 : #else
100 : flags += 1L << 24;
101 : # ifdef NO_snprintf
102 : flags += 1L << 25;
103 : # ifdef HAS_sprintf_void
104 : flags += 1L << 26;
105 : # endif
106 : # else
107 : # ifdef HAS_snprintf_void
108 : flags += 1L << 26;
109 : # endif
110 : # endif
111 : #endif
112 0 : return flags;
113 : }
114 :
115 : #ifdef ZLIB_DEBUG
116 : #include <stdlib.h>
117 : # ifndef verbose
118 : # define verbose 0
119 : # endif
120 : int ZLIB_INTERNAL z_verbose = verbose;
121 :
122 : void ZLIB_INTERNAL z_error (m)
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 0 : const char * ZEXPORT zError(err)
134 : int err;
135 : {
136 0 : return ERR_MSG(err);
137 : }
138 :
139 : #if defined(_WIN32_WCE)
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 : */
144 : int errno = 0;
145 : #endif
146 :
147 : #ifndef HAVE_MEMCPY
148 :
149 : void ZLIB_INTERNAL zmemcpy(dest, source, len)
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 :
160 : int ZLIB_INTERNAL zmemcmp(s1, s2, len)
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 :
173 : void ZLIB_INTERNAL zmemzero(dest, len)
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 :
184 : #ifndef Z_SOLO
185 :
186 : #ifdef SYS16BIT
187 :
188 : #ifdef __TURBOC__
189 : /* Turbo C in 16-bit mode */
190 :
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 :
217 : voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
218 : {
219 : voidpf buf;
220 : ulg bsize = (ulg)items*size;
221 :
222 : (void)opaque;
223 :
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 :
243 : void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
244 : {
245 : int n;
246 :
247 : (void)opaque;
248 :
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 : }
264 : Assert(0, "zcfree: ptr not found");
265 : }
266 :
267 : #endif /* __TURBOC__ */
268 :
269 :
270 : #ifdef M_I86
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 :
280 : voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
281 : {
282 : (void)opaque;
283 : return _halloc((long)items, size);
284 : }
285 :
286 : void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
287 : {
288 : (void)opaque;
289 : _hfree(ptr);
290 : }
291 :
292 : #endif /* M_I86 */
293 :
294 : #endif /* SYS16BIT */
295 :
296 :
297 : #ifndef MY_ZCALLOC /* Any system without a special alloc function */
298 :
299 : #ifndef STDC
300 : extern voidp malloc OF((uInt size));
301 : extern voidp calloc OF((uInt items, uInt size));
302 : extern void free OF((voidpf ptr));
303 : #endif
304 :
305 632 : voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
306 : voidpf opaque;
307 : unsigned items;
308 : unsigned size;
309 : {
310 : (void)opaque;
311 632 : return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
312 : (voidpf)calloc(items, size);
313 : }
314 :
315 632 : void ZLIB_INTERNAL zcfree (opaque, ptr)
316 : voidpf opaque;
317 : voidpf ptr;
318 : {
319 : (void)opaque;
320 632 : free(ptr);
321 632 : }
322 :
323 : #endif /* MY_ZCALLOC */
324 :
325 : #endif /* !Z_SOLO */
|
