LCOV - app.info - modules/zlib/src/zutil.c

LCOV - code coverage report
| Current view: | directory - modules/zlib/src - zutil.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 17 | 6 | 35.3 %
| Date: | 2012-07-07 | Functions: | 5 | 2 | 40.0 %

           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               0 : const char * ZEXPORT zlibVersion()
          28                 : {
          29               0 :     return ZLIB_VERSION;
          30                 : }
          31                 :
          32               0 : uLong ZEXPORT zlibCompileFlags()
          33                 : {
          34                 :     uLong flags;
          35                 :
          36               0 :     flags = 0;
          37                 :     switch ((int)(sizeof(uInt))) {
          38                 :     case 2:     break;
          39               0 :     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               0 :     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               0 :     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               0 :     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               0 :     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               0 : const char * ZEXPORT zError(err)
         134                 :     int err;
         135                 : {
         136               0 :     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           26991 : voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
         301                 :     voidpf opaque;
         302                 :     unsigned items;
         303                 :     unsigned size;
         304                 : {
         305           26991 :     if (opaque) items += size - size; /* make compiler happy */
         306           26991 :     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
         307                 :                               (voidpf)calloc(items, size);
         308                 : }
         309                 :
         310           26989 : void ZLIB_INTERNAL zcfree (opaque, ptr)
         311                 :     voidpf opaque;
         312                 :     voidpf ptr;
         313                 : {
         314           26989 :     free(ptr);
         315           26989 :     if (opaque) return; /* make compiler happy */
         316                 : }
         317                 :
         318                 : #endif /* MY_ZCALLOC */

Generated by: LCOV version 1.7