1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/libs/zlib/adler32.c	Thu Sep 08 06:28:38 2011 +0300
     1.3 @@ -0,0 +1,149 @@
     1.4 +/* adler32.c -- compute the Adler-32 checksum of a data stream
     1.5 + * Copyright (C) 1995-2004 Mark Adler
     1.6 + * For conditions of distribution and use, see copyright notice in zlib.h
     1.7 + */
     1.8 +
     1.9 +/* @(#) $Id$ */
    1.10 +
    1.11 +#define ZLIB_INTERNAL
    1.12 +#include "zlib.h"
    1.13 +
    1.14 +#define BASE 65521UL    /* largest prime smaller than 65536 */
    1.15 +#define NMAX 5552
    1.16 +/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
    1.17 +
    1.18 +#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
    1.19 +#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
    1.20 +#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
    1.21 +#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
    1.22 +#define DO16(buf)   DO8(buf,0); DO8(buf,8);
    1.23 +
    1.24 +/* use NO_DIVIDE if your processor does not do division in hardware */
    1.25 +#ifdef NO_DIVIDE
    1.26 +#  define MOD(a) \
    1.27 +    do { \
    1.28 +        if (a >= (BASE << 16)) a -= (BASE << 16); \
    1.29 +        if (a >= (BASE << 15)) a -= (BASE << 15); \
    1.30 +        if (a >= (BASE << 14)) a -= (BASE << 14); \
    1.31 +        if (a >= (BASE << 13)) a -= (BASE << 13); \
    1.32 +        if (a >= (BASE << 12)) a -= (BASE << 12); \
    1.33 +        if (a >= (BASE << 11)) a -= (BASE << 11); \
    1.34 +        if (a >= (BASE << 10)) a -= (BASE << 10); \
    1.35 +        if (a >= (BASE << 9)) a -= (BASE << 9); \
    1.36 +        if (a >= (BASE << 8)) a -= (BASE << 8); \
    1.37 +        if (a >= (BASE << 7)) a -= (BASE << 7); \
    1.38 +        if (a >= (BASE << 6)) a -= (BASE << 6); \
    1.39 +        if (a >= (BASE << 5)) a -= (BASE << 5); \
    1.40 +        if (a >= (BASE << 4)) a -= (BASE << 4); \
    1.41 +        if (a >= (BASE << 3)) a -= (BASE << 3); \
    1.42 +        if (a >= (BASE << 2)) a -= (BASE << 2); \
    1.43 +        if (a >= (BASE << 1)) a -= (BASE << 1); \
    1.44 +        if (a >= BASE) a -= BASE; \
    1.45 +    } while (0)
    1.46 +#  define MOD4(a) \
    1.47 +    do { \
    1.48 +        if (a >= (BASE << 4)) a -= (BASE << 4); \
    1.49 +        if (a >= (BASE << 3)) a -= (BASE << 3); \
    1.50 +        if (a >= (BASE << 2)) a -= (BASE << 2); \
    1.51 +        if (a >= (BASE << 1)) a -= (BASE << 1); \
    1.52 +        if (a >= BASE) a -= BASE; \
    1.53 +    } while (0)
    1.54 +#else
    1.55 +#  define MOD(a) a %= BASE
    1.56 +#  define MOD4(a) a %= BASE
    1.57 +#endif
    1.58 +
    1.59 +/* ========================================================================= */
    1.60 +uLong ZEXPORT adler32(adler, buf, len)
    1.61 +    uLong adler;
    1.62 +    const Bytef *buf;
    1.63 +    uInt len;
    1.64 +{
    1.65 +    unsigned long sum2;
    1.66 +    unsigned n;
    1.67 +
    1.68 +    /* split Adler-32 into component sums */
    1.69 +    sum2 = (adler >> 16) & 0xffff;
    1.70 +    adler &= 0xffff;
    1.71 +
    1.72 +    /* in case user likes doing a byte at a time, keep it fast */
    1.73 +    if (len == 1) {
    1.74 +        adler += buf[0];
    1.75 +        if (adler >= BASE)
    1.76 +            adler -= BASE;
    1.77 +        sum2 += adler;
    1.78 +        if (sum2 >= BASE)
    1.79 +            sum2 -= BASE;
    1.80 +        return adler | (sum2 << 16);
    1.81 +    }
    1.82 +
    1.83 +    /* initial Adler-32 value (deferred check for len == 1 speed) */
    1.84 +    if (buf == Z_NULL)
    1.85 +        return 1L;
    1.86 +
    1.87 +    /* in case short lengths are provided, keep it somewhat fast */
    1.88 +    if (len < 16) {
    1.89 +        while (len--) {
    1.90 +            adler += *buf++;
    1.91 +            sum2 += adler;
    1.92 +        }
    1.93 +        if (adler >= BASE)
    1.94 +            adler -= BASE;
    1.95 +        MOD4(sum2);             /* only added so many BASE's */
    1.96 +        return adler | (sum2 << 16);
    1.97 +    }
    1.98 +
    1.99 +    /* do length NMAX blocks -- requires just one modulo operation */
   1.100 +    while (len >= NMAX) {
   1.101 +        len -= NMAX;
   1.102 +        n = NMAX / 16;          /* NMAX is divisible by 16 */
   1.103 +        do {
   1.104 +            DO16(buf);          /* 16 sums unrolled */
   1.105 +            buf += 16;
   1.106 +        } while (--n);
   1.107 +        MOD(adler);
   1.108 +        MOD(sum2);
   1.109 +    }
   1.110 +
   1.111 +    /* do remaining bytes (less than NMAX, still just one modulo) */
   1.112 +    if (len) {                  /* avoid modulos if none remaining */
   1.113 +        while (len >= 16) {
   1.114 +            len -= 16;
   1.115 +            DO16(buf);
   1.116 +            buf += 16;
   1.117 +        }
   1.118 +        while (len--) {
   1.119 +            adler += *buf++;
   1.120 +            sum2 += adler;
   1.121 +        }
   1.122 +        MOD(adler);
   1.123 +        MOD(sum2);
   1.124 +    }
   1.125 +
   1.126 +    /* return recombined sums */
   1.127 +    return adler | (sum2 << 16);
   1.128 +}
   1.129 +
   1.130 +/* ========================================================================= */
   1.131 +uLong ZEXPORT adler32_combine(adler1, adler2, len2)
   1.132 +    uLong adler1;
   1.133 +    uLong adler2;
   1.134 +    z_off_t len2;
   1.135 +{
   1.136 +    unsigned long sum1;
   1.137 +    unsigned long sum2;
   1.138 +    unsigned rem;
   1.139 +
   1.140 +    /* the derivation of this formula is left as an exercise for the reader */
   1.141 +    rem = (unsigned)(len2 % BASE);
   1.142 +    sum1 = adler1 & 0xffff;
   1.143 +    sum2 = rem * sum1;
   1.144 +    MOD(sum2);
   1.145 +    sum1 += (adler2 & 0xffff) + BASE - 1;
   1.146 +    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
   1.147 +    if (sum1 > BASE) sum1 -= BASE;
   1.148 +    if (sum1 > BASE) sum1 -= BASE;
   1.149 +    if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
   1.150 +    if (sum2 > BASE) sum2 -= BASE;
   1.151 +    return sum1 | (sum2 << 16);
   1.152 +}