zstdlib 0.9.0-x86_64-darwin

Sign up to get free protection for your applications and to get access to all the features.
Files changed (123) hide show
  1. checksums.yaml +7 -0
  2. data/.yardopts +6 -0
  3. data/CHANGES.md +78 -0
  4. data/Gemfile +3 -0
  5. data/README.md +107 -0
  6. data/Rakefile +59 -0
  7. data/ext/zstdlib_c/extconf.rb +54 -0
  8. data/ext/zstdlib_c/ruby/zlib-2.2/zstdlib.c +4675 -0
  9. data/ext/zstdlib_c/ruby/zlib-2.3/zstdlib.c +4702 -0
  10. data/ext/zstdlib_c/ruby/zlib-2.4/zstdlib.c +4859 -0
  11. data/ext/zstdlib_c/ruby/zlib-2.5/zstdlib.c +4864 -0
  12. data/ext/zstdlib_c/ruby/zlib-2.6/zstdlib.c +4906 -0
  13. data/ext/zstdlib_c/ruby/zlib-2.7/zstdlib.c +4895 -0
  14. data/ext/zstdlib_c/ruby/zlib-3.0/zstdlib.c +4994 -0
  15. data/ext/zstdlib_c/ruby/zlib-3.1/zstdlib.c +5076 -0
  16. data/ext/zstdlib_c/zlib-1.2.11/adler32.c +186 -0
  17. data/ext/zstdlib_c/zlib-1.2.11/compress.c +86 -0
  18. data/ext/zstdlib_c/zlib-1.2.11/crc32.c +442 -0
  19. data/ext/zstdlib_c/zlib-1.2.11/crc32.h +441 -0
  20. data/ext/zstdlib_c/zlib-1.2.11/deflate.c +2163 -0
  21. data/ext/zstdlib_c/zlib-1.2.11/deflate.h +349 -0
  22. data/ext/zstdlib_c/zlib-1.2.11/gzclose.c +25 -0
  23. data/ext/zstdlib_c/zlib-1.2.11/gzguts.h +218 -0
  24. data/ext/zstdlib_c/zlib-1.2.11/gzlib.c +637 -0
  25. data/ext/zstdlib_c/zlib-1.2.11/gzread.c +654 -0
  26. data/ext/zstdlib_c/zlib-1.2.11/gzwrite.c +665 -0
  27. data/ext/zstdlib_c/zlib-1.2.11/infback.c +640 -0
  28. data/ext/zstdlib_c/zlib-1.2.11/inffast.c +323 -0
  29. data/ext/zstdlib_c/zlib-1.2.11/inffast.h +11 -0
  30. data/ext/zstdlib_c/zlib-1.2.11/inffixed.h +94 -0
  31. data/ext/zstdlib_c/zlib-1.2.11/inflate.c +1561 -0
  32. data/ext/zstdlib_c/zlib-1.2.11/inflate.h +125 -0
  33. data/ext/zstdlib_c/zlib-1.2.11/inftrees.c +304 -0
  34. data/ext/zstdlib_c/zlib-1.2.11/inftrees.h +62 -0
  35. data/ext/zstdlib_c/zlib-1.2.11/trees.c +1203 -0
  36. data/ext/zstdlib_c/zlib-1.2.11/trees.h +128 -0
  37. data/ext/zstdlib_c/zlib-1.2.11/uncompr.c +93 -0
  38. data/ext/zstdlib_c/zlib-1.2.11/zconf.h +534 -0
  39. data/ext/zstdlib_c/zlib-1.2.11/zlib.h +1912 -0
  40. data/ext/zstdlib_c/zlib-1.2.11/zutil.c +325 -0
  41. data/ext/zstdlib_c/zlib-1.2.11/zutil.h +271 -0
  42. data/ext/zstdlib_c/zlib.mk +14 -0
  43. data/ext/zstdlib_c/zlibwrapper/zlibwrapper.c +10 -0
  44. data/ext/zstdlib_c/zlibwrapper.mk +14 -0
  45. data/ext/zstdlib_c/zstd-1.5.2/lib/common/bitstream.h +478 -0
  46. data/ext/zstdlib_c/zstd-1.5.2/lib/common/compiler.h +335 -0
  47. data/ext/zstdlib_c/zstd-1.5.2/lib/common/cpu.h +213 -0
  48. data/ext/zstdlib_c/zstd-1.5.2/lib/common/debug.c +24 -0
  49. data/ext/zstdlib_c/zstd-1.5.2/lib/common/debug.h +107 -0
  50. data/ext/zstdlib_c/zstd-1.5.2/lib/common/entropy_common.c +368 -0
  51. data/ext/zstdlib_c/zstd-1.5.2/lib/common/error_private.c +56 -0
  52. data/ext/zstdlib_c/zstd-1.5.2/lib/common/error_private.h +159 -0
  53. data/ext/zstdlib_c/zstd-1.5.2/lib/common/fse.h +717 -0
  54. data/ext/zstdlib_c/zstd-1.5.2/lib/common/fse_decompress.c +403 -0
  55. data/ext/zstdlib_c/zstd-1.5.2/lib/common/huf.h +364 -0
  56. data/ext/zstdlib_c/zstd-1.5.2/lib/common/mem.h +442 -0
  57. data/ext/zstdlib_c/zstd-1.5.2/lib/common/pool.c +355 -0
  58. data/ext/zstdlib_c/zstd-1.5.2/lib/common/pool.h +84 -0
  59. data/ext/zstdlib_c/zstd-1.5.2/lib/common/portability_macros.h +137 -0
  60. data/ext/zstdlib_c/zstd-1.5.2/lib/common/threading.c +122 -0
  61. data/ext/zstdlib_c/zstd-1.5.2/lib/common/threading.h +155 -0
  62. data/ext/zstdlib_c/zstd-1.5.2/lib/common/xxhash.c +24 -0
  63. data/ext/zstdlib_c/zstd-1.5.2/lib/common/xxhash.h +5686 -0
  64. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_common.c +83 -0
  65. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_deps.h +111 -0
  66. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_internal.h +493 -0
  67. data/ext/zstdlib_c/zstd-1.5.2/lib/common/zstd_trace.h +163 -0
  68. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/clevels.h +134 -0
  69. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/fse_compress.c +741 -0
  70. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/hist.c +181 -0
  71. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/hist.h +75 -0
  72. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/huf_compress.c +1370 -0
  73. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress.c +6327 -0
  74. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_internal.h +1458 -0
  75. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_literals.c +159 -0
  76. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_literals.h +31 -0
  77. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_sequences.c +442 -0
  78. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_sequences.h +54 -0
  79. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_superblock.c +573 -0
  80. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_compress_superblock.h +32 -0
  81. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_cwksp.h +676 -0
  82. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_double_fast.c +696 -0
  83. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_double_fast.h +38 -0
  84. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_fast.c +675 -0
  85. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_fast.h +37 -0
  86. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_lazy.c +2104 -0
  87. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_lazy.h +125 -0
  88. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm.c +724 -0
  89. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm.h +117 -0
  90. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_ldm_geartab.h +106 -0
  91. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_opt.c +1446 -0
  92. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstd_opt.h +56 -0
  93. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstdmt_compress.c +1859 -0
  94. data/ext/zstdlib_c/zstd-1.5.2/lib/compress/zstdmt_compress.h +113 -0
  95. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/huf_decompress.c +1889 -0
  96. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/huf_decompress_amd64.S +585 -0
  97. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_ddict.c +244 -0
  98. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_ddict.h +44 -0
  99. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress.c +2230 -0
  100. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_block.c +2072 -0
  101. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_block.h +68 -0
  102. data/ext/zstdlib_c/zstd-1.5.2/lib/decompress/zstd_decompress_internal.h +236 -0
  103. data/ext/zstdlib_c/zstd-1.5.2/lib/zdict.h +452 -0
  104. data/ext/zstdlib_c/zstd-1.5.2/lib/zstd.h +2575 -0
  105. data/ext/zstdlib_c/zstd-1.5.2/lib/zstd_errors.h +95 -0
  106. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzclose.c +28 -0
  107. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzcompatibility.h +68 -0
  108. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzguts.h +229 -0
  109. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzlib.c +640 -0
  110. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzread.c +678 -0
  111. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/gzwrite.c +671 -0
  112. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/zstd_zlibwrapper.c +1198 -0
  113. data/ext/zstdlib_c/zstd-1.5.2/zlibWrapper/zstd_zlibwrapper.h +88 -0
  114. data/ext/zstdlib_c/zstd.mk +15 -0
  115. data/lib/2.4/zstdlib_c.bundle +0 -0
  116. data/lib/2.5/zstdlib_c.bundle +0 -0
  117. data/lib/2.6/zstdlib_c.bundle +0 -0
  118. data/lib/2.7/zstdlib_c.bundle +0 -0
  119. data/lib/3.0/zstdlib_c.bundle +0 -0
  120. data/lib/3.1/zstdlib_c.bundle +0 -0
  121. data/lib/zstdlib.rb +6 -0
  122. data/test/zstdlib_test.rb +21 -0
  123. metadata +237 -0
