src/gzip/zutil.c

   1 /* zutil.c -- target dependent utility functions for the compression library
   2  * Copyright (C) 1995-2002 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 STDC
  11 extern void exit OF((int));
  12 #endif
  13
  14
  15 #ifndef HAVE_MEMCPY
  16
  17 void zmemcpy(dest, source, len)
  18     Bytef* dest;
  19     const Bytef* source;
  20     uInt  len;
  21 {
  22     if (len == 0) return;
  23     do {
  24         *dest++ = *source++; /* ??? to be unrolled */
  25     } while (--len != 0);
  26 }
  27
  28 int zmemcmp(s1, s2, len)
  29     const Bytef* s1;
  30     const Bytef* s2;
  31     uInt  len;
  32 {
  33     uInt j;
  34
  35     for (j = 0; j < len; j++) {
  36         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
  37     }
  38     return 0;
  39 }
  40
  41 void zmemzero(dest, len)
  42     Bytef* dest;
  43     uInt  len;
  44 {
  45     if (len == 0) return;
  46     do {
  47         *dest++ = 0;  /* ??? to be unrolled */
  48     } while (--len != 0);
  49 }
  50 #endif
  51
  52 #if defined( MSDOS ) && defined( __TURBOC__ ) && !defined( MY_ZCALLOC )
  53 #if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__)
  54 /* Small and medium model in Turbo C are for now limited to near allocation
  55  * with reduced MAX_WBITS and MAX_MEM_LEVEL
  56  */
  57 #  define MY_ZCALLOC
  58
  59 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
  60  * and farmalloc(64K) returns a pointer with an offset of 8, so we
  61  * must fix the pointer. Warning: the pointer must be put back to its
  62  * original form in order to free it, use zcfree().
  63  */
  64
  65 #define MAX_PTR 10
  66 /* 10*64K = 640K */
  67
  68 local int next_ptr = 0;
  69
  70 typedef struct ptr_table_s {
  71     voidpf org_ptr;
  72     voidpf new_ptr;
  73 } ptr_table;
  74
  75 local ptr_table table[MAX_PTR];
  76 /* This table is used to remember the original form of pointers
  77  * to large buffers (64K). Such pointers are normalized with a zero offset.
  78  * Since MSDOS is not a preemptive multitasking OS, this table is not
  79  * protected from concurrent access. This hack doesn't work anyway on
  80  * a protected system like OS/2. Use Microsoft C instead.
  81  */
  82
  83 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
  84 {
  85     voidpf buf = opaque; /* just to make some compilers happy */
  86     ulg bsize = (ulg)items*size;
  87
  88     /* If we allocate less than 65520 bytes, we assume that farmalloc
  89      * will return a usable pointer which doesn't have to be normalized.
  90      */
  91     if (bsize < 65520L) {
  92         buf = farmalloc(bsize);
  93         if (*(ush*)&buf != 0) return buf;
  94     } else {
  95         buf = farmalloc(bsize + 16L);
  96     }
  97     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
  98     table[next_ptr].org_ptr = buf;
  99
 100     /* Normalize the pointer to seg:0 */
 101     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
 102     *(ush*)&buf = 0;
 103     table[next_ptr++].new_ptr = buf;
 104     return buf;
 105 }
 106
 107 void  zcfree (voidpf opaque, voidpf ptr)
 108 {
 109     int n;
 110     if (*(ush*)&ptr != 0) { /* object < 64K */
 111         farfree(ptr);
 112         return;
 113     }
 114     /* Find the original pointer */
 115     for (n = 0; n < next_ptr; n++) {
 116         if (ptr != table[n].new_ptr) continue;
 117
 118         farfree(table[n].org_ptr);
 119         while (++n < next_ptr) {
 120             table[n-1] = table[n];
 121         }
 122         next_ptr--;
 123         return;
 124     }
 125     ptr = opaque; /* just to make some compilers happy */
 126     Assert(0, "zcfree: ptr not found");
 127 }
 128 #endif
 129 #endif /* MSDOS && __TURBOC__ */
 130
 131
 132 #if defined(M_I86) && !defined(__32BIT__) && !defined( MY_ZCALLOC )
 133 /* Microsoft C in 16-bit mode */
 134
 135 #  define MY_ZCALLOC
 136
 137 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
 138 #  define _halloc  halloc
 139 #  define _hfree   hfree
 140 #endif
 141
 142 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
 143 {
 144     if (opaque) opaque = 0; /* to make compiler happy */
 145     return _halloc((long)items, size);
 146 }
 147
 148 void  zcfree (voidpf opaque, voidpf ptr)
 149 {
 150     if (opaque) opaque = 0; /* to make compiler happy */
 151     _hfree(ptr);
 152 }
 153
 154 #endif /* MSC */
 155
 156
 157 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
 158
 159 #ifndef STDC
 160 extern voidp  ft_scalloc OF((uInt items, uInt size));
 161 extern void   ft_sfree   OF((voidpf ptr));
 162 #endif
 163
 164 voidpf zcalloc (opaque, items, size)
 165     voidpf opaque;
 166     unsigned items;
 167     unsigned size;
 168 {
 169     if (opaque) items += size - size; /* make compiler happy */
 170     return (voidpf)ft_scalloc(items, size);
 171 }
 172
 173 void  zcfree (opaque, ptr)
 174     voidpf opaque;
 175     voidpf ptr;
 176 {
 177     ft_sfree(ptr);
 178     if (opaque) return; /* make compiler happy */
 179 }
 180
 181 #endif /* MY_ZCALLOC */