Line data Source code
1 : /* $OpenBSD: zutil.c,v 1.2 2011/07/16 07:25:29 jsing Exp $ */
2 : /* zutil.c -- target dependent utility functions for the compression library
3 : * Copyright (C) 1995-2005 Jean-loup Gailly.
4 : * For conditions of distribution and use, see copyright notice in zlib.h
5 : */
6 :
7 :
8 : #include "zutil.h"
9 :
10 : #ifndef NO_DUMMY_DECL
11 : struct internal_state {int dummy;}; /* for buggy compilers */
12 : #endif
13 :
14 : const char * const z_errmsg[10] = {
15 : "need dictionary", /* Z_NEED_DICT 2 */
16 : "stream end", /* Z_STREAM_END 1 */
17 : "", /* Z_OK 0 */
18 : "file error", /* Z_ERRNO (-1) */
19 : "stream error", /* Z_STREAM_ERROR (-2) */
20 : "data error", /* Z_DATA_ERROR (-3) */
21 : "insufficient memory", /* Z_MEM_ERROR (-4) */
22 : "buffer error", /* Z_BUF_ERROR (-5) */
23 : "incompatible version",/* Z_VERSION_ERROR (-6) */
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 : flags = 0;
37 : switch (sizeof(uInt)) {
38 : case 2: break;
39 : case 4: flags += 1; break;
40 : case 8: flags += 2; break;
41 : default: flags += 3;
42 : }
43 : switch (sizeof(uLong)) {
44 : case 2: break;
45 : case 4: flags += 1 << 2; break;
46 : case 8: flags += 2 << 2; break;
47 : default: flags += 3 << 2;
48 : }
49 : switch (sizeof(voidpf)) {
50 : case 2: break;
51 : case 4: flags += 1 << 4; break;
52 : case 8: flags += 2 << 4; break;
53 : default: flags += 3 << 4;
54 : }
55 : switch (sizeof(z_off_t)) {
56 : case 2: break;
57 : case 4: flags += 1 << 6; break;
58 : case 8: flags += 2 << 6; break;
59 : default: flags += 3 << 6;
60 : }
61 : #ifdef DEBUG_LIBZ
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 : #ifdef STDC
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 DEBUG_LIBZ
116 :
117 : # ifndef verbose
118 : # define verbose 0
119 : # endif
120 : int z_verbose = verbose;
121 :
122 : void 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 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 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 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 :
185 : #ifdef SYS16BIT
186 :
187 : #ifdef __TURBOC__
188 : /* Turbo C in 16-bit mode */
189 :
190 : # define MY_ZCALLOC
191 :
192 : /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
193 : * and farmalloc(64K) returns a pointer with an offset of 8, so we
194 : * must fix the pointer. Warning: the pointer must be put back to its
195 : * original form in order to free it, use zcfree().
196 : */
197 :
198 : #define MAX_PTR 10
199 : /* 10*64K = 640K */
200 :
201 : local int next_ptr = 0;
202 :
203 : typedef struct ptr_table_s {
204 : voidpf org_ptr;
205 : voidpf new_ptr;
206 : } ptr_table;
207 :
208 : local ptr_table table[MAX_PTR];
209 : /* This table is used to remember the original form of pointers
210 : * to large buffers (64K). Such pointers are normalized with a zero offset.
211 : * Since MSDOS is not a preemptive multitasking OS, this table is not
212 : * protected from concurrent access. This hack doesn't work anyway on
213 : * a protected system like OS/2. Use Microsoft C instead.
214 : */
215 :
216 : voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
217 : {
218 : voidpf buf = opaque; /* just to make some compilers happy */
219 : ulg bsize = (ulg)items*size;
220 :
221 : /* If we allocate less than 65520 bytes, we assume that farmalloc
222 : * will return a usable pointer which doesn't have to be normalized.
223 : */
224 : if (bsize < 65520L) {
225 : buf = farmalloc(bsize);
226 : if (*(ush*)&buf != 0) return buf;
227 : } else {
228 : buf = farmalloc(bsize + 16L);
229 : }
230 : if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
231 : table[next_ptr].org_ptr = buf;
232 :
233 : /* Normalize the pointer to seg:0 */
234 : *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
235 : *(ush*)&buf = 0;
236 : table[next_ptr++].new_ptr = buf;
237 : return buf;
238 : }
239 :
240 : void zcfree (voidpf opaque, voidpf ptr)
241 : {
242 : int n;
243 : if (*(ush*)&ptr != 0) { /* object < 64K */
244 : farfree(ptr);
245 : return;
246 : }
247 : /* Find the original pointer */
248 : for (n = 0; n < next_ptr; n++) {
249 : if (ptr != table[n].new_ptr) continue;
250 :
251 : farfree(table[n].org_ptr);
252 : while (++n < next_ptr) {
253 : table[n-1] = table[n];
254 : }
255 : next_ptr--;
256 : return;
257 : }
258 : ptr = opaque; /* just to make some compilers happy */
259 : Assert(0, "zcfree: ptr not found");
260 : }
261 :
262 : #endif /* __TURBOC__ */
263 :
264 :
265 : #ifdef M_I86
266 : /* Microsoft C in 16-bit mode */
267 :
268 : # define MY_ZCALLOC
269 :
270 : #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
271 : # define _halloc halloc
272 : # define _hfree hfree
273 : #endif
274 :
275 : voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
276 : {
277 : if (opaque) opaque = 0; /* to make compiler happy */
278 : return _halloc((long)items, size);
279 : }
280 :
281 : void zcfree (voidpf opaque, voidpf ptr)
282 : {
283 : if (opaque) opaque = 0; /* to make compiler happy */
284 : _hfree(ptr);
285 : }
286 :
287 : #endif /* M_I86 */
288 :
289 : #endif /* SYS16BIT */
290 :
291 :
292 : #ifndef MY_ZCALLOC /* Any system without a special alloc function */
293 :
294 : #ifndef STDC
295 : extern voidp malloc OF((uInt size));
296 : extern voidp calloc OF((uInt items, uInt size));
297 : extern void free OF((voidpf ptr));
298 : #endif
299 :
300 : voidpf zcalloc (opaque, items, size)
301 : voidpf opaque;
302 : unsigned items;
303 : unsigned size;
304 : {
305 : if (opaque) items += size - size; /* make compiler happy */
306 : if (items * size == 0)
307 : return (NULL);
308 : return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
309 : (voidpf)calloc(items, size);
310 : }
311 :
312 : void zcfree (opaque, ptr)
313 : voidpf opaque;
314 : voidpf ptr;
315 : {
316 : free(ptr);
317 : if (opaque) return; /* make compiler happy */
318 : }
319 :
320 : #endif /* MY_ZCALLOC */
|
