zlib-1.2.5

/* adler32.c -- compute the Adler-32 checksum of a data stream
 * Copyright （C） 1995-2007 Mark Adler
 * For conditions of distribution and use see copyright notice in zlib.h
 */

/* @（#） $Id$ */

#include “zutil.h“

#define local static

local uLong adler32_combine_（uLong adler1 uLong adler2 z_off64_t len2）;

#define base 65521UL    /* largest prime smaller than 65536 */
#define NMAX 5552
/* NMAX is the largest n such that 255n（n+1）/2 + （n+1）（base-1） <= 2^32-1 */

#define DO1（bufi）  {adler += （buf）[i]; sum2 += adler;}
#define DO2（bufi）  DO1（bufi）; DO1（bufi+1）;
#define DO4（bufi）  DO2（bufi）; DO2（bufi+2）;
#define DO8（bufi）  DO4（bufi）; DO4（bufi+4）;
#define DO16（buf）   DO8（buf0）; DO8（buf8）;

/* use NO_DIVIDE if your processor does not do division in hardware */
#ifdef NO_DIVIDE
#  define MOD（a） \
    do { \
        if （a >= （base << 16）） a -= （base << 16）; \
        if （a >= （base << 15）） a -= （base << 15）; \
        if （a >= （base << 14）） a -= （base << 14）; \
        if （a >= （base << 13）） a -= （base << 13）; \
        if （a >= （base << 12）） a -= （base << 12）; \
        if （a >= （base << 11）） a -= （base << 11）; \
        if （a >= （base << 10）） a -= （base << 10）; \
        if （a >= （base << 9）） a -= （base << 9）; \
        if （a >= （base << 8）） a -= （base << 8）; \
        if （a >= （base << 7）） a -= （base << 7）; \
        if （a >= （base << 6）） a -= （base << 6）; \
        if （a >= （base << 5）） a -= （base << 5）; \
        if （a >= （base << 4）） a -= （base << 4）; \
        if （a >= （base << 3）） a -= （base << 3）; \
        if （a >= （base << 2）） a -= （base << 2）; \
        if （a >= （base << 1）） a -= （base << 1）; \
        if （a >= base） a -= base; \
    } while （0）
#  define MOD4（a） \
    do { \
        if （a >= （base << 4）） a -= （base << 4）; \
        if （a >= （base << 3）） a -= （base << 3）; \
        if （a >= （base << 2）） a -= （base << 2）; \
        if （a >= （base << 1）） a -= （base << 1）; \
        if （a >= base） a -= base; \
    } while （0）
#else
#  define MOD（a） a %= base
#  define MOD4（a） a %= base
#endif

/* ========================================================================= */
uLong ZEXPORT adler32（adler buf len）
    uLong adler;
    const Bytef *buf;
    uInt len;
{
    unsigned long sum2;
    unsigned n;

    /* split Adler-32 into component sums */
    sum2 = （adler >> 16） & 0xffff;
    adler &= 0xffff;

    /* in case user likes doing a byte at a time keep it fast */
    if （len == 1） {
        adler += buf[0];
        if （adler >= base）
            adler -= base;
        sum2 += adler;
        if （sum2 >= base）
            sum2 -= base;
        return adler | （sum2 << 16）;
    }

    /* initial Adler-32 value （deferred check for len == 1 speed） */
    if （buf == Z_NULL）
        return 1L;

    /* in case short lengths are provided keep it somewhat fast */
    if （len < 16） {
        while （len--） {
            adler += *buf++;
            sum2 += adler;
        }
        if （adler >= base）
            adler -= base;