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