Annotation of embedaddon/rsync/zlib/zutil.c, revision 1.1
1.1 ! misho 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; /* CONSTANT CONDITION */
! 39: case 4: flags += 1; break; /* CONSTANT CONDITION */
! 40: case 8: flags += 2; break; /* CONSTANT CONDITION */
! 41: default: flags += 3;
! 42: }
! 43: switch (sizeof(uLong)) {
! 44: case 2: break; /* CONSTANT CONDITION */
! 45: case 4: flags += 1 << 2; break; /* CONSTANT CONDITION */
! 46: case 8: flags += 2 << 2; break; /* CONSTANT CONDITION */
! 47: default: flags += 3 << 2;
! 48: }
! 49: switch (sizeof(voidpf)) {
! 50: case 2: break; /* CONSTANT CONDITION */
! 51: case 4: flags += 1 << 4; break; /* CONSTANT CONDITION */
! 52: case 8: flags += 2 << 4; break; /* CONSTANT CONDITION */
! 53: default: flags += 3 << 4;
! 54: }
! 55: switch (sizeof(z_off_t)) {
! 56: case 2: break; /* CONSTANT CONDITION */
! 57: case 4: flags += 1 << 6; break; /* CONSTANT CONDITION */
! 58: case 8: flags += 2 << 6; break; /* CONSTANT CONDITION */
! 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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zutil.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / zlib