@@ -0,0 +1,186 @@
1
+ /* adler32.c -- compute the Adler-32 checksum of a data stream
2
+ * Copyright (C) 1995-2011, 2016 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
+ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
11
+
12
+ #define BASE 65521U /* largest prime smaller than 65536 */
13
+ #define NMAX 5552
14
+ /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
15
+
16
+ #define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
17
+ #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
18
+ #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
19
+ #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
20
+ #define DO16(buf) DO8(buf,0); DO8(buf,8);
21
+
22
+ /* use NO_DIVIDE if your processor does not do division in hardware --
23
+ try it both ways to see which is faster */
24
+ #ifdef NO_DIVIDE
25
+ /* note that this assumes BASE is 65521, where 65536 % 65521 == 15
26
+ (thank you to John Reiser for pointing this out) */
27
+ # define CHOP(a) \
28
+ do { \
29
+ unsigned long tmp = a >> 16; \
30
+ a &= 0xffffUL; \
31
+ a += (tmp << 4) - tmp; \
32
+ } while (0)
33
+ # define MOD28(a) \
34
+ do { \
35
+ CHOP(a); \
36
+ if (a >= BASE) a -= BASE; \
37
+ } while (0)
38
+ # define MOD(a) \
39
+ do { \
40
+ CHOP(a); \
41
+ MOD28(a); \
42
+ } while (0)
43
+ # define MOD63(a) \
44
+ do { /* this assumes a is not negative */ \
45
+ z_off64_t tmp = a >> 32; \
46
+ a &= 0xffffffffL; \
47
+ a += (tmp << 8) - (tmp << 5) + tmp; \
48
+ tmp = a >> 16; \
49
+ a &= 0xffffL; \
50
+ a += (tmp << 4) - tmp; \
51
+ tmp = a >> 16; \
52
+ a &= 0xffffL; \
53
+ a += (tmp << 4) - tmp; \
54
+ if (a >= BASE) a -= BASE; \
55
+ } while (0)
56
+ #else
57
+ # define MOD(a) a %= BASE
58
+ # define MOD28(a) a %= BASE
59
+ # define MOD63(a) a %= BASE
60
+ #endif
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
+ }
121
+ while (len--) {
122
+ adler += *buf++;
123
+ sum2 += adler;
124
+ }
125
+ MOD(adler);
126
+ MOD(sum2);
127
+ }
128
+
129
+ /* return recombined sums */
130
+ return adler | (sum2 << 16);
131
+ }
132
+
133
+ /* ========================================================================= */
134
+ uLong ZEXPORT adler32(adler, buf, len)
135
+ uLong adler;
136
+ const Bytef *buf;
137
+ uInt len;
138
+ {
139
+ return adler32_z(adler, buf, len);
140
+ }
141
+
142
+ /* ========================================================================= */
143
+ local uLong adler32_combine_(adler1, adler2, len2)
144
+ uLong adler1;
145
+ uLong adler2;
146
+ z_off64_t len2;
147
+ {
148
+ unsigned long sum1;
149
+ unsigned long sum2;
150
+ unsigned rem;
151
+
152
+ /* for negative len, return invalid adler32 as a clue for debugging */
153
+ if (len2 < 0)
154
+ return 0xffffffffUL;
155
+
156
+ /* the derivation of this formula is left as an exercise for the reader */
157
+ MOD63(len2); /* assumes len2 >= 0 */
158
+ rem = (unsigned)len2;
159
+ sum1 = adler1 & 0xffff;
160
+ sum2 = rem * sum1;
161
+ MOD(sum2);
162
+ sum1 += (adler2 & 0xffff) + BASE - 1;
163
+ sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
164
+ if (sum1 >= BASE) sum1 -= BASE;
165
+ if (sum1 >= BASE) sum1 -= BASE;
166
+ if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
167
+ if (sum2 >= BASE) sum2 -= BASE;
168
+ return sum1 | (sum2 << 16);
169
+ }
170
+
171
+ /* ========================================================================= */
172
+ uLong ZEXPORT adler32_combine(adler1, adler2, len2)
173
+ uLong adler1;
174
+ uLong adler2;
175
+ z_off_t len2;
176
+ {
177
+ return adler32_combine_(adler1, adler2, len2);
178
+ }
179
+
180
+ uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
181
+ uLong adler1;
182
+ uLong adler2;
183
+ z_off64_t len2;
184
+ {
185
+ return adler32_combine_(adler1, adler2, len2);
186
+ }
@@ -0,0 +1,86 @@
1
+ /* compress.c -- compress a memory buffer
2
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ */
5
+
6
+ /* @(#) $Id$ */
7
+
8
+ #define ZLIB_INTERNAL
9
+ #include "zlib.h"
10
+
11
+ /* ===========================================================================
12
+ Compresses the source buffer into the destination buffer. The level
13
+ parameter has the same meaning as in deflateInit. sourceLen is the byte
14
+ length of the source buffer. Upon entry, destLen is the total size of the
15
+ destination buffer, which must be at least 0.1% larger than sourceLen plus
16
+ 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
17
+
18
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
19
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
20
+ Z_STREAM_ERROR if the level parameter is invalid.
21
+ */
22
+ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
23
+ Bytef *dest;
24
+ uLongf *destLen;
25
+ const Bytef *source;
26
+ uLong sourceLen;
27
+ int level;
28
+ {
29
+ z_stream stream;
30
+ int err;
31
+ const uInt max = (uInt)-1;
32
+ uLong left;
33
+
34
+ left = *destLen;
35
+ *destLen = 0;
36
+
37
+ stream.zalloc = (alloc_func)0;
38
+ stream.zfree = (free_func)0;
39
+ stream.opaque = (voidpf)0;
40
+
41
+ err = deflateInit(&stream, level);
42
+ if (err != Z_OK) return err;
43
+
44
+ stream.next_out = dest;
45
+ stream.avail_out = 0;
46
+ stream.next_in = (z_const Bytef *)source;
47
+ stream.avail_in = 0;
48
+
49
+ do {
50
+ if (stream.avail_out == 0) {
51
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
52
+ left -= stream.avail_out;
53
+ }
54
+ if (stream.avail_in == 0) {
55
+ stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
56
+ sourceLen -= stream.avail_in;
57
+ }
58
+ err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
59
+ } while (err == Z_OK);
60
+
61
+ *destLen = stream.total_out;
62
+ deflateEnd(&stream);
63
+ return err == Z_STREAM_END ? Z_OK : err;
64
+ }
65
+
66
+ /* ===========================================================================
67
+ */
68
+ int ZEXPORT compress (dest, destLen, source, sourceLen)
69
+ Bytef *dest;
70
+ uLongf *destLen;
71
+ const Bytef *source;
72
+ uLong sourceLen;
73
+ {
74
+ return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
75
+ }
76
+
77
+ /* ===========================================================================
78
+ If the default memLevel or windowBits for deflateInit() is changed, then
79
+ this function needs to be updated.
80
+ */
81
+ uLong ZEXPORT compressBound (sourceLen)
82
+ uLong sourceLen;
83
+ {
84
+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
85
+ (sourceLen >> 25) + 13;
86
+ }
@@ -0,0 +1,442 @@
1
+ /* crc32.c -- compute the CRC-32 of a data stream
2
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
3
+ * For conditions of distribution and use, see copyright notice in zlib.h
4
+ *
5
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
6
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
7
+ * tables for updating the shift register in one step with three exclusive-ors
8
+ * instead of four steps with four exclusive-ors. This results in about a
9
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
10
+ */
11
+
12
+ /* @(#) $Id$ */
13
+
14
+ /*
15
+ Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
16
+ protection on the static variables used to control the first-use generation
17
+ of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should
18
+ first call get_crc_table() to initialize the tables before allowing more than
19
+ one thread to use crc32().
20
+
21
+ DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
22
+ */
23
+
24
+ #ifdef MAKECRCH
25
+ # include <stdio.h>
26
+ # ifndef DYNAMIC_CRC_TABLE
27
+ # define DYNAMIC_CRC_TABLE
28
+ # endif /* !DYNAMIC_CRC_TABLE */
29
+ #endif /* MAKECRCH */
30
+
31
+ #include "zutil.h" /* for STDC and FAR definitions */
32
+
33
+ /* Definitions for doing the crc four data bytes at a time. */
34
+ #if !defined(NOBYFOUR) && defined(Z_U4)
35
+ # define BYFOUR
36
+ #endif
37
+ #ifdef BYFOUR
38
+ local unsigned long crc32_little OF((unsigned long,
39
+ const unsigned char FAR *, z_size_t));
40
+ local unsigned long crc32_big OF((unsigned long,
41
+ const unsigned char FAR *, z_size_t));
42
+ # define TBLS 8
43
+ #else
44
+ # define TBLS 1
45
+ #endif /* BYFOUR */
46
+
47
+ /* Local functions for crc concatenation */
48
+ local unsigned long gf2_matrix_times OF((unsigned long *mat,
49
+ unsigned long vec));
50
+ local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
51
+ local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
52
+
53
+
54
+ #ifdef DYNAMIC_CRC_TABLE
55
+
56
+ local volatile int crc_table_empty = 1;
57
+ local z_crc_t FAR crc_table[TBLS][256];
58
+ local void make_crc_table OF((void));
59
+ #ifdef MAKECRCH
60
+ local void write_table OF((FILE *, const z_crc_t FAR *));
61
+ #endif /* MAKECRCH */
62
+ /*
63
+ Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
64
+ x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
65
+
66
+ Polynomials over GF(2) are represented in binary, one bit per coefficient,
67
+ with the lowest powers in the most significant bit. Then adding polynomials
68
+ is just exclusive-or, and multiplying a polynomial by x is a right shift by
69
+ one. If we call the above polynomial p, and represent a byte as the
70
+ polynomial q, also with the lowest power in the most significant bit (so the
71
+ byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
72
+ where a mod b means the remainder after dividing a by b.
73
+
74
+ This calculation is done using the shift-register method of multiplying and
75
+ taking the remainder. The register is initialized to zero, and for each
76
+ incoming bit, x^32 is added mod p to the register if the bit is a one (where
77
+ x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
78
+ x (which is shifting right by one and adding x^32 mod p if the bit shifted
79
+ out is a one). We start with the highest power (least significant bit) of
80
+ q and repeat for all eight bits of q.
81
+
82
+ The first table is simply the CRC of all possible eight bit values. This is
83
+ all the information needed to generate CRCs on data a byte at a time for all
84
+ combinations of CRC register values and incoming bytes. The remaining tables
85
+ allow for word-at-a-time CRC calculation for both big-endian and little-
86
+ endian machines, where a word is four bytes.
87
+ */
88
+ local void make_crc_table()
89
+ {
90
+ z_crc_t c;
91
+ int n, k;
92
+ z_crc_t poly; /* polynomial exclusive-or pattern */
93
+ /* terms of polynomial defining this crc (except x^32): */
94
+ static volatile int first = 1; /* flag to limit concurrent making */
95
+ static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
96
+
97
+ /* See if another task is already doing this (not thread-safe, but better
98
+ than nothing -- significantly reduces duration of vulnerability in
99
+ case the advice about DYNAMIC_CRC_TABLE is ignored) */
100
+ if (first) {
101
+ first = 0;
102
+
103
+ /* make exclusive-or pattern from polynomial (0xedb88320UL) */
104
+ poly = 0;
105
+ for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
106
+ poly |= (z_crc_t)1 << (31 - p[n]);
107
+
108
+ /* generate a crc for every 8-bit value */
109
+ for (n = 0; n < 256; n++) {
110
+ c = (z_crc_t)n;
111
+ for (k = 0; k < 8; k++)
112
+ c = c & 1 ? poly ^ (c >> 1) : c >> 1;
113
+ crc_table[0][n] = c;
114
+ }
115
+
116
+ #ifdef BYFOUR
117
+ /* generate crc for each value followed by one, two, and three zeros,
118
+ and then the byte reversal of those as well as the first table */
119
+ for (n = 0; n < 256; n++) {
120
+ c = crc_table[0][n];
121
+ crc_table[4][n] = ZSWAP32(c);
122
+ for (k = 1; k < 4; k++) {
123
+ c = crc_table[0][c & 0xff] ^ (c >> 8);
124
+ crc_table[k][n] = c;
125
+ crc_table[k + 4][n] = ZSWAP32(c);
126
+ }
127
+ }
128
+ #endif /* BYFOUR */
129
+
130
+ crc_table_empty = 0;
131
+ }
132
+ else { /* not first */
133
+ /* wait for the other guy to finish (not efficient, but rare) */
134
+ while (crc_table_empty)
135
+ ;
136
+ }
137
+
138
+ #ifdef MAKECRCH
139
+ /* write out CRC tables to crc32.h */
140
+ {
141
+ FILE *out;
142
+
143
+ out = fopen("crc32.h", "w");
144
+ if (out == NULL) return;
145
+ fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
146
+ fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
147
+ fprintf(out, "local const z_crc_t FAR ");
148
+ fprintf(out, "crc_table[TBLS][256] =\n{\n {\n");
149
+ write_table(out, crc_table[0]);
150
+ # ifdef BYFOUR
151
+ fprintf(out, "#ifdef BYFOUR\n");
152
+ for (k = 1; k < 8; k++) {
153
+ fprintf(out, " },\n {\n");
154
+ write_table(out, crc_table[k]);
155
+ }
156
+ fprintf(out, "#endif\n");
157
+ # endif /* BYFOUR */
158
+ fprintf(out, " }\n};\n");
159
+ fclose(out);
160
+ }
161
+ #endif /* MAKECRCH */
162
+ }
163
+
164
+ #ifdef MAKECRCH
165
+ local void write_table(out, table)
166
+ FILE *out;
167
+ const z_crc_t FAR *table;
168
+ {
169
+ int n;
170
+
171
+ for (n = 0; n < 256; n++)
172
+ fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ",
173
+ (unsigned long)(table[n]),
174
+ n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
175
+ }
176
+ #endif /* MAKECRCH */
177
+
178
+ #else /* !DYNAMIC_CRC_TABLE */
179
+ /* ========================================================================
180
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
181
+ */
182
+ #include "crc32.h"
183
+ #endif /* DYNAMIC_CRC_TABLE */
184
+
185
+ /* =========================================================================
186
+ * This function can be used by asm versions of crc32()
187
+ */
188
+ const z_crc_t FAR * ZEXPORT get_crc_table()
189
+ {
190
+ #ifdef DYNAMIC_CRC_TABLE
191
+ if (crc_table_empty)
192
+ make_crc_table();
193
+ #endif /* DYNAMIC_CRC_TABLE */
194
+ return (const z_crc_t FAR *)crc_table;
195
+ }
196
+
197
+ /* ========================================================================= */
198
+ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
199
+ #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
200
+
201
+ /* ========================================================================= */
202
+ unsigned long ZEXPORT crc32_z(crc, buf, len)
203
+ unsigned long crc;
204
+ const unsigned char FAR *buf;
205
+ z_size_t len;
206
+ {
207
+ if (buf == Z_NULL) return 0UL;
208
+
209
+ #ifdef DYNAMIC_CRC_TABLE
210
+ if (crc_table_empty)
211
+ make_crc_table();
212
+ #endif /* DYNAMIC_CRC_TABLE */
213
+
214
+ #ifdef BYFOUR
215
+ if (sizeof(void *) == sizeof(ptrdiff_t)) {
216
+ z_crc_t endian;
217
+
218
+ endian = 1;
219
+ if (*((unsigned char *)(&endian)))
220
+ return crc32_little(crc, buf, len);
221
+ else
222
+ return crc32_big(crc, buf, len);
223
+ }
224
+ #endif /* BYFOUR */
225
+ crc = crc ^ 0xffffffffUL;
226
+ while (len >= 8) {
227
+ DO8;
228
+ len -= 8;
229
+ }
230
+ if (len) do {
231
+ DO1;
232
+ } while (--len);
233
+ return crc ^ 0xffffffffUL;
234
+ }
235
+
236
+ /* ========================================================================= */
237
+ unsigned long ZEXPORT crc32(crc, buf, len)
238
+ unsigned long crc;
239
+ const unsigned char FAR *buf;
240
+ uInt len;
241
+ {
242
+ return crc32_z(crc, buf, len);
243
+ }
244
+
245
+ #ifdef BYFOUR
246
+
247
+ /*
248
+ This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
249
+ integer pointer type. This violates the strict aliasing rule, where a
250
+ compiler can assume, for optimization purposes, that two pointers to
251
+ fundamentally different types won't ever point to the same memory. This can
252
+ manifest as a problem only if one of the pointers is written to. This code
253
+ only reads from those pointers. So long as this code remains isolated in
254
+ this compilation unit, there won't be a problem. For this reason, this code
255
+ should not be copied and pasted into a compilation unit in which other code
256
+ writes to the buffer that is passed to these routines.
257
+ */
258
+
259
+ /* ========================================================================= */
260
+ #define DOLIT4 c ^= *buf4++; \
261
+ c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
262
+ crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
263
+ #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
264
+
265
+ /* ========================================================================= */
266
+ local unsigned long crc32_little(crc, buf, len)
267
+ unsigned long crc;
268
+ const unsigned char FAR *buf;
269
+ z_size_t len;
270
+ {
271
+ register z_crc_t c;
272
+ register const z_crc_t FAR *buf4;
273
+
274
+ c = (z_crc_t)crc;
275
+ c = ~c;
276
+ while (len && ((ptrdiff_t)buf & 3)) {
277
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
278
+ len--;
279
+ }
280
+
281
+ buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
282
+ while (len >= 32) {
283
+ DOLIT32;
284
+ len -= 32;
285
+ }
286
+ while (len >= 4) {
287
+ DOLIT4;
288
+ len -= 4;
289
+ }
290
+ buf = (const unsigned char FAR *)buf4;
291
+
292
+ if (len) do {
293
+ c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
294
+ } while (--len);
295
+ c = ~c;
296
+ return (unsigned long)c;
297
+ }
298
+
299
+ /* ========================================================================= */
300
+ #define DOBIG4 c ^= *buf4++; \
301
+ c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
302
+ crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
303
+ #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
304
+
305
+ /* ========================================================================= */
306
+ local unsigned long crc32_big(crc, buf, len)
307
+ unsigned long crc;
308
+ const unsigned char FAR *buf;
309
+ z_size_t len;
310
+ {
311
+ register z_crc_t c;
312
+ register const z_crc_t FAR *buf4;
313
+
314
+ c = ZSWAP32((z_crc_t)crc);
315
+ c = ~c;
316
+ while (len && ((ptrdiff_t)buf & 3)) {
317
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
318
+ len--;
319
+ }
320
+
321
+ buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
322
+ while (len >= 32) {
323
+ DOBIG32;
324
+ len -= 32;
325
+ }
326
+ while (len >= 4) {
327
+ DOBIG4;
328
+ len -= 4;
329
+ }
330
+ buf = (const unsigned char FAR *)buf4;
331
+
332
+ if (len) do {
333
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
334
+ } while (--len);
335
+ c = ~c;
336
+ return (unsigned long)(ZSWAP32(c));
337
+ }
338
+
339
+ #endif /* BYFOUR */
340
+
341
+ #define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
342
+
343
+ /* ========================================================================= */
344
+ local unsigned long gf2_matrix_times(mat, vec)
345
+ unsigned long *mat;
346
+ unsigned long vec;
347
+ {
348
+ unsigned long sum;
349
+
350
+ sum = 0;
351
+ while (vec) {
352
+ if (vec & 1)
353
+ sum ^= *mat;
354
+ vec >>= 1;
355
+ mat++;
356
+ }
357
+ return sum;
358
+ }
359
+
360
+ /* ========================================================================= */
361
+ local void gf2_matrix_square(square, mat)
362
+ unsigned long *square;
363
+ unsigned long *mat;
364
+ {
365
+ int n;
366
+
367
+ for (n = 0; n < GF2_DIM; n++)
368
+ square[n] = gf2_matrix_times(mat, mat[n]);
369
+ }
370
+
371
+ /* ========================================================================= */
372
+ local uLong crc32_combine_(crc1, crc2, len2)
373
+ uLong crc1;
374
+ uLong crc2;
375
+ z_off64_t len2;
376
+ {
377
+ int n;
378
+ unsigned long row;
379
+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
380
+ unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */
381
+
382
+ /* degenerate case (also disallow negative lengths) */
383
+ if (len2 <= 0)
384
+ return crc1;
385
+
386
+ /* put operator for one zero bit in odd */
387
+ odd[0] = 0xedb88320UL; /* CRC-32 polynomial */
388
+ row = 1;
389
+ for (n = 1; n < GF2_DIM; n++) {
390
+ odd[n] = row;
391
+ row <<= 1;
392
+ }
393
+
394
+ /* put operator for two zero bits in even */
395
+ gf2_matrix_square(even, odd);
396
+
397
+ /* put operator for four zero bits in odd */
398
+ gf2_matrix_square(odd, even);
399
+
400
+ /* apply len2 zeros to crc1 (first square will put the operator for one
401
+ zero byte, eight zero bits, in even) */
402
+ do {
403
+ /* apply zeros operator for this bit of len2 */
404
+ gf2_matrix_square(even, odd);
405
+ if (len2 & 1)
406
+ crc1 = gf2_matrix_times(even, crc1);
407
+ len2 >>= 1;
408
+
409
+ /* if no more bits set, then done */
410
+ if (len2 == 0)
411
+ break;
412
+
413
+ /* another iteration of the loop with odd and even swapped */
414
+ gf2_matrix_square(odd, even);
415
+ if (len2 & 1)
416
+ crc1 = gf2_matrix_times(odd, crc1);
417
+ len2 >>= 1;
418
+
419
+ /* if no more bits set, then done */
420
+ } while (len2 != 0);
421
+
422
+ /* return combined crc */
423
+ crc1 ^= crc2;
424
+ return crc1;
425
+ }
426
+
427
+ /* ========================================================================= */
428
+ uLong ZEXPORT crc32_combine(crc1, crc2, len2)
429
+ uLong crc1;
430
+ uLong crc2;
431
+ z_off_t len2;
432
+ {
433
+ return crc32_combine_(crc1, crc2, len2);
434
+ }
435
+
436
+ uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
437
+ uLong crc1;
438
+ uLong crc2;
439
+ z_off64_t len2;
440
+ {
441
+ return crc32_combine_(crc1, crc2, len2);
442
+ }