/* zutil.c -- target dependent utility functions for the compression library
* Copyright (C) 1995-2017 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h
*/

/* @(#) Id */

#include "zutil.h"
#ifndef Z_SOLO
#  include "gzguts.h"
#endif

z_const char * const z_errmsg[10] = {
   (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
   (z_const char *)"stream end",          /* Z_STREAM_END      1  */
   (z_const char *)"",                    /* Z_OK              0  */
   (z_const char *)"file error",          /* Z_ERRNO         (-1) */
   (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
   (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
   (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
   (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
   (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
   (z_const char *)""
};


const char * ZEXPORT zlibVersion()
{
   return ZLIB_VERSION;
}

uLong ZEXPORT zlibCompileFlags()
{
   uLong flags;

   flags = 0;
   switch ((int)(sizeof(uInt))) {
   case 2:     break;
   case 4:     flags += 1;     break;
   case 8:     flags += 2;     break;
   default:    flags += 3;
   }
   switch ((int)(sizeof(uLong))) {
   case 2:     break;
   case 4:     flags += 1 << 2;        break;
   case 8:     flags += 2 << 2;        break;
   default:    flags += 3 << 2;
   }
   switch ((int)(sizeof(voidpf))) {
   case 2:     break;
   case 4:     flags += 1 << 4;        break;
   case 8:     flags += 2 << 4;        break;
   default:    flags += 3 << 4;
   }
   switch ((int)(sizeof(z_off_t))) {
   case 2:     break;
   case 4:     flags += 1 << 6;        break;
   case 8:     flags += 2 << 6;        break;
   default:    flags += 3 << 6;
   }
#ifdef ZLIB_DEBUG
   flags += 1 << 8;
#endif
#if defined(ASMV) || defined(ASMINF)
   flags += 1 << 9;
#endif
#ifdef ZLIB_WINAPI
   flags += 1 << 10;
#endif
#ifdef BUILDFIXED
   flags += 1 << 12;
#endif
#ifdef DYNAMIC_CRC_TABLE
   flags += 1 << 13;
#endif
#ifdef NO_GZCOMPRESS
   flags += 1L << 16;
#endif
#ifdef NO_GZIP
   flags += 1L << 17;
#endif
#ifdef PKZIP_BUG_WORKAROUND
   flags += 1L << 20;
#endif
#ifdef FASTEST
   flags += 1L << 21;
#endif
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
#  ifdef NO_vsnprintf
   flags += 1L << 25;
#    ifdef HAS_vsprintf_void
   flags += 1L << 26;
#    endif
#  else
#    ifdef HAS_vsnprintf_void
   flags += 1L << 26;
#    endif
#  endif
#else
   flags += 1L << 24;
#  ifdef NO_snprintf
   flags += 1L << 25;
#    ifdef HAS_sprintf_void
   flags += 1L << 26;
#    endif
#  else
#    ifdef HAS_snprintf_void
   flags += 1L << 26;
#    endif
#  endif
#endif
   return flags;
}

#ifdef ZLIB_DEBUG
#include <stdlib.h>
#  ifndef verbose
#    define verbose 0
#  endif
int ZLIB_INTERNAL z_verbose = verbose;

void ZLIB_INTERNAL z_error (m)
   char *m;
{
   fprintf(stderr, "%s\n", m);
   exit(1);
}
#endif

/* exported to allow conversion of error code to string for compress() and
* uncompress()
*/
const char * ZEXPORT zError(err)
   int err;
{
   return ERR_MSG(err);
}

#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
   /* The older Microsoft C Run-Time Library for Windows CE doesn't have
    * errno.  We define it as a global variable to simplify porting.
    * Its value is always 0 and should not be used.
    */
   int errno = 0;
#endif

#ifndef HAVE_MEMCPY

void ZLIB_INTERNAL zmemcpy(dest, source, len)
   Bytef* dest;
   const Bytef* source;
   uInt  len;
{
   if (len == 0) return;
   do {
       *dest++ = *source++; /* ??? to be unrolled */
   } while (--len != 0);
}

int ZLIB_INTERNAL zmemcmp(s1, s2, len)
   const Bytef* s1;
   const Bytef* s2;
   uInt  len;
{
   uInt j;

   for (j = 0; j < len; j++) {
       if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
   }
   return 0;
}

void ZLIB_INTERNAL zmemzero(dest, len)
   Bytef* dest;
   uInt  len;
{
   if (len == 0) return;
   do {
       *dest++ = 0;  /* ??? to be unrolled */
   } while (--len != 0);
}
#endif

#ifndef Z_SOLO

#ifdef SYS16BIT

#ifdef __TURBOC__
/* Turbo C in 16-bit mode */

#  define MY_ZCALLOC

/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
* and farmalloc(64K) returns a pointer with an offset of 8, so we
* must fix the pointer. Warning: the pointer must be put back to its
* original form in order to free it, use zcfree().
*/

#define MAX_PTR 10
/* 10*64K = 640K */

local int next_ptr = 0;

typedef struct ptr_table_s {
   voidpf org_ptr;
   voidpf new_ptr;
} ptr_table;

local ptr_table table[MAX_PTR];
/* This table is used to remember the original form of pointers
* to large buffers (64K). Such pointers are normalized with a zero offset.
* Since MSDOS is not a preemptive multitasking OS, this table is not
* protected from concurrent access. This hack doesn't work anyway on
* a protected system like OS/2. Use Microsoft C instead.
*/

voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
{
   voidpf buf;
   ulg bsize = (ulg)items*size;

   (void)opaque;

   /* If we allocate less than 65520 bytes, we assume that farmalloc
    * will return a usable pointer which doesn't have to be normalized.
    */
   if (bsize < 65520L) {
       buf = farmalloc(bsize);
       if (*(ush*)&buf != 0) return buf;
   } else {
       buf = farmalloc(bsize + 16L);
   }
   if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
   table[next_ptr].org_ptr = buf;

   /* Normalize the pointer to seg:0 */
   *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
   *(ush*)&buf = 0;
   table[next_ptr++].new_ptr = buf;
   return buf;
}

void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
   int n;

   (void)opaque;

   if (*(ush*)&ptr != 0) { /* object < 64K */
       farfree(ptr);
       return;
   }
   /* Find the original pointer */
   for (n = 0; n < next_ptr; n++) {
       if (ptr != table[n].new_ptr) continue;

       farfree(table[n].org_ptr);
       while (++n < next_ptr) {
           table[n-1] = table[n];
       }
       next_ptr--;
       return;
   }
   Assert(0, "zcfree: ptr not found");
}

#endif /* __TURBOC__ */


#ifdef M_I86
/* Microsoft C in 16-bit mode */

#  define MY_ZCALLOC

#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
#  define _halloc  halloc
#  define _hfree   hfree
#endif

voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
{
   (void)opaque;
   return _halloc((long)items, size);
}

void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
{
   (void)opaque;
   _hfree(ptr);
}

#endif /* M_I86 */

#endif /* SYS16BIT */


#ifndef MY_ZCALLOC /* Any system without a special alloc function */

#ifndef STDC
extern voidp  malloc OF((uInt size));
extern voidp  calloc OF((uInt items, uInt size));
extern void   free   OF((voidpf ptr));
#endif

voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
   voidpf opaque;
   unsigned items;
   unsigned size;
{
   (void)opaque;
   return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
                             (voidpf)calloc(items, size);
}

void ZLIB_INTERNAL zcfree (opaque, ptr)
   voidpf opaque;
   voidpf ptr;
{
   (void)opaque;
   free(ptr);
}

#endif /* MY_ZCALLOC */

#endif /* !Z_SOLO */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.