LCOV - code coverage report
Current view: directory - modules/zlib/src - adler32.c (source / functions) Found Hit Coverage
Test: app.info Lines: 56 32 57.1 %
Date: 2012-06-02 Functions: 4 1 25.0 %

       1                 : /* adler32.c -- compute the Adler-32 checksum of a data stream
       2                 :  * Copyright (C) 1995-2007 Mark Adler
       3                 :  * For conditions of distribution and use, see copyright notice in zlib.h
       4                 :  */
       5                 : 
       6                 : /* @(#) $Id$ */
       7                 : 
       8                 : #include "zutil.h"
       9                 : 
      10                 : #define local static
      11                 : 
      12                 : local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2);
      13                 : 
      14                 : #define BASE 65521UL    /* largest prime smaller than 65536 */
      15                 : #define NMAX 5552
      16                 : /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
      17                 : 
      18                 : #define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
      19                 : #define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
      20                 : #define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
      21                 : #define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
      22                 : #define DO16(buf)   DO8(buf,0); DO8(buf,8);
      23                 : 
      24                 : /* use NO_DIVIDE if your processor does not do division in hardware */
      25                 : #ifdef NO_DIVIDE
      26                 : #  define MOD(a) \
      27                 :     do { \
      28                 :         if (a >= (BASE << 16)) a -= (BASE << 16); \
      29                 :         if (a >= (BASE << 15)) a -= (BASE << 15); \
      30                 :         if (a >= (BASE << 14)) a -= (BASE << 14); \
      31                 :         if (a >= (BASE << 13)) a -= (BASE << 13); \
      32                 :         if (a >= (BASE << 12)) a -= (BASE << 12); \
      33                 :         if (a >= (BASE << 11)) a -= (BASE << 11); \
      34                 :         if (a >= (BASE << 10)) a -= (BASE << 10); \
      35                 :         if (a >= (BASE << 9)) a -= (BASE << 9); \
      36                 :         if (a >= (BASE << 8)) a -= (BASE << 8); \
      37                 :         if (a >= (BASE << 7)) a -= (BASE << 7); \
      38                 :         if (a >= (BASE << 6)) a -= (BASE << 6); \
      39                 :         if (a >= (BASE << 5)) a -= (BASE << 5); \
      40                 :         if (a >= (BASE << 4)) a -= (BASE << 4); \
      41                 :         if (a >= (BASE << 3)) a -= (BASE << 3); \
      42                 :         if (a >= (BASE << 2)) a -= (BASE << 2); \
      43                 :         if (a >= (BASE << 1)) a -= (BASE << 1); \
      44                 :         if (a >= BASE) a -= BASE; \
      45                 :     } while (0)
      46                 : #  define MOD4(a) \
      47                 :     do { \
      48                 :         if (a >= (BASE << 4)) a -= (BASE << 4); \
      49                 :         if (a >= (BASE << 3)) a -= (BASE << 3); \
      50                 :         if (a >= (BASE << 2)) a -= (BASE << 2); \
      51                 :         if (a >= (BASE << 1)) a -= (BASE << 1); \
      52                 :         if (a >= BASE) a -= BASE; \
      53                 :     } while (0)
      54                 : #else
      55                 : #  define MOD(a) a %= BASE
      56                 : #  define MOD4(a) a %= BASE
      57                 : #endif
      58                 : 
      59                 : /* ========================================================================= */
      60            5769 : uLong ZEXPORT adler32(adler, buf, len)
      61                 :     uLong adler;
      62                 :     const Bytef *buf;
      63                 :     uInt len;
      64                 : {
      65                 :     unsigned long sum2;
      66                 :     unsigned n;
      67                 : 
      68                 :     /* split Adler-32 into component sums */
      69            5769 :     sum2 = (adler >> 16) & 0xffff;
      70            5769 :     adler &= 0xffff;
      71                 : 
      72                 :     /* in case user likes doing a byte at a time, keep it fast */
      73            5769 :     if (len == 1) {
      74               0 :         adler += buf[0];
      75               0 :         if (adler >= BASE)
      76               0 :             adler -= BASE;
      77               0 :         sum2 += adler;
      78               0 :         if (sum2 >= BASE)
      79               0 :             sum2 -= BASE;
      80               0 :         return adler | (sum2 << 16);
      81                 :     }
      82                 : 
      83                 :     /* initial Adler-32 value (deferred check for len == 1 speed) */
      84            5769 :     if (buf == Z_NULL)
      85            5256 :         return 1L;
      86                 : 
      87                 :     /* in case short lengths are provided, keep it somewhat fast */
      88             513 :     if (len < 16) {
      89            1082 :         while (len--) {
      90             922 :             adler += *buf++;
      91             922 :             sum2 += adler;
      92                 :         }
      93              80 :         if (adler >= BASE)
      94               0 :             adler -= BASE;
      95              80 :         MOD4(sum2);             /* only added so many BASE's */
      96              80 :         return adler | (sum2 << 16);
      97                 :     }
      98                 : 
      99                 :     /* do length NMAX blocks -- requires just one modulo operation */
     100             867 :     while (len >= NMAX) {
     101               1 :         len -= NMAX;
     102               1 :         n = NMAX / 16;          /* NMAX is divisible by 16 */
     103                 :         do {
     104             347 :             DO16(buf);          /* 16 sums unrolled */
     105             347 :             buf += 16;
     106             347 :         } while (--n);
     107               1 :         MOD(adler);
     108               1 :         MOD(sum2);
     109                 :     }
     110                 : 
     111                 :     /* do remaining bytes (less than NMAX, still just one modulo) */
     112             433 :     if (len) {                  /* avoid modulos if none remaining */
     113            5113 :         while (len >= 16) {
     114            4247 :             len -= 16;
     115            4247 :             DO16(buf);
     116            4247 :             buf += 16;
     117                 :         }
     118            1550 :         while (len--) {
     119             684 :             adler += *buf++;
     120             684 :             sum2 += adler;
     121                 :         }
     122             433 :         MOD(adler);
     123             433 :         MOD(sum2);
     124                 :     }
     125                 : 
     126                 :     /* return recombined sums */
     127             433 :     return adler | (sum2 << 16);
     128                 : }
     129                 : 
     130                 : /* ========================================================================= */
     131               0 : local uLong adler32_combine_(adler1, adler2, len2)
     132                 :     uLong adler1;
     133                 :     uLong adler2;
     134                 :     z_off64_t len2;
     135                 : {
     136                 :     unsigned long sum1;
     137                 :     unsigned long sum2;
     138                 :     unsigned rem;
     139                 : 
     140                 :     /* the derivation of this formula is left as an exercise for the reader */
     141               0 :     rem = (unsigned)(len2 % BASE);
     142               0 :     sum1 = adler1 & 0xffff;
     143               0 :     sum2 = rem * sum1;
     144               0 :     MOD(sum2);
     145               0 :     sum1 += (adler2 & 0xffff) + BASE - 1;
     146               0 :     sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
     147               0 :     if (sum1 >= BASE) sum1 -= BASE;
     148               0 :     if (sum1 >= BASE) sum1 -= BASE;
     149               0 :     if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
     150               0 :     if (sum2 >= BASE) sum2 -= BASE;
     151               0 :     return sum1 | (sum2 << 16);
     152                 : }
     153                 : 
     154                 : /* ========================================================================= */
     155               0 : uLong ZEXPORT adler32_combine(adler1, adler2, len2)
     156                 :     uLong adler1;
     157                 :     uLong adler2;
     158                 :     z_off_t len2;
     159                 : {
     160               0 :     return adler32_combine_(adler1, adler2, len2);
     161                 : }
     162                 : 
     163               0 : uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
     164                 :     uLong adler1;
     165                 :     uLong adler2;
     166                 :     z_off64_t len2;
     167                 : {
     168               0 :     return adler32_combine_(adler1, adler2, len2);
     169                 : }

Generated by: LCOV version 1.7