========================================================================= */
| 63 | |
| 64 | /* ========================================================================= */ |
| 65 | uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) |
| 66 | { |
| 67 | unsigned long sum2; |
| 68 | unsigned n; |
| 69 | |
| 70 | /* split Adler-32 into component sums */ |
| 71 | sum2 = (adler >> 16) & 0xffff; |
| 72 | adler &= 0xffff; |
| 73 | |
| 74 | /* in case user likes doing a byte at a time, keep it fast */ |
| 75 | if (len == 1) { |
| 76 | adler += buf[0]; |
| 77 | if (adler >= BASE) |
| 78 | adler -= BASE; |
| 79 | sum2 += adler; |
| 80 | if (sum2 >= BASE) |
| 81 | sum2 -= BASE; |
| 82 | return adler | (sum2 << 16); |
| 83 | } |
| 84 | |
| 85 | /* initial Adler-32 value (deferred check for len == 1 speed) */ |
| 86 | if (buf == Z_NULL) |
| 87 | return 1L; |
| 88 | |
| 89 | /* in case short lengths are provided, keep it somewhat fast */ |
| 90 | if (len < 16) { |
| 91 | while (len--) { |
| 92 | adler += *buf++; |
| 93 | sum2 += adler; |
| 94 | } |
| 95 | if (adler >= BASE) |
| 96 | adler -= BASE; |
| 97 | MOD28(sum2); /* only added so many BASE's */ |
| 98 | return adler | (sum2 << 16); |
| 99 | } |
| 100 | |
| 101 | /* do length NMAX blocks -- requires just one modulo operation */ |
| 102 | while (len >= NMAX) { |
| 103 | len -= NMAX; |
| 104 | n = NMAX / 16; /* NMAX is divisible by 16 */ |
| 105 | do { |
| 106 | DO16(buf); /* 16 sums unrolled */ |
| 107 | buf += 16; |
| 108 | } while (--n); |
| 109 | MOD(adler); |
| 110 | MOD(sum2); |
| 111 | } |
| 112 | |
| 113 | /* do remaining bytes (less than NMAX, still just one modulo) */ |
| 114 | if (len) { /* avoid modulos if none remaining */ |
| 115 | while (len >= 16) { |
| 116 | len -= 16; |
| 117 | DO16(buf); |
| 118 | buf += 16; |
| 119 | } |
| 120 | while (len--) { |
| 121 | adler += *buf++; |
| 122 | sum2 += adler; |
no outgoing calls
no test coverage detected