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