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