Home | History | Annotate | Download | only in gzip 
      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 */
    182