zutil.c
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:5k
源码类别:

生物技术

开发平台:

C/C++

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