[331] | 1 | /* zutil.c -- target dependent utility functions for the compression library
|
---|
| 2 | * Copyright (C) 1995-2017 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 | z_const char * const z_errmsg[10] = {
|
---|
| 14 | (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
|
---|
| 15 | (z_const char *)"stream end", /* Z_STREAM_END 1 */
|
---|
| 16 | (z_const char *)"", /* Z_OK 0 */
|
---|
| 17 | (z_const char *)"file error", /* Z_ERRNO (-1) */
|
---|
| 18 | (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
|
---|
| 19 | (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
|
---|
| 20 | (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
|
---|
| 21 | (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
|
---|
| 22 | (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
|
---|
| 23 | (z_const char *)""
|
---|
| 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 ((int)(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 ((int)(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 ((int)(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 ((int)(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 ZLIB_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 | #if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
---|
| 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 ZLIB_DEBUG
|
---|
| 116 | #include <stdlib.h>
|
---|
| 117 | # ifndef verbose
|
---|
| 118 | # define verbose 0
|
---|
| 119 | # endif
|
---|
| 120 | int ZLIB_INTERNAL z_verbose = verbose;
|
---|
| 121 |
|
---|
| 122 | void ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 | #ifndef Z_SOLO
|
---|
| 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 ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
---|
| 218 | {
|
---|
| 219 | voidpf buf;
|
---|
| 220 | ulg bsize = (ulg)items*size;
|
---|
| 221 |
|
---|
| 222 | (void)opaque;
|
---|
| 223 |
|
---|
| 224 | /* If we allocate less than 65520 bytes, we assume that farmalloc
|
---|
| 225 | * will return a usable pointer which doesn't have to be normalized.
|
---|
| 226 | */
|
---|
| 227 | if (bsize < 65520L) {
|
---|
| 228 | buf = farmalloc(bsize);
|
---|
| 229 | if (*(ush*)&buf != 0) return buf;
|
---|
| 230 | } else {
|
---|
| 231 | buf = farmalloc(bsize + 16L);
|
---|
| 232 | }
|
---|
| 233 | if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
|
---|
| 234 | table[next_ptr].org_ptr = buf;
|
---|
| 235 |
|
---|
| 236 | /* Normalize the pointer to seg:0 */
|
---|
| 237 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
|
---|
| 238 | *(ush*)&buf = 0;
|
---|
| 239 | table[next_ptr++].new_ptr = buf;
|
---|
| 240 | return buf;
|
---|
| 241 | }
|
---|
| 242 |
|
---|
| 243 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
---|
| 244 | {
|
---|
| 245 | int n;
|
---|
| 246 |
|
---|
| 247 | (void)opaque;
|
---|
| 248 |
|
---|
| 249 | if (*(ush*)&ptr != 0) { /* object < 64K */
|
---|
| 250 | farfree(ptr);
|
---|
| 251 | return;
|
---|
| 252 | }
|
---|
| 253 | /* Find the original pointer */
|
---|
| 254 | for (n = 0; n < next_ptr; n++) {
|
---|
| 255 | if (ptr != table[n].new_ptr) continue;
|
---|
| 256 |
|
---|
| 257 | farfree(table[n].org_ptr);
|
---|
| 258 | while (++n < next_ptr) {
|
---|
| 259 | table[n-1] = table[n];
|
---|
| 260 | }
|
---|
| 261 | next_ptr--;
|
---|
| 262 | return;
|
---|
| 263 | }
|
---|
| 264 | Assert(0, "zcfree: ptr not found");
|
---|
| 265 | }
|
---|
| 266 |
|
---|
| 267 | #endif /* __TURBOC__ */
|
---|
| 268 |
|
---|
| 269 |
|
---|
| 270 | #ifdef M_I86
|
---|
| 271 | /* Microsoft C in 16-bit mode */
|
---|
| 272 |
|
---|
| 273 | # define MY_ZCALLOC
|
---|
| 274 |
|
---|
| 275 | #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
|
---|
| 276 | # define _halloc halloc
|
---|
| 277 | # define _hfree hfree
|
---|
| 278 | #endif
|
---|
| 279 |
|
---|
| 280 | voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
|
---|
| 281 | {
|
---|
| 282 | (void)opaque;
|
---|
| 283 | return _halloc((long)items, size);
|
---|
| 284 | }
|
---|
| 285 |
|
---|
| 286 | void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
---|
| 287 | {
|
---|
| 288 | (void)opaque;
|
---|
| 289 | _hfree(ptr);
|
---|
| 290 | }
|
---|
| 291 |
|
---|
| 292 | #endif /* M_I86 */
|
---|
| 293 |
|
---|
| 294 | #endif /* SYS16BIT */
|
---|
| 295 |
|
---|
| 296 |
|
---|
| 297 | #ifndef MY_ZCALLOC /* Any system without a special alloc function */
|
---|
| 298 |
|
---|
| 299 | #ifndef STDC
|
---|
| 300 | extern voidp malloc OF((uInt size));
|
---|
| 301 | extern voidp calloc OF((uInt items, uInt size));
|
---|
| 302 | extern void free OF((voidpf ptr));
|
---|
| 303 | #endif
|
---|
| 304 |
|
---|
| 305 | voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
|
---|
| 306 | voidpf opaque;
|
---|
| 307 | unsigned items;
|
---|
| 308 | unsigned size;
|
---|
| 309 | {
|
---|
| 310 | (void)opaque;
|
---|
| 311 | return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
|
---|
| 312 | (voidpf)calloc(items, size);
|
---|
| 313 | }
|
---|
| 314 |
|
---|
| 315 | void ZLIB_INTERNAL zcfree (opaque, ptr)
|
---|
| 316 | voidpf opaque;
|
---|
| 317 | voidpf ptr;
|
---|
| 318 | {
|
---|
| 319 | (void)opaque;
|
---|
| 320 | free(ptr);
|
---|
| 321 | }
|
---|
| 322 |
|
---|
| 323 | #endif /* MY_ZCALLOC */
|
---|
| 324 |
|
---|
| 325 | #endif /* !Z_SOLO */
|
---|