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-06-02 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