1 /* zutil.c -- target dependent utility functions for the compression library

     2  * Copyright (C) 1995-2005 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 NO_DUMMY_DECL

    11 struct internal_state      {int dummy;}; /* for buggy compilers */

    12 #endif

    13 

    14 const char * const z_errmsg[10] = {

    15 "need dictionary",     /* Z_NEED_DICT       2  */

    16 "stream end",          /* Z_STREAM_END      1  */

    17 "",                    /* Z_OK              0  */

    18 "file error",          /* Z_ERRNO         (-1) */

    19 "stream error",        /* Z_STREAM_ERROR  (-2) */

    20 "data error",          /* Z_DATA_ERROR    (-3) */

    21 "insufficient memory", /* Z_MEM_ERROR     (-4) */

    22 "buffer error",        /* Z_BUF_ERROR     (-5) */

    23 "incompatible version",/* Z_VERSION_ERROR (-6) */

    24 ""};

    25 

    26 

    27 const char * ZEXPORT zlibVersion()

    28 {

    29     return ZLIB_VERSION;

    30 }

    31 

    32 uLong ZEXPORT zlibCompileFlags()

    33 {

    34     uLong flags;

    35 

    36     flags = 0;

    37     switch (sizeof(uInt)) {

    38     case 2:     break;

    39     case 4:     flags += 1;     break;

    40     case 8:     flags += 2;     break;

    41     default:    flags += 3;

    42     }

    43     switch (sizeof(uLong)) {

    44     case 2:     break;

    45     case 4:     flags += 1 << 2;        break;

    46     case 8:     flags += 2 << 2;        break;

    47     default:    flags += 3 << 2;

    48     }

    49     switch (sizeof(voidpf)) {

    50     case 2:     break;

    51     case 4:     flags += 1 << 4;        break;

    52     case 8:     flags += 2 << 4;        break;

    53     default:    flags += 3 << 4;

    54     }

    55     switch (sizeof(z_off_t)) {

    56     case 2:     break;

    57     case 4:     flags += 1 << 6;        break;

    58     case 8:     flags += 2 << 6;        break;

    59     default:    flags += 3 << 6;

    60     }

    61 #ifdef DEBUG

    62     flags += 1 << 8;

    63 #endif

    64 #if defined(ASMV) || defined(ASMINF)

    65     flags += 1 << 9;

    66 #endif

    67 #ifdef ZLIB_WINAPI

    68     flags += 1 << 10;

    69 #endif

    70 #ifdef BUILDFIXED

    71     flags += 1 << 12;

    72 #endif

    73 #ifdef DYNAMIC_CRC_TABLE

    74     flags += 1 << 13;

    75 #endif

    76 #ifdef NO_GZCOMPRESS

    77     flags += 1L << 16;

    78 #endif

    79 #ifdef NO_GZIP

    80     flags += 1L << 17;

    81 #endif

    82 #ifdef PKZIP_BUG_WORKAROUND

    83     flags += 1L << 20;

    84 #endif

    85 #ifdef FASTEST

    86     flags += 1L << 21;

    87 #endif

    88 #ifdef STDC

    89 #  ifdef NO_vsnprintf

    90         flags += 1L << 25;

    91 #    ifdef HAS_vsprintf_void

    92         flags += 1L << 26;

    93 #    endif

    94 #  else

    95 #    ifdef HAS_vsnprintf_void

    96         flags += 1L << 26;

    97 #    endif

    98 #  endif

    99 #else

   100         flags += 1L << 24;

   101 #  ifdef NO_snprintf

   102         flags += 1L << 25;

   103 #    ifdef HAS_sprintf_void

   104         flags += 1L << 26;

   105 #    endif

   106 #  else

   107 #    ifdef HAS_snprintf_void

   108         flags += 1L << 26;

   109 #    endif

   110 #  endif

   111 #endif

   112     return flags;

   113 }

   114 

   115 #ifdef DEBUG

   116 

   117 #  ifndef verbose

   118 #    define verbose 0

   119 #  endif

   120 int z_verbose = verbose;

   121 

   122 void z_error (m)

   123     char *m;

   124 {

   125     fprintf(stderr, "%s\n", m);

   126     exit(1);

   127 }

   128 #endif

   129 

   130 /* exported to allow conversion of error code to string for compress() and

   131  * uncompress()

   132  */

   133 const char * ZEXPORT zError(err)

   134     int err;

   135 {

   136     return ERR_MSG(err);

   137 }

   138 

   139 #if defined(_WIN32_WCE)

   140     /* The Microsoft C Run-Time Library for Windows CE doesn't have

   141      * errno.  We define it as a global variable to simplify porting.

   142      * Its value is always 0 and should not be used.

   143      */

   144     int errno = 0;

   145 #endif

   146 

   147 #ifndef HAVE_MEMCPY

   148 

   149 void zmemcpy(dest, source, len)

   150     Bytef* dest;

   151     const Bytef* source;

   152     uInt  len;

   153 {

   154     if (len == 0) return;

   155     do {

   156         *dest++ = *source++; /* ??? to be unrolled */

   157     } while (--len != 0);

   158 }

   159 

   160 int zmemcmp(s1, s2, len)

   161     const Bytef* s1;

   162     const Bytef* s2;

   163     uInt  len;

   164 {

   165     uInt j;

   166 

   167     for (j = 0; j < len; j++) {

   168         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;

   169     }

   170     return 0;

   171 }

   172 

   173 void zmemzero(dest, len)

   174     Bytef* dest;

   175     uInt  len;

   176 {

   177     if (len == 0) return;

   178     do {

   179         *dest++ = 0;  /* ??? to be unrolled */

   180     } while (--len != 0);

   181 }

   182 #endif

   183 

   184 

   185 #ifdef SYS16BIT

   186 

   187 #ifdef __TURBOC__

   188 /* Turbo C in 16-bit mode */

   189 

   190 #  define MY_ZCALLOC

   191 

   192 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes

   193  * and farmalloc(64K) returns a pointer with an offset of 8, so we

   194  * must fix the pointer. Warning: the pointer must be put back to its

   195  * original form in order to free it, use zcfree().

   196  */

   197 

   198 #define MAX_PTR 10

   199 /* 10*64K = 640K */

   200 

   201 local int next_ptr = 0;

   202 

   203 typedef struct ptr_table_s {

   204     voidpf org_ptr;

   205     voidpf new_ptr;

   206 } ptr_table;

   207 

   208 local ptr_table table[MAX_PTR];

   209 /* This table is used to remember the original form of pointers

   210  * to large buffers (64K). Such pointers are normalized with a zero offset.

   211  * Since MSDOS is not a preemptive multitasking OS, this table is not

   212  * protected from concurrent access. This hack doesn't work anyway on

   213  * a protected system like OS/2. Use Microsoft C instead.

   214  */

   215 

   216 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)

   217 {

   218     voidpf buf = opaque; /* just to make some compilers happy */

   219     ulg bsize = (ulg)items*size;

   220 

   221     /* If we allocate less than 65520 bytes, we assume that farmalloc

   222      * will return a usable pointer which doesn't have to be normalized.

   223      */

   224     if (bsize < 65520L) {

   225         buf = farmalloc(bsize);

   226         if (*(ush*)&buf != 0) return buf;

   227     } else {

   228         buf = farmalloc(bsize + 16L);

   229     }

   230     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;

   231     table[next_ptr].org_ptr = buf;

   232 

   233     /* Normalize the pointer to seg:0 */

   234     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;

   235     *(ush*)&buf = 0;

   236     table[next_ptr++].new_ptr = buf;

   237     return buf;

   238 }

   239 

   240 void  zcfree (voidpf opaque, voidpf ptr)

   241 {

   242     int n;

   243     if (*(ush*)&ptr != 0) { /* object < 64K */

   244         farfree(ptr);

   245         return;

   246     }

   247     /* Find the original pointer */

   248     for (n = 0; n < next_ptr; n++) {

   249         if (ptr != table[n].new_ptr) continue;

   250 

   251         farfree(table[n].org_ptr);

   252         while (++n < next_ptr) {

   253             table[n-1] = table[n];

   254         }

   255         next_ptr--;

   256         return;

   257     }

   258     ptr = opaque; /* just to make some compilers happy */

   259     Assert(0, "zcfree: ptr not found");

   260 }

   261 

   262 #endif /* __TURBOC__ */

   263 

   264 

   265 #ifdef M_I86

   266 /* Microsoft C in 16-bit mode */

   267 

   268 #  define MY_ZCALLOC

   269 

   270 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))

   271 #  define _halloc  halloc

   272 #  define _hfree   hfree

   273 #endif

   274 

   275 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)

   276 {

   277     if (opaque) opaque = 0; /* to make compiler happy */

   278     return _halloc((long)items, size);

   279 }

   280 

   281 void  zcfree (voidpf opaque, voidpf ptr)

   282 {

   283     if (opaque) opaque = 0; /* to make compiler happy */

   284     _hfree(ptr);

   285 }

   286 

   287 #endif /* M_I86 */

   288 

   289 #endif /* SYS16BIT */

   290 

   291 

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

   293 

   294 #ifndef STDC

   295 extern voidp  malloc OF((uInt size));

   296 extern voidp  calloc OF((uInt items, uInt size));

   297 extern void   free   OF((voidpf ptr));

   298 #endif

   299 

   300 voidpf zcalloc (opaque, items, size)

   301     voidpf opaque;

   302     unsigned items;

   303     unsigned size;

   304 {

   305     if (opaque) items += size - size; /* make compiler happy */

   306     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :

   307                               (voidpf)calloc(items, size);

   308 }

   309 

   310 void  zcfree (opaque, ptr)

   311     voidpf opaque;

   312     voidpf ptr;

   313 {

   314     free(ptr);

   315     if (opaque) return; /* make compiler happy */

   316 }

   317 

   318 #endif /* MY_ZCALLOC */