wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - zlib - zutil.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 6 17 35.3 %
Date: 2014-08-22 Functions: 2 5 40.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* zutil.c -- target dependent utility functions for the compression library
       2             :  * Copyright (C) 1995-2005, 2010, 2011, 2012 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             : #ifndef NO_DUMMY_DECL
      14             : struct internal_state      {int dummy;}; /* for buggy compilers */
      15             : #endif
      16             : 
      17             : const char * const z_errmsg[10] = {
      18             : "need dictionary",     /* Z_NEED_DICT       2  */
      19             : "stream end",          /* Z_STREAM_END      1  */
      20             : "",                    /* Z_OK              0  */
      21             : "file error",          /* Z_ERRNO         (-1) */
      22             : "stream error",        /* Z_STREAM_ERROR  (-2) */
      23             : "data error",          /* Z_DATA_ERROR    (-3) */
      24             : "insufficient memory", /* Z_MEM_ERROR     (-4) */
      25             : "buffer error",        /* Z_BUF_ERROR     (-5) */
      26             : "incompatible version",/* Z_VERSION_ERROR (-6) */
      27             : ""};
      28             : 
      29             : 
      30           0 : const char * ZEXPORT zlibVersion()
      31             : {
      32           0 :     return ZLIB_VERSION;
      33             : }
      34             : 
      35           0 : uLong ZEXPORT zlibCompileFlags()
      36             : {
      37             :     uLong flags;
      38             : 
      39           0 :     flags = 0;
      40             :     switch ((int)(sizeof(uInt))) {
      41             :     case 2:     break;
      42           0 :     case 4:     flags += 1;     break;
      43             :     case 8:     flags += 2;     break;
      44             :     default:    flags += 3;
      45             :     }
      46             :     switch ((int)(sizeof(uLong))) {
      47             :     case 2:     break;
      48             :     case 4:     flags += 1 << 2;        break;
      49           0 :     case 8:     flags += 2 << 2;        break;
      50             :     default:    flags += 3 << 2;
      51             :     }
      52             :     switch ((int)(sizeof(voidpf))) {
      53             :     case 2:     break;
      54             :     case 4:     flags += 1 << 4;        break;
      55           0 :     case 8:     flags += 2 << 4;        break;
      56             :     default:    flags += 3 << 4;
      57             :     }
      58             :     switch ((int)(sizeof(z_off_t))) {
      59             :     case 2:     break;
      60             :     case 4:     flags += 1 << 6;        break;
      61           0 :     case 8:     flags += 2 << 6;        break;
      62             :     default:    flags += 3 << 6;
      63             :     }
      64             : #ifdef DEBUG
      65             :     flags += 1 << 8;
      66             : #endif
      67             : #if defined(ASMV) || defined(ASMINF)
      68             :     flags += 1 << 9;
      69             : #endif
      70             : #ifdef ZLIB_WINAPI
      71             :     flags += 1 << 10;
      72             : #endif
      73             : #ifdef BUILDFIXED
      74             :     flags += 1 << 12;
      75             : #endif
      76             : #ifdef DYNAMIC_CRC_TABLE
      77             :     flags += 1 << 13;
      78             : #endif
      79             : #ifdef NO_GZCOMPRESS
      80             :     flags += 1L << 16;
      81             : #endif
      82             : #ifdef NO_GZIP
      83             :     flags += 1L << 17;
      84             : #endif
      85             : #ifdef PKZIP_BUG_WORKAROUND
      86             :     flags += 1L << 20;
      87             : #endif
      88             : #ifdef FASTEST
      89             :     flags += 1L << 21;
      90             : #endif
      91             : #if defined(STDC) || defined(Z_HAVE_STDARG_H)
      92             : #  ifdef NO_vsnprintf
      93             :     flags += 1L << 25;
      94             : #    ifdef HAS_vsprintf_void
      95             :     flags += 1L << 26;
      96             : #    endif
      97             : #  else
      98             : #    ifdef HAS_vsnprintf_void
      99             :     flags += 1L << 26;
     100             : #    endif
     101             : #  endif
     102             : #else
     103             :     flags += 1L << 24;
     104             : #  ifdef NO_snprintf
     105             :     flags += 1L << 25;
     106             : #    ifdef HAS_sprintf_void
     107             :     flags += 1L << 26;
     108             : #    endif
     109             : #  else
     110             : #    ifdef HAS_snprintf_void
     111             :     flags += 1L << 26;
     112             : #    endif
     113             : #  endif
     114             : #endif
     115           0 :     return flags;
     116             : }
     117             : 
     118             : #ifdef DEBUG
     119             : 
     120             : #  ifndef verbose
     121             : #    define verbose 0
     122             : #  endif
     123             : int ZLIB_INTERNAL z_verbose = verbose;
     124             : 
     125             : void ZLIB_INTERNAL z_error (m)
     126             :     char *m;
     127             : {
     128             :     fprintf(stderr, "%s\n", m);
     129             :     exit(1);
     130             : }
     131             : #endif
     132             : 
     133             : /* exported to allow conversion of error code to string for compress() and
     134             :  * uncompress()
     135             :  */
     136           0 : const char * ZEXPORT zError(err)
     137             :     int err;
     138             : {
     139           0 :     return ERR_MSG(err);
     140             : }
     141             : 
     142             : #if defined(_WIN32_WCE)
     143             :     /* The Microsoft C Run-Time Library for Windows CE doesn't have
     144             :      * errno.  We define it as a global variable to simplify porting.
     145             :      * Its value is always 0 and should not be used.
     146             :      */
     147             :     int errno = 0;
     148             : #endif
     149             : 
     150             : #ifndef HAVE_MEMCPY
     151             : 
     152             : void ZLIB_INTERNAL zmemcpy(dest, source, len)
     153             :     Bytef* dest;
     154             :     const Bytef* source;
     155             :     uInt  len;
     156             : {
     157             :     if (len == 0) return;
     158             :     do {
     159             :         *dest++ = *source++; /* ??? to be unrolled */
     160             :     } while (--len != 0);
     161             : }
     162             : 
     163             : int ZLIB_INTERNAL zmemcmp(s1, s2, len)
     164             :     const Bytef* s1;
     165             :     const Bytef* s2;
     166             :     uInt  len;
     167             : {
     168             :     uInt j;
     169             : 
     170             :     for (j = 0; j < len; j++) {
     171             :         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
     172             :     }
     173             :     return 0;
     174             : }
     175             : 
     176             : void ZLIB_INTERNAL zmemzero(dest, len)
     177             :     Bytef* dest;
     178             :     uInt  len;
     179             : {
     180             :     if (len == 0) return;
     181             :     do {
     182             :         *dest++ = 0;  /* ??? to be unrolled */
     183             :     } while (--len != 0);
     184             : }
     185             : #endif
     186             : 
     187             : #ifndef Z_SOLO
     188             : 
     189             : #ifdef SYS16BIT
     190             : 
     191             : #ifdef __TURBOC__
     192             : /* Turbo C in 16-bit mode */
     193             : 
     194             : #  define MY_ZCALLOC
     195             : 
     196             : /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
     197             :  * and farmalloc(64K) returns a pointer with an offset of 8, so we
     198             :  * must fix the pointer. Warning: the pointer must be put back to its
     199             :  * original form in order to free it, use zcfree().
     200             :  */
     201             : 
     202             : #define MAX_PTR 10
     203             : /* 10*64K = 640K */
     204             : 
     205             : local int next_ptr = 0;
     206             : 
     207             : typedef struct ptr_table_s {
     208             :     voidpf org_ptr;
     209             :     voidpf new_ptr;
     210             : } ptr_table;
     211             : 
     212             : local ptr_table table[MAX_PTR];
     213             : /* This table is used to remember the original form of pointers
     214             :  * to large buffers (64K). Such pointers are normalized with a zero offset.
     215             :  * Since MSDOS is not a preemptive multitasking OS, this table is not
     216             :  * protected from concurrent access. This hack doesn't work anyway on
     217             :  * a protected system like OS/2. Use Microsoft C instead.
     218             :  */
     219             : 
     220             : voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
     221             : {
     222             :     voidpf buf = opaque; /* just to make some compilers happy */
     223             :     ulg bsize = (ulg)items*size;
     224             : 
     225             :     /* If we allocate less than 65520 bytes, we assume that farmalloc
     226             :      * will return a usable pointer which doesn't have to be normalized.
     227             :      */
     228             :     if (bsize < 65520L) {
     229             :         buf = farmalloc(bsize);
     230             :         if (*(ush*)&buf != 0) return buf;
     231             :     } else {
     232             :         buf = farmalloc(bsize + 16L);
     233             :     }
     234             :     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
     235             :     table[next_ptr].org_ptr = buf;
     236             : 
     237             :     /* Normalize the pointer to seg:0 */
     238             :     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
     239             :     *(ush*)&buf = 0;
     240             :     table[next_ptr++].new_ptr = buf;
     241             :     return buf;
     242             : }
     243             : 
     244             : void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
     245             : {
     246             :     int n;
     247             :     if (*(ush*)&ptr != 0) { /* object < 64K */
     248             :         farfree(ptr);
     249             :         return;
     250             :     }
     251             :     /* Find the original pointer */
     252             :     for (n = 0; n < next_ptr; n++) {
     253             :         if (ptr != table[n].new_ptr) continue;
     254             : 
     255             :         farfree(table[n].org_ptr);
     256             :         while (++n < next_ptr) {
     257             :             table[n-1] = table[n];
     258             :         }
     259             :         next_ptr--;
     260             :         return;
     261             :     }
     262             :     ptr = opaque; /* just to make some compilers happy */
     263             :     Assert(0, "zcfree: ptr not found");
     264             : }
     265             : 
     266             : #endif /* __TURBOC__ */
     267             : 
     268             : 
     269             : #ifdef M_I86
     270             : /* Microsoft C in 16-bit mode */
     271             : 
     272             : #  define MY_ZCALLOC
     273             : 
     274             : #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
     275             : #  define _halloc  halloc
     276             : #  define _hfree   hfree
     277             : #endif
     278             : 
     279             : voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
     280             : {
     281             :     if (opaque) opaque = 0; /* to make compiler happy */
     282             :     return _halloc((long)items, size);
     283             : }
     284             : 
     285             : void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
     286             : {
     287             :     if (opaque) opaque = 0; /* to make compiler happy */
     288             :     _hfree(ptr);
     289             : }
     290             : 
     291             : #endif /* M_I86 */
     292             : 
     293             : #endif /* SYS16BIT */
     294             : 
     295             : 
     296             : #ifndef MY_ZCALLOC /* Any system without a special alloc function */
     297             : 
     298             : #ifndef STDC
     299             : extern voidp  malloc OF((uInt size));
     300             : extern voidp  calloc OF((uInt items, uInt size));
     301             : extern void   free   OF((voidpf ptr));
     302             : #endif
     303             : 
     304       27877 : voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
     305             :     voidpf opaque;
     306             :     unsigned items;
     307             :     unsigned size;
     308             : {
     309       27877 :     if (opaque) items += size - size; /* make compiler happy */
     310       27877 :     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
     311             :                               (voidpf)calloc(items, size);
     312             : }
     313             : 
     314       27877 : void ZLIB_INTERNAL zcfree (opaque, ptr)
     315             :     voidpf opaque;
     316             :     voidpf ptr;
     317             : {
     318       27877 :     free(ptr);
     319       27877 :     if (opaque) return; /* make compiler happy */
     320             : }
     321             : 
     322             : #endif /* MY_ZCALLOC */
     323             : 
     324             : #endif /* !Z_SOLO */

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.