zstdlib 0.9.0-arm64-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,678 @@
1
+ /* gzread.c contains minimal changes required to be compiled with zlibWrapper:
2
+ * - gz_statep was converted to union to work with -Wstrict-aliasing=1 */
3
+
4
+ /* gzread.c -- zlib functions for reading gzip files
5
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
6
+ * For conditions of distribution and use, see http://www.zlib.net/zlib_license.html
7
+ */
8
+
9
+ #include "gzguts.h"
10
+
11
+ /* fix for Visual Studio, which doesn't support ssize_t type.
12
+ * see https://github.com/facebook/zstd/issues/1800#issuecomment-545945050 */
13
+ #if defined(_MSC_VER) && !defined(ssize_t)
14
+ # include <BaseTsd.h>
15
+ typedef SSIZE_T ssize_t;
16
+ #endif
17
+
18
+
19
+ /* Local functions */
20
+ local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
21
+ local int gz_avail OF((gz_statep));
22
+ local int gz_look OF((gz_statep));
23
+ local int gz_decomp OF((gz_statep));
24
+ local int gz_fetch OF((gz_statep));
25
+ local int gz_skip OF((gz_statep, z_off64_t));
26
+ local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
27
+
28
+ /* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
29
+ state.state->fd, and update state.state->eof, state.state->err, and state.state->msg as appropriate.
30
+ This function needs to loop on read(), since read() is not guaranteed to
31
+ read the number of bytes requested, depending on the type of descriptor. */
32
+ local int gz_load(state, buf, len, have)
33
+ gz_statep state;
34
+ unsigned char *buf;
35
+ unsigned len;
36
+ unsigned *have;
37
+ {
38
+ ssize_t ret;
39
+ unsigned get, max = ((unsigned)-1 >> 2) + 1;
40
+
41
+ *have = 0;
42
+ do {
43
+ get = len - *have;
44
+ if (get > max)
45
+ get = max;
46
+ ret = read(state.state->fd, buf + *have, get);
47
+ if (ret <= 0)
48
+ break;
49
+ *have += (unsigned)ret;
50
+ } while (*have < len);
51
+ if (ret < 0) {
52
+ gz_error(state, Z_ERRNO, zstrerror());
53
+ return -1;
54
+ }
55
+ if (ret == 0)
56
+ state.state->eof = 1;
57
+ return 0;
58
+ }
59
+
60
+ /* Load up input buffer and set eof flag if last data loaded -- return -1 on
61
+ error, 0 otherwise. Note that the eof flag is set when the end of the input
62
+ file is reached, even though there may be unused data in the buffer. Once
63
+ that data has been used, no more attempts will be made to read the file.
64
+ If strm->avail_in != 0, then the current data is moved to the beginning of
65
+ the input buffer, and then the remainder of the buffer is loaded with the
66
+ available data from the input file. */
67
+ local int gz_avail(state)
68
+ gz_statep state;
69
+ {
70
+ unsigned got;
71
+ z_streamp strm = &(state.state->strm);
72
+
73
+ if (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR)
74
+ return -1;
75
+ if (state.state->eof == 0) {
76
+ if (strm->avail_in) { /* copy what's there to the start */
77
+ unsigned char *p = state.state->in;
78
+ unsigned const char *q = strm->next_in;
79
+ unsigned n = strm->avail_in;
80
+ do {
81
+ *p++ = *q++;
82
+ } while (--n);
83
+ }
84
+ if (gz_load(state, state.state->in + strm->avail_in,
85
+ state.state->size - strm->avail_in, &got) == -1)
86
+ return -1;
87
+ strm->avail_in += got;
88
+ strm->next_in = state.state->in;
89
+ }
90
+ return 0;
91
+ }
92
+
93
+ /* Look for gzip header, set up for inflate or copy. state.state->x.have must be 0.
94
+ If this is the first time in, allocate required memory. state.state->how will be
95
+ left unchanged if there is no more input data available, will be set to COPY
96
+ if there is no gzip header and direct copying will be performed, or it will
97
+ be set to GZIP for decompression. If direct copying, then leftover input
98
+ data from the input buffer will be copied to the output buffer. In that
99
+ case, all further file reads will be directly to either the output buffer or
100
+ a user buffer. If decompressing, the inflate state will be initialized.
101
+ gz_look() will return 0 on success or -1 on failure. */
102
+ local int gz_look(state)
103
+ gz_statep state;
104
+ {
105
+ z_streamp strm = &(state.state->strm);
106
+
107
+ /* allocate read buffers and inflate memory */
108
+ if (state.state->size == 0) {
109
+ /* allocate buffers */
110
+ state.state->in = (unsigned char *)malloc(state.state->want);
111
+ state.state->out = (unsigned char *)malloc(state.state->want << 1);
112
+ if (state.state->in == NULL || state.state->out == NULL) {
113
+ free(state.state->out);
114
+ free(state.state->in);
115
+ gz_error(state, Z_MEM_ERROR, "out of memory");
116
+ return -1;
117
+ }
118
+ state.state->size = state.state->want;
119
+
120
+ /* allocate inflate memory */
121
+ state.state->strm.zalloc = Z_NULL;
122
+ state.state->strm.zfree = Z_NULL;
123
+ state.state->strm.opaque = Z_NULL;
124
+ state.state->strm.avail_in = 0;
125
+ state.state->strm.next_in = Z_NULL;
126
+ if (inflateInit2(&(state.state->strm), 15 + 16) != Z_OK) { /* gunzip */
127
+ free(state.state->out);
128
+ free(state.state->in);
129
+ state.state->size = 0;
130
+ gz_error(state, Z_MEM_ERROR, "out of memory");
131
+ return -1;
132
+ }
133
+ }
134
+
135
+ /* get at least the magic bytes in the input buffer */
136
+ if (strm->avail_in < 2) {
137
+ if (gz_avail(state) == -1)
138
+ return -1;
139
+ if (strm->avail_in == 0)
140
+ return 0;
141
+ }
142
+
143
+ /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
144
+ a logical dilemma here when considering the case of a partially written
145
+ gzip file, to wit, if a single 31 byte is written, then we cannot tell
146
+ whether this is a single-byte file, or just a partially written gzip
147
+ file -- for here we assume that if a gzip file is being written, then
148
+ the header will be written in a single operation, so that reading a
149
+ single byte is sufficient indication that it is not a gzip file) */
150
+ if (strm->avail_in > 1 &&
151
+ ((strm->next_in[0] == 31 && strm->next_in[1] == 139) /* gz header */
152
+ || (strm->next_in[0] == 40 && strm->next_in[1] == 181))) { /* zstd header */
153
+ inflateReset(strm);
154
+ state.state->how = GZIP;
155
+ state.state->direct = 0;
156
+ return 0;
157
+ }
158
+
159
+ /* no gzip header -- if we were decoding gzip before, then this is trailing
160
+ garbage. Ignore the trailing garbage and finish. */
161
+ if (state.state->direct == 0) {
162
+ strm->avail_in = 0;
163
+ state.state->eof = 1;
164
+ state.state->x.have = 0;
165
+ return 0;
166
+ }
167
+
168
+ /* doing raw i/o, copy any leftover input to output -- this assumes that
169
+ the output buffer is larger than the input buffer, which also assures
170
+ space for gzungetc() */
171
+ state.state->x.next = state.state->out;
172
+ if (strm->avail_in) {
173
+ memcpy(state.state->x.next, strm->next_in, strm->avail_in);
174
+ state.state->x.have = strm->avail_in;
175
+ strm->avail_in = 0;
176
+ }
177
+ state.state->how = COPY;
178
+ state.state->direct = 1;
179
+ return 0;
180
+ }
181
+
182
+ /* Decompress from input to the provided next_out and avail_out in the state.
183
+ On return, state.state->x.have and state.state->x.next point to the just decompressed
184
+ data. If the gzip stream completes, state.state->how is reset to LOOK to look for
185
+ the next gzip stream or raw data, once state.state->x.have is depleted. Returns 0
186
+ on success, -1 on failure. */
187
+ local int gz_decomp(state)
188
+ gz_statep state;
189
+ {
190
+ int ret = Z_OK;
191
+ unsigned had;
192
+ z_streamp strm = &(state.state->strm);
193
+
194
+ /* fill output buffer up to end of deflate stream */
195
+ had = strm->avail_out;
196
+ do {
197
+ /* get more input for inflate() */
198
+ if (strm->avail_in == 0 && gz_avail(state) == -1)
199
+ return -1;
200
+ if (strm->avail_in == 0) {
201
+ gz_error(state, Z_BUF_ERROR, "unexpected end of file");
202
+ break;
203
+ }
204
+
205
+ /* decompress and handle errors */
206
+ ret = inflate(strm, Z_NO_FLUSH);
207
+ if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
208
+ gz_error(state, Z_STREAM_ERROR,
209
+ "internal error: inflate stream corrupt");
210
+ return -1;
211
+ }
212
+ if (ret == Z_MEM_ERROR) {
213
+ gz_error(state, Z_MEM_ERROR, "out of memory");
214
+ return -1;
215
+ }
216
+ if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
217
+ gz_error(state, Z_DATA_ERROR,
218
+ strm->msg == NULL ? "compressed data error" : strm->msg);
219
+ return -1;
220
+ }
221
+ } while (strm->avail_out && ret != Z_STREAM_END);
222
+
223
+ /* update available output */
224
+ state.state->x.have = had - strm->avail_out;
225
+ state.state->x.next = strm->next_out - state.state->x.have;
226
+
227
+ /* if the gzip stream completed successfully, look for another */
228
+ if (ret == Z_STREAM_END)
229
+ state.state->how = LOOK;
230
+
231
+ /* good decompression */
232
+ return 0;
233
+ }
234
+
235
+ /* Fetch data and put it in the output buffer. Assumes state.state->x.have is 0.
236
+ Data is either copied from the input file or decompressed from the input
237
+ file depending on state.state->how. If state.state->how is LOOK, then a gzip header is
238
+ looked for to determine whether to copy or decompress. Returns -1 on error,
239
+ otherwise 0. gz_fetch() will leave state.state->how as COPY or GZIP unless the
240
+ end of the input file has been reached and all data has been processed. */
241
+ local int gz_fetch(state)
242
+ gz_statep state;
243
+ {
244
+ z_streamp strm = &(state.state->strm);
245
+
246
+ do {
247
+ switch(state.state->how) {
248
+ case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
249
+ if (gz_look(state) == -1)
250
+ return -1;
251
+ if (state.state->how == LOOK)
252
+ return 0;
253
+ break;
254
+ case COPY: /* -> COPY */
255
+ if (gz_load(state, state.state->out, state.state->size << 1, &(state.state->x.have))
256
+ == -1)
257
+ return -1;
258
+ state.state->x.next = state.state->out;
259
+ return 0;
260
+ case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */
261
+ strm->avail_out = state.state->size << 1;
262
+ strm->next_out = state.state->out;
263
+ if (gz_decomp(state) == -1)
264
+ return -1;
265
+ }
266
+ } while (state.state->x.have == 0 && (!state.state->eof || strm->avail_in));
267
+ return 0;
268
+ }
269
+
270
+ /* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */
271
+ local int gz_skip(state, len)
272
+ gz_statep state;
273
+ z_off64_t len;
274
+ {
275
+ unsigned n;
276
+
277
+ /* skip over len bytes or reach end-of-file, whichever comes first */
278
+ while (len)
279
+ /* skip over whatever is in output buffer */
280
+ if (state.state->x.have) {
281
+ n = GT_OFF(state.state->x.have) || (z_off64_t)state.state->x.have > len ?
282
+ (unsigned)len : state.state->x.have;
283
+ state.state->x.have -= n;
284
+ state.state->x.next += n;
285
+ state.state->x.pos += n;
286
+ len -= n;
287
+ }
288
+
289
+ /* output buffer empty -- return if we're at the end of the input */
290
+ else if (state.state->eof && state.state->strm.avail_in == 0)
291
+ break;
292
+
293
+ /* need more data to skip -- load up output buffer */
294
+ else {
295
+ /* get more output, looking for header if required */
296
+ if (gz_fetch(state) == -1)
297
+ return -1;
298
+ }
299
+ return 0;
300
+ }
301
+
302
+ /* Read len bytes into buf from file, or less than len up to the end of the
303
+ input. Return the number of bytes read. If zero is returned, either the
304
+ end of file was reached, or there was an error. state.state->err must be
305
+ consulted in that case to determine which. */
306
+ local z_size_t gz_read(state, buf, len)
307
+ gz_statep state;
308
+ voidp buf;
309
+ z_size_t len;
310
+ {
311
+ z_size_t got;
312
+ unsigned n;
313
+
314
+ /* if len is zero, avoid unnecessary operations */
315
+ if (len == 0)
316
+ return 0;
317
+
318
+ /* process a skip request */
319
+ if (state.state->seek) {
320
+ state.state->seek = 0;
321
+ if (gz_skip(state, state.state->skip) == -1)
322
+ return 0;
323
+ }
324
+
325
+ /* get len bytes to buf, or less than len if at the end */
326
+ got = 0;
327
+ do {
328
+ /* set n to the maximum amount of len that fits in an unsigned int */
329
+ n = -1;
330
+ if (n > len)
331
+ n = (unsigned)len;
332
+
333
+ /* first just try copying data from the output buffer */
334
+ if (state.state->x.have) {
335
+ if (state.state->x.have < n)
336
+ n = state.state->x.have;
337
+ memcpy(buf, state.state->x.next, n);
338
+ state.state->x.next += n;
339
+ state.state->x.have -= n;
340
+ }
341
+
342
+ /* output buffer empty -- return if we're at the end of the input */
343
+ else if (state.state->eof && state.state->strm.avail_in == 0) {
344
+ state.state->past = 1; /* tried to read past end */
345
+ break;
346
+ }
347
+
348
+ /* need output data -- for small len or new stream load up our output
349
+ buffer */
350
+ else if (state.state->how == LOOK || n < (state.state->size << 1)) {
351
+ /* get more output, looking for header if required */
352
+ if (gz_fetch(state) == -1)
353
+ return 0;
354
+ continue; /* no progress yet -- go back to copy above */
355
+ /* the copy above assures that we will leave with space in the
356
+ output buffer, allowing at least one gzungetc() to succeed */
357
+ }
358
+
359
+ /* large len -- read directly into user buffer */
360
+ else if (state.state->how == COPY) { /* read directly */
361
+ if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
362
+ return 0;
363
+ }
364
+
365
+ /* large len -- decompress directly into user buffer */
366
+ else { /* state.state->how == GZIP */
367
+ state.state->strm.avail_out = n;
368
+ state.state->strm.next_out = (unsigned char *)buf;
369
+ if (gz_decomp(state) == -1)
370
+ return 0;
371
+ n = state.state->x.have;
372
+ state.state->x.have = 0;
373
+ }
374
+
375
+ /* update progress */
376
+ len -= n;
377
+ buf = (char *)buf + n;
378
+ got += n;
379
+ state.state->x.pos += n;
380
+ } while (len);
381
+
382
+ /* return number of bytes read into user buffer */
383
+ return got;
384
+ }
385
+
386
+ /* -- see zlib.h -- */
387
+ int ZEXPORT gzread(file, buf, len)
388
+ gzFile file;
389
+ voidp buf;
390
+ unsigned len;
391
+ {
392
+ gz_statep state;
393
+
394
+ /* get internal structure */
395
+ if (file == NULL)
396
+ return -1;
397
+ state.file = file;
398
+
399
+ /* check that we're reading and that there's no (serious) error */
400
+ if (state.state->mode != GZ_READ ||
401
+ (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR))
402
+ return -1;
403
+
404
+ /* since an int is returned, make sure len fits in one, otherwise return
405
+ with an error (this avoids a flaw in the interface) */
406
+ if ((int)len < 0) {
407
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
408
+ return -1;
409
+ }
410
+
411
+ /* read len or fewer bytes to buf */
412
+ len = (unsigned)gz_read(state, buf, len);
413
+
414
+ /* check for an error */
415
+ if (len == 0 && state.state->err != Z_OK && state.state->err != Z_BUF_ERROR)
416
+ return -1;
417
+
418
+ /* return the number of bytes read (this is assured to fit in an int) */
419
+ return (int)len;
420
+ }
421
+
422
+ /* -- see zlib.h -- */
423
+ z_size_t ZEXPORT gzfread(buf, size, nitems, file)
424
+ voidp buf;
425
+ z_size_t size;
426
+ z_size_t nitems;
427
+ gzFile file;
428
+ {
429
+ z_size_t len;
430
+ gz_statep state;
431
+
432
+ /* get internal structure */
433
+ if (file == NULL)
434
+ return 0;
435
+ state.file = file;
436
+
437
+ /* check that we're reading and that there's no (serious) error */
438
+ if (state.state->mode != GZ_READ ||
439
+ (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR))
440
+ return 0;
441
+
442
+ /* compute bytes to read -- error on overflow */
443
+ len = nitems * size;
444
+ if (size && len / size != nitems) {
445
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
446
+ return 0;
447
+ }
448
+
449
+ /* read len or fewer bytes to buf, return the number of full items read */
450
+ return len ? gz_read(state, buf, len) / size : 0;
451
+ }
452
+
453
+ /* -- see zlib.h -- */
454
+ #if ZLIB_VERNUM >= 0x1261
455
+ #ifdef Z_PREFIX_SET
456
+ # undef z_gzgetc
457
+ #else
458
+ # undef gzgetc
459
+ #endif
460
+ #endif
461
+
462
+ #if ZLIB_VERNUM == 0x1260
463
+ # undef gzgetc
464
+ #endif
465
+
466
+ #if ZLIB_VERNUM <= 0x1250
467
+ ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
468
+ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file));
469
+ #endif
470
+
471
+ int ZEXPORT gzgetc(file)
472
+ gzFile file;
473
+ {
474
+ int ret;
475
+ unsigned char buf[1];
476
+ gz_statep state;
477
+
478
+ /* get internal structure */
479
+ if (file == NULL)
480
+ return -1;
481
+ state.file = file;
482
+
483
+ /* check that we're reading and that there's no (serious) error */
484
+ if (state.state->mode != GZ_READ ||
485
+ (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR))
486
+ return -1;
487
+
488
+ /* try output buffer (no need to check for skip request) */
489
+ if (state.state->x.have) {
490
+ state.state->x.have--;
491
+ state.state->x.pos++;
492
+ return *(state.state->x.next)++;
493
+ }
494
+
495
+ /* nothing there -- try gz_read() */
496
+ ret = (int)gz_read(state, buf, 1);
497
+ return ret < 1 ? -1 : buf[0];
498
+ }
499
+
500
+ int ZEXPORT gzgetc_(file)
501
+ gzFile file;
502
+ {
503
+ return gzgetc(file);
504
+ }
505
+
506
+ /* -- see zlib.h -- */
507
+ int ZEXPORT gzungetc(c, file)
508
+ int c;
509
+ gzFile file;
510
+ {
511
+ gz_statep state;
512
+
513
+ /* get internal structure */
514
+ if (file == NULL)
515
+ return -1;
516
+ state.file = file;
517
+
518
+ /* check that we're reading and that there's no (serious) error */
519
+ if (state.state->mode != GZ_READ ||
520
+ (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR))
521
+ return -1;
522
+
523
+ /* process a skip request */
524
+ if (state.state->seek) {
525
+ state.state->seek = 0;
526
+ if (gz_skip(state, state.state->skip) == -1)
527
+ return -1;
528
+ }
529
+
530
+ /* can't push EOF */
531
+ if (c < 0)
532
+ return -1;
533
+
534
+ /* if output buffer empty, put byte at end (allows more pushing) */
535
+ if (state.state->x.have == 0) {
536
+ state.state->x.have = 1;
537
+ state.state->x.next = state.state->out + (state.state->size << 1) - 1;
538
+ state.state->x.next[0] = (unsigned char)c;
539
+ state.state->x.pos--;
540
+ state.state->past = 0;
541
+ return c;
542
+ }
543
+
544
+ /* if no room, give up (must have already done a gzungetc()) */
545
+ if (state.state->x.have == (state.state->size << 1)) {
546
+ gz_error(state, Z_DATA_ERROR, "out of room to push characters");
547
+ return -1;
548
+ }
549
+
550
+ /* slide output data if needed and insert byte before existing data */
551
+ if (state.state->x.next == state.state->out) {
552
+ unsigned char *src = state.state->out + state.state->x.have;
553
+ unsigned char *dest = state.state->out + (state.state->size << 1);
554
+ while (src > state.state->out)
555
+ *--dest = *--src;
556
+ state.state->x.next = dest;
557
+ }
558
+ state.state->x.have++;
559
+ state.state->x.next--;
560
+ state.state->x.next[0] = (unsigned char)c;
561
+ state.state->x.pos--;
562
+ state.state->past = 0;
563
+ return c;
564
+ }
565
+
566
+ /* -- see zlib.h -- */
567
+ char * ZEXPORT gzgets(file, buf, len)
568
+ gzFile file;
569
+ char *buf;
570
+ int len;
571
+ {
572
+ unsigned left, n;
573
+ char *str;
574
+ unsigned char *eol;
575
+ gz_statep state;
576
+
577
+ /* check parameters and get internal structure */
578
+ if (file == NULL || buf == NULL || len < 1)
579
+ return NULL;
580
+ state.file = file;
581
+
582
+ /* check that we're reading and that there's no (serious) error */
583
+ if (state.state->mode != GZ_READ ||
584
+ (state.state->err != Z_OK && state.state->err != Z_BUF_ERROR))
585
+ return NULL;
586
+
587
+ /* process a skip request */
588
+ if (state.state->seek) {
589
+ state.state->seek = 0;
590
+ if (gz_skip(state, state.state->skip) == -1)
591
+ return NULL;
592
+ }
593
+
594
+ /* copy output bytes up to new line or len - 1, whichever comes first --
595
+ append a terminating zero to the string (we don't check for a zero in
596
+ the contents, let the user worry about that) */
597
+ str = buf;
598
+ left = (unsigned)len - 1;
599
+ if (left) do {
600
+ /* assure that something is in the output buffer */
601
+ if (state.state->x.have == 0 && gz_fetch(state) == -1)
602
+ return NULL; /* error */
603
+ if (state.state->x.have == 0) { /* end of file */
604
+ state.state->past = 1; /* read past end */
605
+ break; /* return what we have */
606
+ }
607
+
608
+ /* look for end-of-line in current output buffer */
609
+ n = state.state->x.have > left ? left : state.state->x.have;
610
+ eol = (unsigned char *)memchr(state.state->x.next, '\n', n);
611
+ if (eol != NULL)
612
+ n = (unsigned)(eol - state.state->x.next) + 1;
613
+
614
+ /* copy through end-of-line, or remainder if not found */
615
+ memcpy(buf, state.state->x.next, n);
616
+ state.state->x.have -= n;
617
+ state.state->x.next += n;
618
+ state.state->x.pos += n;
619
+ left -= n;
620
+ buf += n;
621
+ } while (left && eol == NULL);
622
+
623
+ /* return terminated string, or if nothing, end of file */
624
+ if (buf == str)
625
+ return NULL;
626
+ buf[0] = 0;
627
+ return str;
628
+ }
629
+
630
+ /* -- see zlib.h -- */
631
+ int ZEXPORT gzdirect(file)
632
+ gzFile file;
633
+ {
634
+ gz_statep state;
635
+
636
+ /* get internal structure */
637
+ if (file == NULL)
638
+ return 0;
639
+ state.file = file;
640
+
641
+ /* if the state is not known, but we can find out, then do so (this is
642
+ mainly for right after a gzopen() or gzdopen()) */
643
+ if (state.state->mode == GZ_READ && state.state->how == LOOK && state.state->x.have == 0)
644
+ (void)gz_look(state);
645
+
646
+ /* return 1 if transparent, 0 if processing a gzip stream */
647
+ return state.state->direct;
648
+ }
649
+
650
+ /* -- see zlib.h -- */
651
+ int ZEXPORT gzclose_r(file)
652
+ gzFile file;
653
+ {
654
+ int ret, err;
655
+ gz_statep state;
656
+
657
+ /* get internal structure */
658
+ if (file == NULL)
659
+ return Z_STREAM_ERROR;
660
+ state.file = file;
661
+
662
+ /* check that we're reading */
663
+ if (state.state->mode != GZ_READ)
664
+ return Z_STREAM_ERROR;
665
+
666
+ /* free memory and close file */
667
+ if (state.state->size) {
668
+ inflateEnd(&(state.state->strm));
669
+ free(state.state->out);
670
+ free(state.state->in);
671
+ }
672
+ err = state.state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
673
+ gz_error(state, Z_OK, NULL);
674
+ free(state.state->path);
675
+ ret = close(state.state->fd);
676
+ free(state.state);
677
+ return ret ? Z_ERRNO : err;
678
+ }