external/zlib-1.2.11/zutil.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 26 Oct 2018 14:58:01 -0700
changeset 617 d64228a395fc
parent 521 9ed2f7d4a251
permissions -rw-r--r--
Fixed webp library detection when cross-compiling for Windows
     1 /* zutil.c -- target dependent utility functions for the compression library
     2  * Copyright (C) 1995-2017 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 #ifndef Z_SOLO
    10 #  include "gzguts.h"
    11 #endif
    12 
    13 z_const char * const z_errmsg[10] = {
    14     (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
    15     (z_const char *)"stream end",          /* Z_STREAM_END      1  */
    16     (z_const char *)"",                    /* Z_OK              0  */
    17     (z_const char *)"file error",          /* Z_ERRNO         (-1) */
    18     (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
    19     (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
    20     (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
    21     (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
    22     (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
    23     (z_const char *)""
    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 ((int)(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 ((int)(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 ((int)(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 ((int)(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 ZLIB_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 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
    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 ZLIB_DEBUG
   116 #include <stdlib.h>
   117 #  ifndef verbose
   118 #    define verbose 0
   119 #  endif
   120 int ZLIB_INTERNAL z_verbose = verbose;
   121 
   122 void ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 #ifndef Z_SOLO
   185 
   186 #ifdef SYS16BIT
   187 
   188 #ifdef __TURBOC__
   189 /* Turbo C in 16-bit mode */
   190 
   191 #  define MY_ZCALLOC
   192 
   193 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
   194  * and farmalloc(64K) returns a pointer with an offset of 8, so we
   195  * must fix the pointer. Warning: the pointer must be put back to its
   196  * original form in order to free it, use zcfree().
   197  */
   198 
   199 #define MAX_PTR 10
   200 /* 10*64K = 640K */
   201 
   202 local int next_ptr = 0;
   203 
   204 typedef struct ptr_table_s {
   205     voidpf org_ptr;
   206     voidpf new_ptr;
   207 } ptr_table;
   208 
   209 local ptr_table table[MAX_PTR];
   210 /* This table is used to remember the original form of pointers
   211  * to large buffers (64K). Such pointers are normalized with a zero offset.
   212  * Since MSDOS is not a preemptive multitasking OS, this table is not
   213  * protected from concurrent access. This hack doesn't work anyway on
   214  * a protected system like OS/2. Use Microsoft C instead.
   215  */
   216 
   217 voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
   218 {
   219     voidpf buf;
   220     ulg bsize = (ulg)items*size;
   221 
   222     (void)opaque;
   223 
   224     /* If we allocate less than 65520 bytes, we assume that farmalloc
   225      * will return a usable pointer which doesn't have to be normalized.
   226      */
   227     if (bsize < 65520L) {
   228         buf = farmalloc(bsize);
   229         if (*(ush*)&buf != 0) return buf;
   230     } else {
   231         buf = farmalloc(bsize + 16L);
   232     }
   233     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
   234     table[next_ptr].org_ptr = buf;
   235 
   236     /* Normalize the pointer to seg:0 */
   237     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
   238     *(ush*)&buf = 0;
   239     table[next_ptr++].new_ptr = buf;
   240     return buf;
   241 }
   242 
   243 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
   244 {
   245     int n;
   246 
   247     (void)opaque;
   248 
   249     if (*(ush*)&ptr != 0) { /* object < 64K */
   250         farfree(ptr);
   251         return;
   252     }
   253     /* Find the original pointer */
   254     for (n = 0; n < next_ptr; n++) {
   255         if (ptr != table[n].new_ptr) continue;
   256 
   257         farfree(table[n].org_ptr);
   258         while (++n < next_ptr) {
   259             table[n-1] = table[n];
   260         }
   261         next_ptr--;
   262         return;
   263     }
   264     Assert(0, "zcfree: ptr not found");
   265 }
   266 
   267 #endif /* __TURBOC__ */
   268 
   269 
   270 #ifdef M_I86
   271 /* Microsoft C in 16-bit mode */
   272 
   273 #  define MY_ZCALLOC
   274 
   275 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
   276 #  define _halloc  halloc
   277 #  define _hfree   hfree
   278 #endif
   279 
   280 voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
   281 {
   282     (void)opaque;
   283     return _halloc((long)items, size);
   284 }
   285 
   286 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
   287 {
   288     (void)opaque;
   289     _hfree(ptr);
   290 }
   291 
   292 #endif /* M_I86 */
   293 
   294 #endif /* SYS16BIT */
   295 
   296 
   297 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
   298 
   299 #ifndef STDC
   300 extern voidp  malloc OF((uInt size));
   301 extern voidp  calloc OF((uInt items, uInt size));
   302 extern void   free   OF((voidpf ptr));
   303 #endif
   304 
   305 voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
   306     voidpf opaque;
   307     unsigned items;
   308     unsigned size;
   309 {
   310     (void)opaque;
   311     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
   312                               (voidpf)calloc(items, size);
   313 }
   314 
   315 void ZLIB_INTERNAL zcfree (opaque, ptr)
   316     voidpf opaque;
   317     voidpf ptr;
   318 {
   319     (void)opaque;
   320     free(ptr);
   321 }
   322 
   323 #endif /* MY_ZCALLOC */
   324 
   325 #endif /* !Z_SOLO */