"Fossies" - the Fresh Open Source Software Archive

Member "mariadb-connector-c-3.0.8-src/zlib/zutil.c" (18 Dec 2018, 7313 Bytes) of package /linux/misc/mariadb-connector-c-3.0.8-src.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /* zutil.c -- target dependent utility functions for the compression library
    2  * Copyright (C) 1995-2005, 2010 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 ((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 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 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 
  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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
  276 {
  277     if (opaque) opaque = 0; /* to make compiler happy */
  278     return _halloc((long)items, size);
  279 }
  280 
  281 void ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 ZLIB_INTERNAL 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 */