Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  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.