diff options
author | Maurus Cuelenaere <mcuelenaere@gmail.com> | 2008-07-11 15:50:46 +0000 |
---|---|---|
committer | Maurus Cuelenaere <mcuelenaere@gmail.com> | 2008-07-11 15:50:46 +0000 |
commit | 14c7f45cdae826f88dc539c8c38dd95caf305731 (patch) | |
tree | 832da054b7cfb2dc6fd63339af736625f31d21aa /utils/zenutils/libraries/zlib123/zlib/zutil.c | |
parent | 7c84ede3781c27db73403bd6302f320c76a58c8c (diff) | |
download | rockbox-14c7f45cdae826f88dc539c8c38dd95caf305731.tar.gz rockbox-14c7f45cdae826f88dc539c8c38dd95caf305731.zip |
Add zook's ZenUtils to SVN
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@18010 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'utils/zenutils/libraries/zlib123/zlib/zutil.c')
-rwxr-xr-x | utils/zenutils/libraries/zlib123/zlib/zutil.c | 318 |
1 files changed, 318 insertions, 0 deletions
diff --git a/utils/zenutils/libraries/zlib123/zlib/zutil.c b/utils/zenutils/libraries/zlib123/zlib/zutil.c new file mode 100755 index 0000000000..0f4bd7871d --- /dev/null +++ b/utils/zenutils/libraries/zlib123/zlib/zutil.c | |||
@@ -0,0 +1,318 @@ | |||
1 | /* zutil.c -- target dependent utility functions for the compression library | ||
2 | * Copyright (C) 1995-2005 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 | |||
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 | const char * ZEXPORT zlibVersion() | ||
28 | { | ||
29 | return ZLIB_VERSION; | ||
30 | } | ||
31 | |||
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 | ||
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 | return flags; | ||
113 | } | ||
114 | |||
115 | #ifdef DEBUG | ||
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 | |||
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 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : | ||
307 | (voidpf)calloc(items, size); | ||
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 */ | ||