Commit | Line | Data |
---|---|---|
c801d85f | 1 | /* zutil.c -- target dependent utility functions for the compression library |
41faf807 | 2 | * Copyright (C) 1995-2005 Jean-loup Gailly. |
e6ebb514 | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
c801d85f KB |
4 | */ |
5 | ||
6 | /* @(#) $Id$ */ | |
7 | ||
8 | #include "zutil.h" | |
9 | ||
51dbdf87 | 10 | #ifndef NO_DUMMY_DECL |
c801d85f | 11 | struct internal_state {int dummy;}; /* for buggy compilers */ |
51dbdf87 | 12 | #endif |
c801d85f | 13 | |
51dbdf87 | 14 | const char * const z_errmsg[10] = { |
c801d85f KB |
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 | const char * ZEXPORT zlibVersion() | |
28 | { | |
29 | return ZLIB_VERSION; | |
30 | } | |
31 | ||
51dbdf87 VS |
32 | 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 | |
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 | |
41faf807 | 77 | flags += 1L << 16; |
51dbdf87 VS |
78 | #endif |
79 | #ifdef NO_GZIP | |
41faf807 | 80 | flags += 1L << 17; |
51dbdf87 VS |
81 | #endif |
82 | #ifdef PKZIP_BUG_WORKAROUND | |
41faf807 | 83 | flags += 1L << 20; |
51dbdf87 VS |
84 | #endif |
85 | #ifdef FASTEST | |
41faf807 | 86 | flags += 1L << 21; |
51dbdf87 VS |
87 | #endif |
88 | #ifdef STDC | |
89 | # ifdef NO_vsnprintf | |
41faf807 | 90 | flags += 1L << 25; |
51dbdf87 | 91 | # ifdef HAS_vsprintf_void |
41faf807 | 92 | flags += 1L << 26; |
51dbdf87 VS |
93 | # endif |
94 | # else | |
95 | # ifdef HAS_vsnprintf_void | |
41faf807 | 96 | flags += 1L << 26; |
51dbdf87 VS |
97 | # endif |
98 | # endif | |
99 | #else | |
41faf807 | 100 | flags += 1L << 24; |
51dbdf87 | 101 | # ifdef NO_snprintf |
41faf807 | 102 | flags += 1L << 25; |
51dbdf87 | 103 | # ifdef HAS_sprintf_void |
41faf807 | 104 | flags += 1L << 26; |
51dbdf87 VS |
105 | # endif |
106 | # else | |
107 | # ifdef HAS_snprintf_void | |
41faf807 | 108 | flags += 1L << 26; |
51dbdf87 VS |
109 | # endif |
110 | # endif | |
111 | #endif | |
112 | return flags; | |
113 | } | |
114 | ||
115 | #ifdef DEBUG | |
c801d85f KB |
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 | const char * ZEXPORT zError(err) | |
134 | int err; | |
135 | { | |
136 | return ERR_MSG(err); | |
137 | } | |
138 | ||
51dbdf87 | 139 | #if defined(_WIN32_WCE) |
41faf807 MW |
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 | */ | |
51dbdf87 VS |
144 | int errno = 0; |
145 | #endif | |
c801d85f KB |
146 | |
147 | #ifndef HAVE_MEMCPY | |
148 | ||
149 | void zmemcpy(dest, source, len) | |
150 | Bytef* dest; | |
51dbdf87 | 151 | const Bytef* source; |
c801d85f KB |
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) | |
51dbdf87 VS |
161 | const Bytef* s1; |
162 | const Bytef* s2; | |
c801d85f KB |
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 | ||
51dbdf87 VS |
184 | |
185 | #ifdef SYS16BIT | |
186 | ||
c801d85f | 187 | #ifdef __TURBOC__ |
51dbdf87 VS |
188 | /* Turbo C in 16-bit mode */ |
189 | ||
c801d85f KB |
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 | } | |
51dbdf87 | 261 | |
c801d85f KB |
262 | #endif /* __TURBOC__ */ |
263 | ||
264 | ||
51dbdf87 | 265 | #ifdef M_I86 |
c801d85f KB |
266 | /* Microsoft C in 16-bit mode */ |
267 | ||
268 | # define MY_ZCALLOC | |
269 | ||
51dbdf87 | 270 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600)) |
c801d85f KB |
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 | ||
51dbdf87 VS |
287 | #endif /* M_I86 */ |
288 | ||
289 | #endif /* SYS16BIT */ | |
c801d85f KB |
290 | |
291 | ||
292 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */ | |
293 | ||
294 | #ifndef STDC | |
51dbdf87 | 295 | extern voidp malloc OF((uInt size)); |
c801d85f KB |
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 */ | |
51dbdf87 VS |
306 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : |
307 | (voidpf)calloc(items, size); | |
c801d85f KB |
308 | } |
309 | ||
310 | void zcfree (opaque, ptr) | |
311 | voidpf opaque; | |
312 | voidpf ptr; | |
313 | { | |
314 | free(ptr); | |
315 | if (opaque) return; /* make compiler happy */ | |
316 | } | |
317 | ||
318 | #endif /* MY_ZCALLOC */ |