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