rubysl-zlib 1.0.1 → 2.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +5 -6
  3. data/ext/rubysl/zlib/extconf.rb +3 -1
  4. data/ext/rubysl/zlib/zlib.c +1536 -712
  5. data/lib/rubysl/zlib/version.rb +1 -1
  6. data/rubysl-zlib.gemspec +1 -2
  7. metadata +24 -39
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 39b27bbc346365ead0ddf563ea56a9372313cc9c
4
- data.tar.gz: 7bf396dc0987da9d8382a8d66f34ac5a2c78e48e
3
+ metadata.gz: 5c8834ce05136d4bccc980b8340f08ffdc55b2b8
4
+ data.tar.gz: 89e1a54194e94a79c962cf8e51d97375cc09fcce
5
5
  SHA512:
6
- metadata.gz: 7fb7a56fb838a7df3e2224f9991c560adbff1d53029cf2f7f040453fcb0e26ef8d581164e71f0ce403c2bbd5c3b98cb74fbd4ae299013b3580c2b87c7fc22cbc
7
- data.tar.gz: 46eb5d53032843d1ef59bed5c29bc225151bc871cd88c88ad9c0c73de48ab0e0246fd8e5918d2cfef75429039c29bde0b6d9cbe18a1e0553e3ad2ebcf875e578
6
+ metadata.gz: 89d136000290cdc485aba19fa7608df7ca633502d397c53bf5f1d21dfd4958e0d5cb89d40a746d72b0b9ce45673d866c33c993d44754f7245bc66dbc0c4ad222
7
+ data.tar.gz: 9cfc9b259bc9d8ad304457cda99e27c628dc78bf79ceb7268828c6f6adb3741f2f5c97b354dff6d7d755a0929808b6615684184f5e28b0524a55f70518fb17b9
data/.travis.yml CHANGED
@@ -1,8 +1,7 @@
1
1
  language: ruby
2
- before_install:
3
- - gem update --system
4
- - gem --version
5
- - gem install rubysl-bundler
6
- script: bundle exec mspec spec
2
+ env:
3
+ - RUBYLIB=lib
4
+ script: bundle exec mspec
7
5
  rvm:
8
- - rbx-nightly-18mode
6
+ - 1.9.3
7
+ - rbx-nightly-19mode
data/ext/rubysl/zlib/extconf.rb CHANGED
@@ -1,7 +1,7 @@
1
1
  #
2
2
  # extconf.rb
3
3
  #
4
- # $Id: extconf.rb 16679 2008-05-29 11:23:36Z knu $
4
+ # $Id: extconf.rb 26353 2010-01-19 05:14:29Z usa $
5
5
  #
6
6
 
7
7
  require 'mkmf'
@@ -58,6 +58,8 @@ if %w'z libz zlib1 zlib zdll'.find {|z| have_library(z, 'deflateReset')} and
58
58
 
59
59
  $defs.concat(defines.collect{|d|' -D'+d})
60
60
 
61
+ have_func('crc32_combine', 'zlib.h')
62
+ have_func('adler32_combine', 'zlib.h')
61
63
  have_type('z_crc_t', 'zlib.h')
62
64
 
63
65
  create_makefile('zlib/zlib')
data/ext/rubysl/zlib/zlib.c CHANGED
@@ -3,7 +3,7 @@
3
3
  *
4
4
  * Copyright (C) UENO Katsuhiro 2000-2003
5
5
  *
6
- * $Id: zlib.c 31714 2011-05-23 04:49:42Z shyouhei $
6
+ * $Id: zlib.c 34544 2012-02-10 18:37:45Z naruse $
7
7
  */
8
8
 
9
9
  #define RSTRING_NOT_MODIFIED 1
@@ -11,6 +11,20 @@
11
11
  #include <ruby.h>
12
12
  #include <zlib.h>
13
13
  #include <time.h>
14
+ #include <ruby/io.h>
15
+
16
+ #ifdef HAVE_VALGRIND_MEMCHECK_H
17
+ # include <valgrind/memcheck.h>
18
+ # ifndef VALGRIND_MAKE_MEM_DEFINED
19
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
20
+ # endif
21
+ # ifndef VALGRIND_MAKE_MEM_UNDEFINED
22
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
23
+ # endif
24
+ #else
25
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) /* empty */
26
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) /* empty */
27
+ #endif
14
28
 
15
29
  #define RUBY_ZLIB_VERSION "0.6.0"
16
30
 
@@ -30,166 +44,217 @@
30
44
  #endif
31
45
  #endif
32
46
 
47
+ #if SIZEOF_LONG > SIZEOF_INT
48
+ static inline uInt
49
+ max_uint(long n)
50
+ {
51
+ if (n > UINT_MAX) n = UINT_MAX;
52
+ return (uInt)n;
53
+ }
54
+ #define MAX_UINT(n) max_uint(n)
55
+ #else
56
+ #define MAX_UINT(n) (uInt)(n)
57
+ #endif
58
+
59
+ #define sizeof(x) ((int)sizeof(x))
33
60
 
34
61
  /*--------- Prototypes --------*/
35
62
 
36
- static NORETURN(void raise_zlib_error _((int, const char *)));
37
- static VALUE rb_zlib_version _((VALUE));
38
- static VALUE do_checksum _((int, VALUE*, uLong (*) _((uLong, const Bytef*, uInt))));
39
- static VALUE rb_zlib_adler32 _((int, VALUE*, VALUE));
40
- static VALUE rb_zlib_crc32 _((int, VALUE*, VALUE));
41
- static VALUE rb_zlib_crc_table _((VALUE));
42
- static voidpf zlib_mem_alloc _((voidpf, uInt, uInt));
43
- static void zlib_mem_free _((voidpf, voidpf));
44
- static void finalizer_warn _((const char*));
63
+ static NORETURN(void raise_zlib_error(int, const char*));
64
+ static VALUE rb_zlib_version(VALUE);
65
+ static VALUE do_checksum(int, VALUE*, uLong (*)(uLong, const Bytef*, uInt));
66
+ static VALUE rb_zlib_adler32(int, VALUE*, VALUE);
67
+ static VALUE rb_zlib_crc32(int, VALUE*, VALUE);
68
+ static VALUE rb_zlib_crc_table(VALUE);
69
+ static voidpf zlib_mem_alloc(voidpf, uInt, uInt);
70
+ static void zlib_mem_free(voidpf, voidpf);
71
+ static void finalizer_warn(const char*);
45
72
 
46
73
  struct zstream;
47
74
  struct zstream_funcs;
48
- static void zstream_init _((struct zstream*, const struct zstream_funcs *));
49
- static void zstream_expand_buffer _((struct zstream*));
50
- static void zstream_expand_buffer_into _((struct zstream*, int));
51
- static void zstream_append_buffer _((struct zstream*, const char*, int));
52
- static VALUE zstream_detach_buffer _((struct zstream*));
53
- static VALUE zstream_shift_buffer _((struct zstream*, int));
54
- static void zstream_buffer_ungetc _((struct zstream*, int));
55
- static void zstream_append_input _((struct zstream*, const char*, unsigned int));
56
- static void zstream_discard_input _((struct zstream*, unsigned int));
57
- static void zstream_reset_input _((struct zstream*));
58
- static void zstream_passthrough_input _((struct zstream*));
59
- static VALUE zstream_detach_input _((struct zstream*));
60
- static void zstream_reset _((struct zstream*));
61
- static VALUE zstream_end _((struct zstream*));
62
- static void zstream_run _((struct zstream*, Bytef*, uInt, int));
63
- static VALUE zstream_sync _((struct zstream*, Bytef*, uInt));
64
- static void zstream_mark _((struct zstream*));
65
- static void zstream_free _((struct zstream*));
66
- static VALUE zstream_new _((VALUE, const struct zstream_funcs*));
67
- static struct zstream *get_zstream _((VALUE));
68
- static void zstream_finalize _((struct zstream*));
69
-
70
- static VALUE rb_zstream_end _((VALUE));
71
- static VALUE rb_zstream_reset _((VALUE));
72
- static VALUE rb_zstream_finish _((VALUE));
73
- static VALUE rb_zstream_flush_next_in _((VALUE));
74
- static VALUE rb_zstream_flush_next_out _((VALUE));
75
- static VALUE rb_zstream_avail_out _((VALUE));
76
- static VALUE rb_zstream_set_avail_out _((VALUE, VALUE));
77
- static VALUE rb_zstream_avail_in _((VALUE));
78
- static VALUE rb_zstream_total_in _((VALUE));
79
- static VALUE rb_zstream_total_out _((VALUE));
80
- static VALUE rb_zstream_data_type _((VALUE));
81
- static VALUE rb_zstream_adler _((VALUE));
82
- static VALUE rb_zstream_finished_p _((VALUE));
83
- static VALUE rb_zstream_closed_p _((VALUE));
84
-
85
- static VALUE rb_deflate_s_allocate _((VALUE));
86
- static VALUE rb_deflate_initialize _((int, VALUE*, VALUE));
87
- static VALUE rb_deflate_init_copy _((VALUE, VALUE));
88
- static VALUE deflate_run _((VALUE));
89
- static VALUE rb_deflate_s_deflate _((int, VALUE*, VALUE));
90
- static void do_deflate _((struct zstream*, VALUE, int));
91
- static VALUE rb_deflate_deflate _((int, VALUE*, VALUE));
92
- static VALUE rb_deflate_addstr _((VALUE, VALUE));
93
- static VALUE rb_deflate_flush _((int, VALUE*, VALUE));
94
- static VALUE rb_deflate_params _((VALUE, VALUE, VALUE));
95
- static VALUE rb_deflate_set_dictionary _((VALUE, VALUE));
96
-
97
- static VALUE inflate_run _((VALUE));
98
- static VALUE rb_inflate_s_allocate _((VALUE));
99
- static VALUE rb_inflate_initialize _((int, VALUE*, VALUE));
100
- static VALUE rb_inflate_s_inflate _((VALUE, VALUE));
101
- static void do_inflate _((struct zstream*, VALUE));
102
- static VALUE rb_inflate_inflate _((VALUE, VALUE));
103
- static VALUE rb_inflate_addstr _((VALUE, VALUE));
104
- static VALUE rb_inflate_sync _((VALUE, VALUE));
105
- static VALUE rb_inflate_sync_point_p _((VALUE));
106
- static VALUE rb_inflate_set_dictionary _((VALUE, VALUE));
75
+ static void zstream_init(struct zstream*, const struct zstream_funcs*);
76
+ static void zstream_expand_buffer(struct zstream*);
77
+ static void zstream_expand_buffer_into(struct zstream*, unsigned long);
78
+ static void zstream_append_buffer(struct zstream*, const Bytef*, long);
79
+ static VALUE zstream_detach_buffer(struct zstream*);
80
+ static VALUE zstream_shift_buffer(struct zstream*, long);
81
+ static void zstream_buffer_ungets(struct zstream*, const Bytef*, unsigned long);
82
+ static void zstream_buffer_ungetbyte(struct zstream*, int);
83
+ static void zstream_append_input(struct zstream*, const Bytef*, long);
84
+ static void zstream_discard_input(struct zstream*, long);
85
+ static void zstream_reset_input(struct zstream*);
86
+ static void zstream_passthrough_input(struct zstream*);
87
+ static VALUE zstream_detach_input(struct zstream*);
88
+ static void zstream_reset(struct zstream*);
89
+ static VALUE zstream_end(struct zstream*);
90
+ static void zstream_run(struct zstream*, Bytef*, long, int);
91
+ static VALUE zstream_sync(struct zstream*, Bytef*, long);
92
+ static void zstream_mark(struct zstream*);
93
+ static void zstream_free(struct zstream*);
94
+ static VALUE zstream_new(VALUE, const struct zstream_funcs*);
95
+ static struct zstream *get_zstream(VALUE);
96
+ static void zstream_finalize(struct zstream*);
97
+
98
+ static VALUE rb_zstream_end(VALUE);
99
+ static VALUE rb_zstream_reset(VALUE);
100
+ static VALUE rb_zstream_finish(VALUE);
101
+ static VALUE rb_zstream_flush_next_in(VALUE);
102
+ static VALUE rb_zstream_flush_next_out(VALUE);
103
+ static VALUE rb_zstream_avail_out(VALUE);
104
+ static VALUE rb_zstream_set_avail_out(VALUE, VALUE);
105
+ static VALUE rb_zstream_avail_in(VALUE);
106
+ static VALUE rb_zstream_total_in(VALUE);
107
+ static VALUE rb_zstream_total_out(VALUE);
108
+ static VALUE rb_zstream_data_type(VALUE);
109
+ static VALUE rb_zstream_adler(VALUE);
110
+ static VALUE rb_zstream_finished_p(VALUE);
111
+ static VALUE rb_zstream_closed_p(VALUE);
112
+
113
+ static VALUE rb_deflate_s_allocate(VALUE);
114
+ static VALUE rb_deflate_initialize(int, VALUE*, VALUE);
115
+ static VALUE rb_deflate_init_copy(VALUE, VALUE);
116
+ static VALUE deflate_run(VALUE);
117
+ static VALUE rb_deflate_s_deflate(int, VALUE*, VALUE);
118
+ static void do_deflate(struct zstream*, VALUE, int);
119
+ static VALUE rb_deflate_deflate(int, VALUE*, VALUE);
120
+ static VALUE rb_deflate_addstr(VALUE, VALUE);
121
+ static VALUE rb_deflate_flush(int, VALUE*, VALUE);
122
+ static VALUE rb_deflate_params(VALUE, VALUE, VALUE);
123
+ static VALUE rb_deflate_set_dictionary(VALUE, VALUE);
124
+
125
+ static VALUE inflate_run(VALUE);
126
+ static VALUE rb_inflate_s_allocate(VALUE);
127
+ static VALUE rb_inflate_initialize(int, VALUE*, VALUE);
128
+ static VALUE rb_inflate_s_inflate(VALUE, VALUE);
129
+ static void do_inflate(struct zstream*, VALUE);
130
+ static VALUE rb_inflate_inflate(VALUE, VALUE);
131
+ static VALUE rb_inflate_addstr(VALUE, VALUE);
132
+ static VALUE rb_inflate_sync(VALUE, VALUE);
133
+ static VALUE rb_inflate_sync_point_p(VALUE);
134
+ static VALUE rb_inflate_set_dictionary(VALUE, VALUE);
107
135
 
108
136
  #if GZIP_SUPPORT
109
137
  struct gzfile;
110
- static void gzfile_mark _((struct gzfile*));
111
- static void gzfile_free _((struct gzfile*));
112
- static VALUE gzfile_new _((VALUE, const struct zstream_funcs*, void (*) _((struct gzfile*))));
113
- static void gzfile_reset _((struct gzfile*));
114
- static void gzfile_close _((struct gzfile*, int));
115
- static void gzfile_write_raw _((struct gzfile*));
116
- static VALUE gzfile_read_raw _((struct gzfile*));
117
- static int gzfile_read_raw_ensure _((struct gzfile*, int));
118
- static char *gzfile_read_raw_until_zero _((struct gzfile*, long));
119
- static unsigned int gzfile_get16 _((const unsigned char*));
120
- static unsigned long gzfile_get32 _((const unsigned char*));
121
- static void gzfile_set32 _((unsigned long n, unsigned char*));
122
- static void gzfile_make_header _((struct gzfile*));
123
- static void gzfile_make_footer _((struct gzfile*));
124
- static void gzfile_read_header _((struct gzfile*));
125
- static void gzfile_check_footer _((struct gzfile*));
126
- static void gzfile_write _((struct gzfile*, Bytef*, uInt));
127
- static long gzfile_read_more _((struct gzfile*));
128
- static void gzfile_calc_crc _((struct gzfile*, VALUE));
129
- static VALUE gzfile_read _((struct gzfile*, int));
130
- static VALUE gzfile_read_all _((struct gzfile*));
131
- static void gzfile_ungetc _((struct gzfile*, int));
132
- static VALUE gzfile_writer_end_run _((VALUE));
133
- static void gzfile_writer_end _((struct gzfile*));
134
- static VALUE gzfile_reader_end_run _((VALUE));
135
- static void gzfile_reader_end _((struct gzfile*));
136
- static void gzfile_reader_rewind _((struct gzfile*));
137
- static VALUE gzfile_reader_get_unused _((struct gzfile*));
138
- static struct gzfile *get_gzfile _((VALUE));
139
- static VALUE gzfile_ensure_close _((VALUE));
140
- static VALUE rb_gzfile_s_wrap _((int, VALUE*, VALUE));
141
- static VALUE gzfile_s_open _((int, VALUE*, VALUE, const char*));
142
-
143
- static VALUE rb_gzfile_to_io _((VALUE));
144
- static VALUE rb_gzfile_crc _((VALUE));
145
- static VALUE rb_gzfile_mtime _((VALUE));
146
- static VALUE rb_gzfile_level _((VALUE));
147
- static VALUE rb_gzfile_os_code _((VALUE));
148
- static VALUE rb_gzfile_orig_name _((VALUE));
149
- static VALUE rb_gzfile_comment _((VALUE));
150
- static VALUE rb_gzfile_lineno _((VALUE));
151
- static VALUE rb_gzfile_set_lineno _((VALUE, VALUE));
152
- static VALUE rb_gzfile_set_mtime _((VALUE, VALUE));
153
- static VALUE rb_gzfile_set_orig_name _((VALUE, VALUE));
154
- static VALUE rb_gzfile_set_comment _((VALUE, VALUE));
155
- static VALUE rb_gzfile_close _((VALUE));
156
- static VALUE rb_gzfile_finish _((VALUE));
157
- static VALUE rb_gzfile_closed_p _((VALUE));
158
- static VALUE rb_gzfile_eof_p _((VALUE));
159
- static VALUE rb_gzfile_sync _((VALUE));
160
- static VALUE rb_gzfile_set_sync _((VALUE, VALUE));
161
- static VALUE rb_gzfile_total_in _((VALUE));
162
- static VALUE rb_gzfile_total_out _((VALUE));
163
-
164
- static VALUE rb_gzwriter_s_allocate _((VALUE));
165
- static VALUE rb_gzwriter_s_open _((int, VALUE*, VALUE));
166
- static VALUE rb_gzwriter_initialize _((int, VALUE*, VALUE));
167
- static VALUE rb_gzwriter_flush _((int, VALUE*, VALUE));
168
- static VALUE rb_gzwriter_write _((VALUE, VALUE));
169
- static VALUE rb_gzwriter_putc _((VALUE, VALUE));
170
-
171
- static VALUE rb_gzreader_s_allocate _((VALUE));
172
- static VALUE rb_gzreader_s_open _((int, VALUE*, VALUE));
173
- static VALUE rb_gzreader_initialize _((VALUE, VALUE));
174
- static VALUE rb_gzreader_rewind _((VALUE));
175
- static VALUE rb_gzreader_unused _((VALUE));
176
- static VALUE rb_gzreader_read _((int, VALUE*, VALUE));
177
- static VALUE rb_gzreader_getc _((VALUE));
178
- static VALUE rb_gzreader_readchar _((VALUE));
179
- static VALUE rb_gzreader_each_byte _((VALUE));
180
- static VALUE rb_gzreader_ungetc _((VALUE, VALUE));
181
- static void gzreader_skip_linebreaks _((struct gzfile*));
182
- static VALUE gzreader_gets _((int, VALUE*, VALUE));
183
- static VALUE rb_gzreader_gets _((int, VALUE*, VALUE));
184
- static VALUE rb_gzreader_readline _((int, VALUE*, VALUE));
185
- static VALUE rb_gzreader_each _((int, VALUE*, VALUE));
186
- static VALUE rb_gzreader_readlines _((int, VALUE*, VALUE));
138
+ static void gzfile_mark(struct gzfile*);
139
+ static void gzfile_free(struct gzfile*);
140
+ static VALUE gzfile_new(VALUE, const struct zstream_funcs*, void (*) _((struct gzfile*)));
141
+ static void gzfile_reset(struct gzfile*);
142
+ static void gzfile_close(struct gzfile*, int);
143
+ static void gzfile_write_raw(struct gzfile*);
144
+ static VALUE gzfile_read_raw_partial(VALUE);
145
+ static VALUE gzfile_read_raw_rescue(VALUE);
146
+ static VALUE gzfile_read_raw(struct gzfile*);
147
+ static int gzfile_read_raw_ensure(struct gzfile*, long);
148
+ static char *gzfile_read_raw_until_zero(struct gzfile*, long);
149
+ static unsigned int gzfile_get16(const unsigned char*);
150
+ static unsigned long gzfile_get32(const unsigned char*);
151
+ static void gzfile_set32(unsigned long n, unsigned char*);
152
+ static void gzfile_make_header(struct gzfile*);
153
+ static void gzfile_make_footer(struct gzfile*);
154
+ static void gzfile_read_header(struct gzfile*);
155
+ static void gzfile_check_footer(struct gzfile*);
156
+ static void gzfile_write(struct gzfile*, Bytef*, long);
157
+ static long gzfile_read_more(struct gzfile*);
158
+ static void gzfile_calc_crc(struct gzfile*, VALUE);
159
+ static VALUE gzfile_read(struct gzfile*, long);
160
+ static VALUE gzfile_read_all(struct gzfile*);
161
+ static void gzfile_ungets(struct gzfile*, const Bytef*, long);
162
+ static void gzfile_ungetbyte(struct gzfile*, int);
163
+ static VALUE gzfile_writer_end_run(VALUE);
164
+ static void gzfile_writer_end(struct gzfile*);
165
+ static VALUE gzfile_reader_end_run(VALUE);
166
+ static void gzfile_reader_end(struct gzfile*);
167
+ static void gzfile_reader_rewind(struct gzfile*);
168
+ static VALUE gzfile_reader_get_unused(struct gzfile*);
169
+ static struct gzfile *get_gzfile(VALUE);
170
+ static VALUE gzfile_ensure_close(VALUE);
171
+ static VALUE rb_gzfile_s_wrap(int, VALUE*, VALUE);
172
+ static VALUE gzfile_s_open(int, VALUE*, VALUE, const char*);
173
+ NORETURN(static void gzfile_raise(struct gzfile *, VALUE, const char *));
174
+ static VALUE gzfile_error_inspect(VALUE);
175
+
176
+ static VALUE rb_gzfile_to_io(VALUE);
177
+ static VALUE rb_gzfile_crc(VALUE);
178
+ static VALUE rb_gzfile_mtime(VALUE);
179
+ static VALUE rb_gzfile_level(VALUE);
180
+ static VALUE rb_gzfile_os_code(VALUE);
181
+ static VALUE rb_gzfile_orig_name(VALUE);
182
+ static VALUE rb_gzfile_comment(VALUE);
183
+ static VALUE rb_gzfile_lineno(VALUE);
184
+ static VALUE rb_gzfile_set_lineno(VALUE, VALUE);
185
+ static VALUE rb_gzfile_set_mtime(VALUE, VALUE);
186
+ static VALUE rb_gzfile_set_orig_name(VALUE, VALUE);
187
+ static VALUE rb_gzfile_set_comment(VALUE, VALUE);
188
+ static VALUE rb_gzfile_close(VALUE);
189
+ static VALUE rb_gzfile_finish(VALUE);
190
+ static VALUE rb_gzfile_closed_p(VALUE);
191
+ static VALUE rb_gzfile_eof_p(VALUE);
192
+ static VALUE rb_gzfile_sync(VALUE);
193
+ static VALUE rb_gzfile_set_sync(VALUE, VALUE);
194
+ static VALUE rb_gzfile_total_in(VALUE);
195
+ static VALUE rb_gzfile_total_out(VALUE);
196
+ static VALUE rb_gzfile_path(VALUE);
197
+
198
+ static VALUE rb_gzwriter_s_allocate(VALUE);
199
+ static VALUE rb_gzwriter_s_open(int, VALUE*, VALUE);
200
+ static VALUE rb_gzwriter_initialize(int, VALUE*, VALUE);
201
+ static VALUE rb_gzwriter_flush(int, VALUE*, VALUE);
202
+ static VALUE rb_gzwriter_write(VALUE, VALUE);
203
+ static VALUE rb_gzwriter_putc(VALUE, VALUE);
204
+
205
+ static VALUE rb_gzreader_s_allocate(VALUE);
206
+ static VALUE rb_gzreader_s_open(int, VALUE*, VALUE);
207
+ static VALUE rb_gzreader_initialize(int, VALUE*, VALUE);
208
+ static VALUE rb_gzreader_rewind(VALUE);
209
+ static VALUE rb_gzreader_unused(VALUE);
210
+ static VALUE rb_gzreader_read(int, VALUE*, VALUE);
211
+ static VALUE rb_gzreader_getc(VALUE);
212
+ static VALUE rb_gzreader_readchar(VALUE);
213
+ static VALUE rb_gzreader_each_byte(VALUE);
214
+ static VALUE rb_gzreader_ungetc(VALUE, VALUE);
215
+ static VALUE rb_gzreader_ungetbyte(VALUE, VALUE);
216
+ static void gzreader_skip_linebreaks(struct gzfile*);
217
+ static VALUE gzreader_gets(int, VALUE*, VALUE);
218
+ static VALUE rb_gzreader_gets(int, VALUE*, VALUE);
219
+ static VALUE rb_gzreader_readline(int, VALUE*, VALUE);
220
+ static VALUE rb_gzreader_each(int, VALUE*, VALUE);
221
+ static VALUE rb_gzreader_readlines(int, VALUE*, VALUE);
187
222
  #endif /* GZIP_SUPPORT */
188
223
 
189
-
190
- void Init_zlib _((void));
191
-
192
-
224
+ /*
225
+ * Document-module: Zlib
226
+ *
227
+ * == Overview
228
+ *
229
+ * Access to the zlib library.
230
+ *
231
+ * == Class tree
232
+ *
233
+ * - Zlib::Deflate
234
+ * - Zlib::Inflate
235
+ * - Zlib::ZStream
236
+ * - Zlib::Error
237
+ * - Zlib::StreamEnd
238
+ * - Zlib::NeedDict
239
+ * - Zlib::DataError
240
+ * - Zlib::StreamError
241
+ * - Zlib::MemError
242
+ * - Zlib::BufError
243
+ * - Zlib::VersionError
244
+ *
245
+ * (if you have GZIP_SUPPORT)
246
+ * - Zlib::GzipReader
247
+ * - Zlib::GzipWriter
248
+ * - Zlib::GzipFile
249
+ * - Zlib::GzipFile::Error
250
+ * - Zlib::GzipFile::LengthError
251
+ * - Zlib::GzipFile::CRCError
252
+ * - Zlib::GzipFile::NoFooter
253
+ *
254
+ * see also zlib.h
255
+ *
256
+ */
257
+ void Init_zlib(void);
193
258
 
194
259
  /*--------- Exceptions --------*/
195
260
 
@@ -197,9 +262,7 @@ static VALUE cZError, cStreamEnd, cNeedDict;
197
262
  static VALUE cStreamError, cDataError, cMemError, cBufError, cVersionError;
198
263
 
199
264
  static void
200
- raise_zlib_error(err, msg)
201
- int err;
202
- const char *msg;
265
+ raise_zlib_error(int err, const char *msg)
203
266
  {
204
267
  VALUE exc;
205
268
 
@@ -247,8 +310,7 @@ raise_zlib_error(err, msg)
247
310
  /*--- Warning (in finalizer) ---*/
248
311
 
249
312
  static void
250
- finalizer_warn(msg)
251
- const char *msg;
313
+ finalizer_warn(const char *msg)
252
314
  {
253
315
  fprintf(stderr, "zlib(finalizer): %s\n", msg);
254
316
  }
@@ -257,11 +319,12 @@ finalizer_warn(msg)
257
319
  /*-------- module Zlib --------*/
258
320
 
259
321
  /*
322
+ * Document-method: Zlib.zlib_version
323
+ *
260
324
  * Returns the string which represents the version of zlib library.
261
325
  */
262
326
  static VALUE
263
- rb_zlib_version(klass)
264
- VALUE klass;
327
+ rb_zlib_version(VALUE klass)
265
328
  {
266
329
  VALUE str;
267
330
 
@@ -270,11 +333,29 @@ rb_zlib_version(klass)
270
333
  return str;
271
334
  }
272
335
 
336
+ #if SIZEOF_LONG > SIZEOF_INT
337
+ static uLong
338
+ checksum_long(uLong (*func)(uLong, const Bytef*, uInt), uLong sum, const Bytef *ptr, long len)
339
+ {
340
+ if (len > UINT_MAX) {
341
+ do {
342
+ sum = func(sum, ptr, UINT_MAX);
343
+ ptr += UINT_MAX;
344
+ len -= UINT_MAX;
345
+ } while (len >= UINT_MAX);
346
+ }
347
+ if (len > 0) sum = func(sum, ptr, (uInt)len);
348
+ return sum;
349
+ }
350
+ #else
351
+ #define checksum_long(func, sum, ptr, len) (func)((sum), (ptr), (len))
352
+ #endif
353
+
273
354
  static VALUE
274
355
  do_checksum(argc, argv, func)
275
356
  int argc;
276
357
  VALUE *argv;
277
- uLong (*func) _((uLong, const Bytef *, uInt));
358
+ uLong (*func)(uLong, const Bytef*, uInt);
278
359
  {
279
360
  VALUE str, vsum;
280
361
  unsigned long sum;
@@ -296,12 +377,14 @@ do_checksum(argc, argv, func)
296
377
  }
297
378
  else {
298
379
  StringValue(str);
299
- sum = func(sum, RSTRING(str)->ptr, RSTRING(str)->len);
380
+ sum = checksum_long(func, sum, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
300
381
  }
301
382
  return rb_uint2inum(sum);
302
383
  }
303
384
 
304
385
  /*
386
+ * Document-method: Zlib.adler32
387
+ *
305
388
  * call-seq: Zlib.adler32(string, adler)
306
389
  *
307
390
  * Calculates Adler-32 checksum for +string+, and returns updated value of
@@ -311,15 +394,35 @@ do_checksum(argc, argv, func)
311
394
  * FIXME: expression.
312
395
  */
313
396
  static VALUE
314
- rb_zlib_adler32(argc, argv, klass)
315
- int argc;
316
- VALUE *argv;
317
- VALUE klass;
397
+ rb_zlib_adler32(int argc, VALUE *argv, VALUE klass)
318
398
  {
319
399
  return do_checksum(argc, argv, adler32);
320
400
  }
321
401
 
402
+ #ifdef HAVE_ADLER32_COMBINE
322
403
  /*
404
+ * Document-method: Zlib.adler32_combine
405
+ *
406
+ * call-seq: Zlib.adler32_combine(adler1, adler2, len2)
407
+ *
408
+ * Combine two Adler-32 check values in to one. +alder1+ is the first Adler-32
409
+ * value, +adler2+ is the second Adler-32 value. +len2+ is the length of the
410
+ * string used to generate +adler2+.
411
+ *
412
+ */
413
+ static VALUE
414
+ rb_zlib_adler32_combine(VALUE klass, VALUE adler1, VALUE adler2, VALUE len2)
415
+ {
416
+ return ULONG2NUM(
417
+ adler32_combine(NUM2ULONG(adler1), NUM2ULONG(adler2), NUM2LONG(len2)));
418
+ }
419
+ #else
420
+ #define rb_zlib_adler32_combine rb_f_notimplement
421
+ #endif
422
+
423
+ /*
424
+ * Document-method: Zlib.crc32
425
+ *
323
426
  * call-seq: Zlib.crc32(string, adler)
324
427
  *
325
428
  * Calculates CRC checksum for +string+, and returns updated value of +crc+. If
@@ -329,20 +432,39 @@ rb_zlib_adler32(argc, argv, klass)
329
432
  * FIXME: expression.
330
433
  */
331
434
  static VALUE
332
- rb_zlib_crc32(argc, argv, klass)
333
- int argc;
334
- VALUE *argv;
335
- VALUE klass;
435
+ rb_zlib_crc32(int argc, VALUE *argv, VALUE klass)
336
436
  {
337
437
  return do_checksum(argc, argv, crc32);
338
438
  }
339
439
 
440
+ #ifdef HAVE_CRC32_COMBINE
441
+ /*
442
+ * Document-method: Zlib.crc32_combine
443
+ *
444
+ * call-seq: Zlib.crc32_combine(crc1, crc2, len2)
445
+ *
446
+ * Combine two CRC-32 check values in to one. +crc1+ is the first CRC-32
447
+ * value, +crc2+ is the second CRC-32 value. +len2+ is the length of the
448
+ * string used to generate +crc2+.
449
+ *
450
+ */
451
+ static VALUE
452
+ rb_zlib_crc32_combine(VALUE klass, VALUE crc1, VALUE crc2, VALUE len2)
453
+ {
454
+ return ULONG2NUM(
455
+ crc32_combine(NUM2ULONG(crc1), NUM2ULONG(crc2), NUM2LONG(len2)));
456
+ }
457
+ #else
458
+ #define rb_zlib_crc32_combine rb_f_notimplement
459
+ #endif
460
+
340
461
  /*
462
+ * Document-method: Zlib.crc_table
463
+ *
341
464
  * Returns the table for calculating CRC checksum as an array.
342
465
  */
343
466
  static VALUE
344
- rb_zlib_crc_table(obj)
345
- VALUE obj;
467
+ rb_zlib_crc_table(VALUE obj)
346
468
  {
347
469
  #if !defined(HAVE_TYPE_Z_CRC_T)
348
470
  /* z_crc_t is defined since zlib-1.2.7. */
@@ -372,9 +494,9 @@ struct zstream {
372
494
  VALUE input;
373
495
  z_stream stream;
374
496
  const struct zstream_funcs {
375
- int (*reset) _((z_streamp));
376
- int (*end) _((z_streamp));
377
- int (*run) _((z_streamp, int));
497
+ int (*reset)(z_streamp);
498
+ int (*end)(z_streamp);
499
+ int (*run)(z_streamp, int);
378
500
  } *func;
379
501
  };
380
502
 
@@ -405,24 +527,25 @@ static const struct zstream_funcs inflate_funcs = {
405
527
 
406
528
 
407
529
  static voidpf
408
- zlib_mem_alloc(opaque, items, size)
409
- voidpf opaque;
410
- uInt items, size;
411
- {
412
- return xmalloc(items * size);
530
+ zlib_mem_alloc(voidpf opaque, uInt items, uInt size)
531
+ {
532
+ voidpf p = xmalloc(items * size);
533
+ /* zlib FAQ: Valgrind (or some similar memory access checker) says that
534
+ deflate is performing a conditional jump that depends on an
535
+ uninitialized value. Isn't that a bug?
536
+ http://www.zlib.net/zlib_faq.html#faq36 */
537
+ VALGRIND_MAKE_MEM_DEFINED(p, items * size);
538
+ return p;
413
539
  }
414
540
 
415
541
  static void
416
- zlib_mem_free(opaque, address)
417
- voidpf opaque, address;
542
+ zlib_mem_free(voidpf opaque, voidpf address)
418
543
  {
419
- free(address);
544
+ xfree(address);
420
545
  }
421
546
 
422
547
  static void
423
- zstream_init(z, func)
424
- struct zstream *z;
425
- const struct zstream_funcs *func;
548
+ zstream_init(struct zstream *z, const struct zstream_funcs *func)
426
549
  {
427
550
  z->flags = 0;
428
551
  z->buf = Qnil;
@@ -443,8 +566,7 @@ zstream_init(z, func)
443
566
  #define zstream_init_inflate(z) zstream_init((z), &inflate_funcs)
444
567
 
445
568
  static void
446
- zstream_expand_buffer(z)
447
- struct zstream *z;
569
+ zstream_expand_buffer(struct zstream *z)
448
570
  {
449
571
  long inc;
450
572
 
@@ -453,12 +575,12 @@ zstream_expand_buffer(z)
453
575
  rb_str_buf_new makes a zero-length string. */
454
576
  z->buf = rb_str_new(0, ZSTREAM_INITIAL_BUFSIZE);
455
577
  z->buf_filled = 0;
456
- z->stream.next_out = RSTRING(z->buf)->ptr;
578
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
457
579
  z->stream.avail_out = ZSTREAM_INITIAL_BUFSIZE;
458
580
  return;
459
581
  }
460
582
 
461
- if (RSTRING(z->buf)->len - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
583
+ if (RSTRING_LEN(z->buf) - z->buf_filled >= ZSTREAM_AVAIL_OUT_STEP_MAX) {
462
584
  /* to keep other threads from freezing */
463
585
  z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
464
586
  }
@@ -469,69 +591,63 @@ zstream_expand_buffer(z)
469
591
  }
470
592
  rb_str_resize(z->buf, z->buf_filled + inc);
471
593
  z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
472
- inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
594
+ (int)inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
473
595
  }
474
- z->stream.next_out = RSTRING(z->buf)->ptr + z->buf_filled;
596
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
475
597
  }
476
598
 
477
599
  static void
478
- zstream_expand_buffer_into(z, size)
479
- struct zstream *z;
480
- int size;
600
+ zstream_expand_buffer_into(struct zstream *z, unsigned long size)
481
601
  {
482
602
  if (NIL_P(z->buf)) {
483
603
  /* I uses rb_str_new here not rb_str_buf_new because
484
604
  rb_str_buf_new makes a zero-length string. */
485
605
  z->buf = rb_str_new(0, size);
486
606
  z->buf_filled = 0;
487
- z->stream.next_out = RSTRING(z->buf)->ptr;
488
- z->stream.avail_out = size;
607
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
608
+ z->stream.avail_out = MAX_UINT(size);
489
609
  }
490
610
  else if (z->stream.avail_out != size) {
491
611
  rb_str_resize(z->buf, z->buf_filled + size);
492
- z->stream.next_out = RSTRING(z->buf)->ptr + z->buf_filled;
493
- z->stream.avail_out = size;
612
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
613
+ z->stream.avail_out = MAX_UINT(size);
494
614
  }
495
615
  }
496
616
 
497
617
  static void
498
- zstream_append_buffer(z, src, len)
499
- struct zstream *z;
500
- const char *src;
501
- int len;
618
+ zstream_append_buffer(struct zstream *z, const Bytef *src, long len)
502
619
  {
503
620
  if (NIL_P(z->buf)) {
504
621
  z->buf = rb_str_buf_new(len);
505
- rb_str_buf_cat(z->buf, src, len);
622
+ rb_str_buf_cat(z->buf, (const char*)src, len);
506
623
  z->buf_filled = len;
507
- z->stream.next_out = RSTRING(z->buf)->ptr;
624
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf);
508
625
  z->stream.avail_out = 0;
509
626
  return;
510
627
  }
511
628
 
512
- if (RSTRING(z->buf)->len < z->buf_filled + len) {
629
+ if (RSTRING_LEN(z->buf) < z->buf_filled + len) {
513
630
  rb_str_resize(z->buf, z->buf_filled + len);
514
631
  z->stream.avail_out = 0;
515
632
  }
516
633
  else {
517
- if (z->stream.avail_out >= len) {
518
- z->stream.avail_out -= len;
634
+ if (z->stream.avail_out >= (uInt)len) {
635
+ z->stream.avail_out -= (uInt)len;
519
636
  }
520
637
  else {
521
638
  z->stream.avail_out = 0;
522
639
  }
523
640
  }
524
- memcpy(RSTRING(z->buf)->ptr + z->buf_filled, src, len);
641
+ memcpy(RSTRING_PTR(z->buf) + z->buf_filled, src, len);
525
642
  z->buf_filled += len;
526
- z->stream.next_out = RSTRING(z->buf)->ptr + z->buf_filled;
643
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
527
644
  }
528
645
 
529
646
  #define zstream_append_buffer2(z,v) \
530
- zstream_append_buffer((z),RSTRING(v)->ptr,RSTRING(v)->len)
647
+ zstream_append_buffer((z),(Bytef*)RSTRING_PTR(v),RSTRING_LEN(v))
531
648
 
532
649
  static VALUE
533
- zstream_detach_buffer(z)
534
- struct zstream *z;
650
+ zstream_detach_buffer(struct zstream *z)
535
651
  {
536
652
  VALUE dst;
537
653
 
@@ -551,40 +667,55 @@ zstream_detach_buffer(z)
551
667
  }
552
668
 
553
669
  static VALUE
554
- zstream_shift_buffer(z, len)
555
- struct zstream *z;
556
- int len;
670
+ zstream_shift_buffer(struct zstream *z, long len)
557
671
  {
558
672
  VALUE dst;
673
+ long buflen;
559
674
 
560
675
  if (z->buf_filled <= len) {
561
676
  return zstream_detach_buffer(z);
562
677
  }
563
678
 
564
- dst = rb_str_substr(z->buf, 0, len);
679
+ dst = rb_str_subseq(z->buf, 0, len);
565
680
  z->buf_filled -= len;
566
- memmove(RSTRING(z->buf)->ptr, RSTRING(z->buf)->ptr + len,
681
+ memmove(RSTRING_PTR(z->buf), RSTRING_PTR(z->buf) + len,
567
682
  z->buf_filled);
568
- z->stream.next_out = RSTRING(z->buf)->ptr + z->buf_filled;
569
- z->stream.avail_out = RSTRING(z->buf)->len - z->buf_filled;
570
- if (z->stream.avail_out > ZSTREAM_AVAIL_OUT_STEP_MAX) {
571
- z->stream.avail_out = ZSTREAM_AVAIL_OUT_STEP_MAX;
683
+ z->stream.next_out = (Bytef*)RSTRING_PTR(z->buf) + z->buf_filled;
684
+ buflen = RSTRING_LEN(z->buf) - z->buf_filled;
685
+ if (buflen > ZSTREAM_AVAIL_OUT_STEP_MAX) {
686
+ buflen = ZSTREAM_AVAIL_OUT_STEP_MAX;
572
687
  }
688
+ z->stream.avail_out = (uInt)buflen;
573
689
 
574
690
  return dst;
575
691
  }
576
692
 
577
693
  static void
578
- zstream_buffer_ungetc(z, c)
579
- struct zstream *z;
580
- int c;
694
+ zstream_buffer_ungets(struct zstream *z, const Bytef *b, unsigned long len)
695
+ {
696
+ if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
697
+ zstream_expand_buffer_into(z, len);
698
+ }
699
+
700
+ memmove(RSTRING_PTR(z->buf) + len, RSTRING_PTR(z->buf), z->buf_filled);
701
+ memmove(RSTRING_PTR(z->buf), b, len);
702
+ z->buf_filled+=len;
703
+ if (z->stream.avail_out > 0) {
704
+ if (len > z->stream.avail_out) len = z->stream.avail_out;
705
+ z->stream.next_out+=len;
706
+ z->stream.avail_out-=(uInt)len;
707
+ }
708
+ }
709
+
710
+ static void
711
+ zstream_buffer_ungetbyte(struct zstream *z, int c)
581
712
  {
582
- if (NIL_P(z->buf) || RSTRING(z->buf)->len - z->buf_filled == 0) {
713
+ if (NIL_P(z->buf) || RSTRING_LEN(z->buf) - z->buf_filled == 0) {
583
714
  zstream_expand_buffer(z);
584
715
  }
585
716
 
586
- memmove(RSTRING(z->buf)->ptr + 1, RSTRING(z->buf)->ptr, z->buf_filled);
587
- RSTRING(z->buf)->ptr[0] = (char)c;
717
+ memmove(RSTRING_PTR(z->buf) + 1, RSTRING_PTR(z->buf), z->buf_filled);
718
+ RSTRING_PTR(z->buf)[0] = (char)c;
588
719
  z->buf_filled++;
589
720
  if (z->stream.avail_out > 0) {
590
721
  z->stream.next_out++;
@@ -593,51 +724,44 @@ zstream_buffer_ungetc(z, c)
593
724
  }
594
725
 
595
726
  static void
596
- zstream_append_input(z, src, len)
597
- struct zstream *z;
598
- const char *src;
599
- unsigned int len;
727
+ zstream_append_input(struct zstream *z, const Bytef *src, long len)
600
728
  {
601
729
  if (len <= 0) return;
602
730
 
603
731
  if (NIL_P(z->input)) {
604
732
  z->input = rb_str_buf_new(len);
605
- rb_str_buf_cat(z->input, src, len);
733
+ rb_str_buf_cat(z->input, (const char*)src, len);
606
734
  }
607
735
  else {
608
- rb_str_buf_cat(z->input, src, len);
736
+ rb_str_buf_cat(z->input, (const char*)src, len);
609
737
  }
610
738
  }
611
739
 
612
740
  #define zstream_append_input2(z,v)\
613
- RB_GC_GUARD(v),\
741
+ RB_GC_GUARD(v) = v,\
614
742
  zstream_append_input((z), (Bytef*)RSTRING_PTR(v), RSTRING_LEN(v))
615
743
 
616
744
  static void
617
- zstream_discard_input(z, len)
618
- struct zstream *z;
619
- unsigned int len;
745
+ zstream_discard_input(struct zstream *z, long len)
620
746
  {
621
- if (NIL_P(z->input) || RSTRING(z->input)->len <= len) {
747
+ if (NIL_P(z->input) || RSTRING_LEN(z->input) <= len) {
622
748
  z->input = Qnil;
623
749
  }
624
750
  else {
625
- memmove(RSTRING(z->input)->ptr, RSTRING(z->input)->ptr + len,
626
- RSTRING(z->input)->len - len);
627
- rb_str_resize(z->input, RSTRING(z->input)->len - len);
751
+ memmove(RSTRING_PTR(z->input), RSTRING_PTR(z->input) + len,
752
+ RSTRING_LEN(z->input) - len);
753
+ rb_str_resize(z->input, RSTRING_LEN(z->input) - len);
628
754
  }
629
755
  }
630
756
 
631
757
  static void
632
- zstream_reset_input(z)
633
- struct zstream *z;
758
+ zstream_reset_input(struct zstream *z)
634
759
  {
635
760
  z->input = Qnil;
636
761
  }
637
762
 
638
763
  static void
639
- zstream_passthrough_input(z)
640
- struct zstream *z;
764
+ zstream_passthrough_input(struct zstream *z)
641
765
  {
642
766
  if (!NIL_P(z->input)) {
643
767
  zstream_append_buffer2(z, z->input);
@@ -646,8 +770,7 @@ zstream_passthrough_input(z)
646
770
  }
647
771
 
648
772
  static VALUE
649
- zstream_detach_input(z)
650
- struct zstream *z;
773
+ zstream_detach_input(struct zstream *z)
651
774
  {
652
775
  VALUE dst;
653
776
 
@@ -662,8 +785,7 @@ zstream_detach_input(z)
662
785
  }
663
786
 
664
787
  static void
665
- zstream_reset(z)
666
- struct zstream *z;
788
+ zstream_reset(struct zstream *z)
667
789
  {
668
790
  int err;
669
791
 
@@ -680,8 +802,7 @@ zstream_reset(z)
680
802
  }
681
803
 
682
804
  static VALUE
683
- zstream_end(z)
684
- struct zstream *z;
805
+ zstream_end(struct zstream *z)
685
806
  {
686
807
  int err;
687
808
 
@@ -704,24 +825,20 @@ zstream_end(z)
704
825
  }
705
826
 
706
827
  static void
707
- zstream_run(z, src, len, flush)
708
- struct zstream *z;
709
- Bytef *src;
710
- uInt len;
711
- int flush;
828
+ zstream_run(struct zstream *z, Bytef *src, long len, int flush)
712
829
  {
713
830
  uInt n;
714
831
  int err;
715
- volatile VALUE guard;
832
+ volatile VALUE guard = Qnil;
716
833
 
717
834
  if (NIL_P(z->input) && len == 0) {
718
- z->stream.next_in = "";
835
+ z->stream.next_in = (Bytef*)"";
719
836
  z->stream.avail_in = 0;
720
837
  }
721
838
  else {
722
839
  zstream_append_input(z, src, len);
723
- z->stream.next_in = RSTRING(z->input)->ptr;
724
- z->stream.avail_in = RSTRING(z->input)->len;
840
+ z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
841
+ z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
725
842
  /* keep reference to `z->input' so as not to be garbage collected
726
843
  after zstream_reset_input() and prevent `z->stream.next_in'
727
844
  from dangling. */
@@ -735,7 +852,7 @@ zstream_run(z, src, len, flush)
735
852
  for (;;) {
736
853
  /* VC allocates err and guard to same address. accessing err and guard
737
854
  in same scope prevents it. */
738
- RB_GC_GUARD(guard);
855
+ RB_GC_GUARD(guard) = guard;
739
856
  n = z->stream.avail_out;
740
857
  err = z->func->run(&z->stream, flush);
741
858
  z->buf_filled += n - z->stream.avail_out;
@@ -773,27 +890,24 @@ zstream_run(z, src, len, flush)
773
890
  }
774
891
 
775
892
  static VALUE
776
- zstream_sync(z, src, len)
777
- struct zstream *z;
778
- Bytef *src;
779
- uInt len;
893
+ zstream_sync(struct zstream *z, Bytef *src, long len)
780
894
  {
781
895
  VALUE rest;
782
896
  int err;
783
897
 
784
898
  if (!NIL_P(z->input)) {
785
- z->stream.next_in = RSTRING(z->input)->ptr;
786
- z->stream.avail_in = RSTRING(z->input)->len;
899
+ z->stream.next_in = (Bytef*)RSTRING_PTR(z->input);
900
+ z->stream.avail_in = MAX_UINT(RSTRING_LEN(z->input));
787
901
  err = inflateSync(&z->stream);
788
902
  if (err == Z_OK) {
789
903
  zstream_discard_input(z,
790
- RSTRING(z->input)->len - z->stream.avail_in);
904
+ RSTRING_LEN(z->input) - z->stream.avail_in);
791
905
  zstream_append_input(z, src, len);
792
906
  return Qtrue;
793
907
  }
794
908
  zstream_reset_input(z);
795
909
  if (err != Z_DATA_ERROR) {
796
- rest = rb_str_new(z->stream.next_in, z->stream.avail_in);
910
+ rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in);
797
911
  raise_zlib_error(err, z->stream.msg);
798
912
  }
799
913
  }
@@ -801,30 +915,28 @@ zstream_sync(z, src, len)
801
915
  if (len <= 0) return Qfalse;
802
916
 
803
917
  z->stream.next_in = src;
804
- z->stream.avail_in = len;
918
+ z->stream.avail_in = MAX_UINT(len);
805
919
  err = inflateSync(&z->stream);
806
920
  if (err == Z_OK) {
807
921
  zstream_append_input(z, z->stream.next_in, z->stream.avail_in);
808
922
  return Qtrue;
809
923
  }
810
924
  if (err != Z_DATA_ERROR) {
811
- rest = rb_str_new(z->stream.next_in, z->stream.avail_in);
925
+ rest = rb_str_new((char*)z->stream.next_in, z->stream.avail_in);
812
926
  raise_zlib_error(err, z->stream.msg);
813
927
  }
814
928
  return Qfalse;
815
929
  }
816
930
 
817
931
  static void
818
- zstream_mark(z)
819
- struct zstream *z;
932
+ zstream_mark(struct zstream *z)
820
933
  {
821
934
  rb_gc_mark(z->buf);
822
935
  rb_gc_mark(z->input);
823
936
  }
824
937
 
825
938
  static void
826
- zstream_finalize(z)
827
- struct zstream *z;
939
+ zstream_finalize(struct zstream *z)
828
940
  {
829
941
  int err = z->func->end(&z->stream);
830
942
  if (err == Z_STREAM_ERROR)
@@ -834,19 +946,16 @@ zstream_finalize(z)
834
946
  }
835
947
 
836
948
  static void
837
- zstream_free(z)
838
- struct zstream *z;
949
+ zstream_free(struct zstream *z)
839
950
  {
840
951
  if (ZSTREAM_IS_READY(z)) {
841
952
  zstream_finalize(z);
842
953
  }
843
- free(z);
954
+ xfree(z);
844
955
  }
845
956
 
846
957
  static VALUE
847
- zstream_new(klass, funcs)
848
- VALUE klass;
849
- const struct zstream_funcs *funcs;
958
+ zstream_new(VALUE klass, const struct zstream_funcs *funcs)
850
959
  {
851
960
  VALUE obj;
852
961
  struct zstream *z;
@@ -861,8 +970,7 @@ zstream_new(klass, funcs)
861
970
  #define zstream_inflate_new(klass) zstream_new((klass), &inflate_funcs)
862
971
 
863
972
  static struct zstream *
864
- get_zstream(obj)
865
- VALUE obj;
973
+ get_zstream(VALUE obj)
866
974
  {
867
975
  struct zstream *z;
868
976
 
@@ -942,8 +1050,7 @@ get_zstream(obj)
942
1050
  * exception.
943
1051
  */
944
1052
  static VALUE
945
- rb_zstream_end(obj)
946
- VALUE obj;
1053
+ rb_zstream_end(VALUE obj)
947
1054
  {
948
1055
  zstream_end(get_zstream(obj));
949
1056
  return Qnil;
@@ -954,8 +1061,7 @@ rb_zstream_end(obj)
954
1061
  * are discarded.
955
1062
  */
956
1063
  static VALUE
957
- rb_zstream_reset(obj)
958
- VALUE obj;
1064
+ rb_zstream_reset(VALUE obj)
959
1065
  {
960
1066
  zstream_reset(get_zstream(obj));
961
1067
  return Qnil;
@@ -966,13 +1072,12 @@ rb_zstream_reset(obj)
966
1072
  * Zlib::Inflate#finish for details of this behavior.
967
1073
  */
968
1074
  static VALUE
969
- rb_zstream_finish(obj)
970
- VALUE obj;
1075
+ rb_zstream_finish(VALUE obj)
971
1076
  {
972
1077
  struct zstream *z = get_zstream(obj);
973
1078
  VALUE dst;
974
1079
 
975
- zstream_run(z, "", 0, Z_FINISH);
1080
+ zstream_run(z, (Bytef*)"", 0, Z_FINISH);
976
1081
  dst = zstream_detach_buffer(z);
977
1082
 
978
1083
  OBJ_INFECT(dst, obj);
@@ -983,8 +1088,7 @@ rb_zstream_finish(obj)
983
1088
  * Flushes input buffer and returns all data in that buffer.
984
1089
  */
985
1090
  static VALUE
986
- rb_zstream_flush_next_in(obj)
987
- VALUE obj;
1091
+ rb_zstream_flush_next_in(VALUE obj)
988
1092
  {
989
1093
  struct zstream *z;
990
1094
  VALUE dst;
@@ -999,8 +1103,7 @@ rb_zstream_flush_next_in(obj)
999
1103
  * Flushes output buffer and returns all data in that buffer.
1000
1104
  */
1001
1105
  static VALUE
1002
- rb_zstream_flush_next_out(obj)
1003
- VALUE obj;
1106
+ rb_zstream_flush_next_out(VALUE obj)
1004
1107
  {
1005
1108
  struct zstream *z;
1006
1109
  VALUE dst;
@@ -1016,8 +1119,7 @@ rb_zstream_flush_next_out(obj)
1016
1119
  * space is allocated automatically, this method returns 0 normally.
1017
1120
  */
1018
1121
  static VALUE
1019
- rb_zstream_avail_out(obj)
1020
- VALUE obj;
1122
+ rb_zstream_avail_out(VALUE obj)
1021
1123
  {
1022
1124
  struct zstream *z;
1023
1125
  Data_Get_Struct(obj, struct zstream, z);
@@ -1026,13 +1128,12 @@ rb_zstream_avail_out(obj)
1026
1128
 
1027
1129
  /*
1028
1130
  * Allocates +size+ bytes of free space in the output buffer. If there are more
1029
- * than +size+ bytes already in the buffer, the buffer is truncated. Because
1131
+ * than +size+ bytes already in the buffer, the buffer is truncated. Because
1030
1132
  * free space is allocated automatically, you usually don't need to use this
1031
1133
  * method.
1032
1134
  */
1033
1135
  static VALUE
1034
- rb_zstream_set_avail_out(obj, size)
1035
- VALUE obj, size;
1136
+ rb_zstream_set_avail_out(VALUE obj, VALUE size)
1036
1137
  {
1037
1138
  struct zstream *z = get_zstream(obj);
1038
1139
 
@@ -1045,20 +1146,18 @@ rb_zstream_set_avail_out(obj, size)
1045
1146
  * Returns bytes of data in the input buffer. Normally, returns 0.
1046
1147
  */
1047
1148
  static VALUE
1048
- rb_zstream_avail_in(obj)
1049
- VALUE obj;
1149
+ rb_zstream_avail_in(VALUE obj)
1050
1150
  {
1051
1151
  struct zstream *z;
1052
1152
  Data_Get_Struct(obj, struct zstream, z);
1053
- return INT2FIX(NIL_P(z->input) ? 0 : (int)(RSTRING(z->input)->len));
1153
+ return INT2FIX(NIL_P(z->input) ? 0 : (int)(RSTRING_LEN(z->input)));
1054
1154
  }
1055
1155
 
1056
1156
  /*
1057
1157
  * Returns the total bytes of the input data to the stream. FIXME
1058
1158
  */
1059
1159
  static VALUE
1060
- rb_zstream_total_in(obj)
1061
- VALUE obj;
1160
+ rb_zstream_total_in(VALUE obj)
1062
1161
  {
1063
1162
  return rb_uint2inum(get_zstream(obj)->stream.total_in);
1064
1163
  }
@@ -1067,20 +1166,18 @@ rb_zstream_total_in(obj)
1067
1166
  * Returns the total bytes of the output data from the stream. FIXME
1068
1167
  */
1069
1168
  static VALUE
1070
- rb_zstream_total_out(obj)
1071
- VALUE obj;
1169
+ rb_zstream_total_out(VALUE obj)
1072
1170
  {
1073
1171
  return rb_uint2inum(get_zstream(obj)->stream.total_out);
1074
1172
  }
1075
1173
 
1076
1174
  /*
1077
1175
  * Guesses the type of the data which have been inputed into the stream. The
1078
- * returned value is either <tt>Zlib::BINARY</tt>, <tt>Zlib::ASCII</tt>, or
1079
- * <tt>Zlib::UNKNOWN</tt>.
1176
+ * returned value is either <tt>BINARY</tt>, <tt>ASCII</tt>, or
1177
+ * <tt>UNKNOWN</tt>.
1080
1178
  */
1081
1179
  static VALUE
1082
- rb_zstream_data_type(obj)
1083
- VALUE obj;
1180
+ rb_zstream_data_type(VALUE obj)
1084
1181
  {
1085
1182
  return INT2FIX(get_zstream(obj)->stream.data_type);
1086
1183
  }
@@ -1089,8 +1186,7 @@ rb_zstream_data_type(obj)
1089
1186
  * Returns the adler-32 checksum.
1090
1187
  */
1091
1188
  static VALUE
1092
- rb_zstream_adler(obj)
1093
- VALUE obj;
1189
+ rb_zstream_adler(VALUE obj)
1094
1190
  {
1095
1191
  return rb_uint2inum(get_zstream(obj)->stream.adler);
1096
1192
  }
@@ -1099,8 +1195,7 @@ rb_zstream_adler(obj)
1099
1195
  * Returns true if the stream is finished.
1100
1196
  */
1101
1197
  static VALUE
1102
- rb_zstream_finished_p(obj)
1103
- VALUE obj;
1198
+ rb_zstream_finished_p(VALUE obj)
1104
1199
  {
1105
1200
  return ZSTREAM_IS_FINISHED(get_zstream(obj)) ? Qtrue : Qfalse;
1106
1201
  }
@@ -1109,8 +1204,7 @@ rb_zstream_finished_p(obj)
1109
1204
  * Returns true if the stream is closed.
1110
1205
  */
1111
1206
  static VALUE
1112
- rb_zstream_closed_p(obj)
1113
- VALUE obj;
1207
+ rb_zstream_closed_p(VALUE obj)
1114
1208
  {
1115
1209
  struct zstream *z;
1116
1210
  Data_Get_Struct(obj, struct zstream, z);
@@ -1123,7 +1217,7 @@ rb_zstream_closed_p(obj)
1123
1217
  /*
1124
1218
  * Document-class: Zlib::Deflate
1125
1219
  *
1126
- * Zlib::Deflate is the class for compressing data. See Zlib::Stream for more
1220
+ * Zlib::Deflate is the class for compressing data. See Zlib::ZStream for more
1127
1221
  * information.
1128
1222
  */
1129
1223
 
@@ -1139,26 +1233,71 @@ rb_zstream_closed_p(obj)
1139
1233
 
1140
1234
 
1141
1235
  static VALUE
1142
- rb_deflate_s_allocate(klass)
1143
- VALUE klass;
1236
+ rb_deflate_s_allocate(VALUE klass)
1144
1237
  {
1145
1238
  return zstream_deflate_new(klass);
1146
1239
  }
1147
1240
 
1148
1241
  /*
1242
+ * Document-method: Zlib::Deflate.new
1243
+ *
1149
1244
  * call-seq: Zlib::Deflate.new(level=nil, windowBits=nil, memlevel=nil, strategy=nil)
1150
1245
  *
1246
+ * == Arguments
1247
+ *
1248
+ * +level+::
1249
+ * An Integer compression level between
1250
+ * BEST_SPEED and BEST_COMPRESSION
1251
+ * +windowBits+::
1252
+ * An Integer for the windowBits size. Should be
1253
+ * in the range 8..15, larger values of this parameter
1254
+ * result in better at the expense of memory usage.
1255
+ * +memlevel+::
1256
+ * Specifies how much memory should be allocated for
1257
+ * the internal compression state.
1258
+ * Between DEF_MEM_LEVEL and MAX_MEM_LEVEL
1259
+ * +strategy+::
1260
+ * A parameter to tune the compression algorithm. Use the
1261
+ * DEFAULT_STRATEGY for normal data, FILTERED for data produced by a
1262
+ * filter (or predictor), HUFFMAN_ONLY to force Huffman encoding only (no
1263
+ * string match).
1264
+ *
1265
+ * == Description
1266
+ *
1151
1267
  * Creates a new deflate stream for compression. See zlib.h for details of
1152
1268
  * each argument. If an argument is nil, the default value of that argument is
1153
1269
  * used.
1154
1270
  *
1155
- * TODO: document better!
1271
+ *
1272
+ * == examples
1273
+ *
1274
+ * === basic
1275
+ *
1276
+ * f = File.new("compressed.file","w+")
1277
+ * #=> #<File:compressed.file>
1278
+ * f << Zlib::Deflate.new().deflate(File.read("big.file"))
1279
+ * #=> #<File:compressed.file>
1280
+ * f.close
1281
+ * #=> nil
1282
+ *
1283
+ * === a little more robust
1284
+ *
1285
+ * compressed_file = File.open("compressed.file", "w+")
1286
+ * #=> #<File:compressed.file>
1287
+ * zd = Zlib::Deflate.new(Zlib::BEST_COMPRESSION, 15, Zlib::MAX_MEM_LEVEL, Zlib::HUFFMAN_ONLY)
1288
+ * #=> #<Zlib::Deflate:0x000000008610a0>
1289
+ * compressed_file << zd.deflate(File.read("big.file"))
1290
+ * #=> "\xD4z\xC6\xDE\b\xA1K\x1Ej\x8A ..."
1291
+ * compressed_file.close
1292
+ * #=> nil
1293
+ * zd.close
1294
+ * #=> nil
1295
+ *
1296
+ * (while this example will work, for best optimization the flags need to be reviewed for your specific function)
1297
+ *
1156
1298
  */
1157
1299
  static VALUE
1158
- rb_deflate_initialize(argc, argv, obj)
1159
- int argc;
1160
- VALUE *argv;
1161
- VALUE obj;
1300
+ rb_deflate_initialize(int argc, VALUE *argv, VALUE obj)
1162
1301
  {
1163
1302
  struct zstream *z;
1164
1303
  VALUE level, wbits, memlevel, strategy;
@@ -1179,11 +1318,12 @@ rb_deflate_initialize(argc, argv, obj)
1179
1318
  }
1180
1319
 
1181
1320
  /*
1321
+ * Document-method: Zlib::Deflate#initialize_copy
1322
+ *
1182
1323
  * Duplicates the deflate stream.
1183
1324
  */
1184
1325
  static VALUE
1185
- rb_deflate_init_copy(self, orig)
1186
- VALUE self, orig;
1326
+ rb_deflate_init_copy(VALUE self, VALUE orig)
1187
1327
  {
1188
1328
  struct zstream *z1, *z2;
1189
1329
  int err;
@@ -1204,41 +1344,40 @@ rb_deflate_init_copy(self, orig)
1204
1344
  }
1205
1345
 
1206
1346
  static VALUE
1207
- deflate_run(args)
1208
- VALUE args;
1347
+ deflate_run(VALUE args)
1209
1348
  {
1210
- struct zstream *z = (struct zstream *)((VALUE *)args)[0];
1211
- VALUE src = ((VALUE *)args)[1];
1349
+ struct zstream *z = (struct zstream*)((VALUE*)args)[0];
1350
+ VALUE src = ((VALUE*)args)[1];
1212
1351
 
1213
- zstream_run(z, RSTRING(src)->ptr, RSTRING(src)->len, Z_FINISH);
1352
+ zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_FINISH);
1214
1353
  return zstream_detach_buffer(z);
1215
1354
  }
1216
1355
 
1217
1356
  /*
1218
- * call-seq: Zlib::Deflate.deflate(string[, level])
1357
+ * Document-method: Zlib::Deflate.deflate
1358
+ *
1359
+ * call-seq: Zlib.deflate(string[, level])
1360
+ * Zlib::Deflate.deflate(string[, level])
1219
1361
  *
1220
1362
  * Compresses the given +string+. Valid values of level are
1221
- * <tt>Zlib::NO_COMPRESSION</tt>, <tt>Zlib::BEST_SPEED</tt>,
1222
- * <tt>Zlib::BEST_COMPRESSION</tt>, <tt>Zlib::DEFAULT_COMPRESSION</tt>, and an
1223
- * integer from 0 to 9.
1363
+ * <tt>NO_COMPRESSION</tt>, <tt>BEST_SPEED</tt>,
1364
+ * <tt>BEST_COMPRESSION</tt>, <tt>DEFAULT_COMPRESSION</tt>, and an
1365
+ * integer from 0 to 9 (the default is 6).
1224
1366
  *
1225
1367
  * This method is almost equivalent to the following code:
1226
1368
  *
1227
1369
  * def deflate(string, level)
1228
1370
  * z = Zlib::Deflate.new(level)
1229
- * dst = z.deflate(string, Zlib::FINISH)
1371
+ * dst = z.deflate(string, Zlib::NO_FLUSH)
1230
1372
  * z.close
1231
1373
  * dst
1232
1374
  * end
1233
1375
  *
1234
- * TODO: what's default value of +level+?
1376
+ * See also Zlib.inflate
1235
1377
  *
1236
1378
  */
1237
1379
  static VALUE
1238
- rb_deflate_s_deflate(argc, argv, klass)
1239
- int argc;
1240
- VALUE *argv;
1241
- VALUE klass;
1380
+ rb_deflate_s_deflate(int argc, VALUE *argv, VALUE klass)
1242
1381
  {
1243
1382
  struct zstream z;
1244
1383
  VALUE src, level, dst, args[2];
@@ -1264,40 +1403,53 @@ rb_deflate_s_deflate(argc, argv, klass)
1264
1403
  }
1265
1404
 
1266
1405
  static void
1267
- do_deflate(z, src, flush)
1268
- struct zstream *z;
1269
- VALUE src;
1270
- int flush;
1406
+ do_deflate(struct zstream *z, VALUE src, int flush)
1271
1407
  {
1272
1408
  if (NIL_P(src)) {
1273
- zstream_run(z, "", 0, Z_FINISH);
1409
+ zstream_run(z, (Bytef*)"", 0, Z_FINISH);
1274
1410
  return;
1275
1411
  }
1276
1412
  StringValue(src);
1277
- if (flush != Z_NO_FLUSH || RSTRING(src)->len > 0) { /* prevent BUF_ERROR */
1278
- zstream_run(z, RSTRING(src)->ptr, RSTRING(src)->len, flush);
1413
+ if (flush != Z_NO_FLUSH || RSTRING_LEN(src) > 0) { /* prevent BUF_ERROR */
1414
+ zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), flush);
1279
1415
  }
1280
1416
  }
1281
1417
 
1282
1418
  /*
1419
+ * Document-method: Zlib.deflate
1420
+ *
1283
1421
  * call-seq: deflate(string[, flush])
1284
1422
  *
1423
+ * == Arguments
1424
+ *
1425
+ * +string+::
1426
+ * String
1427
+ *
1428
+ * +flush+::
1429
+ * Integer representing a flush code. Either NO_FLUSH,
1430
+ * SYNC_FLUSH, FULL_FLUSH, or FINISH. See zlib.h for details.
1431
+ * Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
1432
+ * decide how much data to accumulate before producing output, in order to
1433
+ * maximize compression.
1434
+ *
1435
+ * == Description
1436
+ *
1285
1437
  * Inputs +string+ into the deflate stream and returns the output from the
1286
1438
  * stream. On calling this method, both the input and the output buffers of
1287
- * the stream are flushed. If +string+ is nil, this method finishes the
1439
+ * the stream are flushed.
1440
+ *
1441
+ * If +string+ is nil, this method finishes the
1288
1442
  * stream, just like Zlib::ZStream#finish.
1289
1443
  *
1290
- * The value of +flush+ should be either <tt>Zlib::NO_FLUSH</tt>,
1291
- * <tt>Zlib::SYNC_FLUSH</tt>, <tt>Zlib::FULL_FLUSH</tt>, or
1292
- * <tt>Zlib::FINISH</tt>. See zlib.h for details.
1444
+ * == Usage
1445
+ *
1446
+ * comp = Zlib.deflate(File.read("big.file"))
1447
+ * or
1448
+ * comp = Zlib.deflate(File.read("big.file"), Zlib::FULL_FLUSH)
1293
1449
  *
1294
- * TODO: document better!
1295
1450
  */
1296
1451
  static VALUE
1297
- rb_deflate_deflate(argc, argv, obj)
1298
- int argc;
1299
- VALUE *argv;
1300
- VALUE obj;
1452
+ rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
1301
1453
  {
1302
1454
  struct zstream *z = get_zstream(obj);
1303
1455
  VALUE src, flush, dst;
@@ -1312,6 +1464,8 @@ rb_deflate_deflate(argc, argv, obj)
1312
1464
  }
1313
1465
 
1314
1466
  /*
1467
+ * Document-method: Zlib::Deflate.<<
1468
+ *
1315
1469
  * call-seq: << string
1316
1470
  *
1317
1471
  * Inputs +string+ into the deflate stream just like Zlib::Deflate#deflate, but
@@ -1319,8 +1473,7 @@ rb_deflate_deflate(argc, argv, obj)
1319
1473
  * preserved in output buffer.
1320
1474
  */
1321
1475
  static VALUE
1322
- rb_deflate_addstr(obj, src)
1323
- VALUE obj, src;
1476
+ rb_deflate_addstr(VALUE obj, VALUE src)
1324
1477
  {
1325
1478
  OBJ_INFECT(obj, src);
1326
1479
  do_deflate(get_zstream(obj), src, Z_NO_FLUSH);
@@ -1328,19 +1481,19 @@ rb_deflate_addstr(obj, src)
1328
1481
  }
1329
1482
 
1330
1483
  /*
1484
+ * Document-method: Zlib::Deflate#flush
1485
+ *
1331
1486
  * call-seq: flush(flush)
1332
1487
  *
1333
1488
  * This method is equivalent to <tt>deflate('', flush)</tt>. If flush is omitted,
1334
- * <tt>Zlib::SYNC_FLUSH</tt> is used as flush. This method is just provided
1489
+ * <tt>SYNC_FLUSH</tt> is used as flush. This method is just provided
1335
1490
  * to improve the readability of your Ruby program.
1336
1491
  *
1337
- * TODO: document better!
1492
+ * Please visit your zlib.h for a deeper detail on NO_FLUSH, SYNC_FLUSH, FULL_FLUSH, and FINISH
1493
+ *
1338
1494
  */
1339
1495
  static VALUE
1340
- rb_deflate_flush(argc, argv, obj)
1341
- int argc;
1342
- VALUE *argv;
1343
- VALUE obj;
1496
+ rb_deflate_flush(int argc, VALUE *argv, VALUE obj)
1344
1497
  {
1345
1498
  struct zstream *z = get_zstream(obj);
1346
1499
  VALUE v_flush, dst;
@@ -1349,7 +1502,7 @@ rb_deflate_flush(argc, argv, obj)
1349
1502
  rb_scan_args(argc, argv, "01", &v_flush);
1350
1503
  flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
1351
1504
  if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */
1352
- zstream_run(z, "", 0, flush);
1505
+ zstream_run(z, (Bytef*)"", 0, flush);
1353
1506
  }
1354
1507
  dst = zstream_detach_buffer(z);
1355
1508
 
@@ -1358,17 +1511,26 @@ rb_deflate_flush(argc, argv, obj)
1358
1511
  }
1359
1512
 
1360
1513
  /*
1514
+ * Document-method: Zlib::Deflate.params
1515
+ *
1361
1516
  * call-seq: params(level, strategy)
1362
- *
1517
+ *
1363
1518
  * Changes the parameters of the deflate stream. See zlib.h for details. The
1364
1519
  * output from the stream by changing the params is preserved in output
1365
1520
  * buffer.
1366
1521
  *
1367
- * TODO: document better!
1522
+ * +level+::
1523
+ * An Integer compression level between
1524
+ * BEST_SPEED and BEST_COMPRESSION
1525
+ * +strategy+::
1526
+ * A parameter to tune the compression algorithm. Use the
1527
+ * DEFAULT_STRATEGY for normal data, FILTERED for data produced by a
1528
+ * filter (or predictor), HUFFMAN_ONLY to force Huffman encoding only (no
1529
+ * string match).
1530
+ *
1368
1531
  */
1369
1532
  static VALUE
1370
- rb_deflate_params(obj, v_level, v_strategy)
1371
- VALUE obj, v_level, v_strategy;
1533
+ rb_deflate_params(VALUE obj, VALUE v_level, VALUE v_strategy)
1372
1534
  {
1373
1535
  struct zstream *z = get_zstream(obj);
1374
1536
  int level, strategy;
@@ -1396,17 +1558,21 @@ rb_deflate_params(obj, v_level, v_strategy)
1396
1558
  }
1397
1559
 
1398
1560
  /*
1561
+ * Document-method: Zlib::Deflate.set_dictionary
1562
+ *
1399
1563
  * call-seq: set_dictionary(string)
1400
1564
  *
1401
1565
  * Sets the preset dictionary and returns +string+. This method is available
1402
1566
  * just only after Zlib::Deflate.new or Zlib::ZStream#reset method was called.
1403
1567
  * See zlib.h for details.
1404
1568
  *
1405
- * TODO: document better!
1569
+ * Can raise errors of Z_STREAM_ERROR if a parameter is invalid (such as
1570
+ * NULL dictionary) or the stream state is inconsistent, Z_DATA_ERROR if
1571
+ * the given dictionary doesn't match the expected one (incorrect adler32 value)
1572
+ *
1406
1573
  */
1407
1574
  static VALUE
1408
- rb_deflate_set_dictionary(obj, dic)
1409
- VALUE obj, dic;
1575
+ rb_deflate_set_dictionary(VALUE obj, VALUE dic)
1410
1576
  {
1411
1577
  struct zstream *z = get_zstream(obj);
1412
1578
  VALUE src = dic;
@@ -1415,7 +1581,7 @@ rb_deflate_set_dictionary(obj, dic)
1415
1581
  OBJ_INFECT(obj, dic);
1416
1582
  StringValue(src);
1417
1583
  err = deflateSetDictionary(&z->stream,
1418
- RSTRING(src)->ptr, RSTRING(src)->len);
1584
+ (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
1419
1585
  if (err != Z_OK) {
1420
1586
  raise_zlib_error(err, z->stream.msg);
1421
1587
  }
@@ -1437,25 +1603,53 @@ rb_deflate_set_dictionary(obj, dic)
1437
1603
 
1438
1604
 
1439
1605
  static VALUE
1440
- rb_inflate_s_allocate(klass)
1441
- VALUE klass;
1606
+ rb_inflate_s_allocate(VALUE klass)
1442
1607
  {
1443
1608
  return zstream_inflate_new(klass);
1444
1609
  }
1445
1610
 
1446
1611
  /*
1612
+ * Document-method: Zlib::Inflate.new
1613
+ *
1447
1614
  * call-seq: Zlib::Inflate.new(window_bits)
1448
1615
  *
1616
+ * == Arguments
1617
+ *
1618
+ * +windowBits+::
1619
+ * An Integer for the windowBits size. Should be
1620
+ * in the range 8..15, larger values of this parameter
1621
+ * result in better at the expense of memory usage.
1622
+ *
1623
+ * == Description
1624
+ *
1449
1625
  * Creates a new inflate stream for decompression. See zlib.h for details
1450
1626
  * of the argument. If +window_bits+ is +nil+, the default value is used.
1451
1627
  *
1452
- * TODO: document better!
1628
+ * == Example
1629
+ *
1630
+ * cf = File.open("compressed.file")
1631
+ * ucf = File.open("uncompressed.file", "w+")
1632
+ * zi = Zlib::Inflate.new(Zlib::MAX_WBITS)
1633
+ *
1634
+ * ucf << zi.inflate(cf.read)
1635
+ *
1636
+ * ucf.close
1637
+ * zi.close
1638
+ * cf.close
1639
+ *
1640
+ * or
1641
+ *
1642
+ * File.open("compressed.file") {|cf|
1643
+ * zi = Zlib::Inflate.new
1644
+ * File.open("uncompressed.file", "w+") {|ucf|
1645
+ * ucf << zi.inflate(cf.read)
1646
+ * }
1647
+ * zi.close
1648
+ * }
1649
+ *
1453
1650
  */
1454
1651
  static VALUE
1455
- rb_inflate_initialize(argc, argv, obj)
1456
- int argc;
1457
- VALUE *argv;
1458
- VALUE obj;
1652
+ rb_inflate_initialize(int argc, VALUE *argv, VALUE obj)
1459
1653
  {
1460
1654
  struct zstream *z;
1461
1655
  VALUE wbits;
@@ -1474,18 +1668,19 @@ rb_inflate_initialize(argc, argv, obj)
1474
1668
  }
1475
1669
 
1476
1670
  static VALUE
1477
- inflate_run(args)
1478
- VALUE args;
1671
+ inflate_run(VALUE args)
1479
1672
  {
1480
- struct zstream *z = (struct zstream *)((VALUE *)args)[0];
1481
- VALUE src = ((VALUE *)args)[1];
1673
+ struct zstream *z = (struct zstream*)((VALUE*)args)[0];
1674
+ VALUE src = ((VALUE*)args)[1];
1482
1675
 
1483
- zstream_run(z, RSTRING(src)->ptr, RSTRING(src)->len, Z_SYNC_FLUSH);
1484
- zstream_run(z, "", 0, Z_FINISH); /* for checking errors */
1676
+ zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
1677
+ zstream_run(z, (Bytef*)"", 0, Z_FINISH); /* for checking errors */
1485
1678
  return zstream_detach_buffer(z);
1486
1679
  }
1487
1680
 
1488
1681
  /*
1682
+ * Document-method: Zlib::Inflate.inflate
1683
+ *
1489
1684
  * call-seq: Zlib::Inflate.inflate(string)
1490
1685
  *
1491
1686
  * Decompresses +string+. Raises a Zlib::NeedDict exception if a preset
@@ -1501,10 +1696,11 @@ inflate_run(args)
1501
1696
  * buf
1502
1697
  * end
1503
1698
  *
1699
+ * See also Zlib.deflate
1700
+ *
1504
1701
  */
1505
1702
  static VALUE
1506
- rb_inflate_s_inflate(obj, src)
1507
- VALUE obj, src;
1703
+ rb_inflate_s_inflate(VALUE obj, VALUE src)
1508
1704
  {
1509
1705
  struct zstream z;
1510
1706
  VALUE dst, args[2];
@@ -1527,21 +1723,21 @@ rb_inflate_s_inflate(obj, src)
1527
1723
  }
1528
1724
 
1529
1725
  static void
1530
- do_inflate(z, src)
1531
- struct zstream *z;
1532
- VALUE src;
1726
+ do_inflate(struct zstream *z, VALUE src)
1533
1727
  {
1534
1728
  if (NIL_P(src)) {
1535
- zstream_run(z, "", 0, Z_FINISH);
1729
+ zstream_run(z, (Bytef*)"", 0, Z_FINISH);
1536
1730
  return;
1537
1731
  }
1538
1732
  StringValue(src);
1539
- if (RSTRING(src)->len > 0) { /* prevent Z_BUF_ERROR */
1540
- zstream_run(z, RSTRING(src)->ptr, RSTRING(src)->len, Z_SYNC_FLUSH);
1733
+ if (RSTRING_LEN(src) > 0) { /* prevent Z_BUF_ERROR */
1734
+ zstream_run(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src), Z_SYNC_FLUSH);
1541
1735
  }
1542
1736
  }
1543
1737
 
1544
1738
  /*
1739
+ * Document-method: Zlib::Inflate#inflate
1740
+ *
1545
1741
  * call-seq: inflate(string)
1546
1742
  *
1547
1743
  * Inputs +string+ into the inflate stream and returns the output from the
@@ -1553,11 +1749,10 @@ do_inflate(z, src)
1553
1749
  * decompress. Set the dictionary by Zlib::Inflate#set_dictionary and then
1554
1750
  * call this method again with an empty string. (<i>???</i>)
1555
1751
  *
1556
- * TODO: document better!
1752
+ * See also Zlib::Inflate.new
1557
1753
  */
1558
1754
  static VALUE
1559
- rb_inflate_inflate(obj, src)
1560
- VALUE obj, src;
1755
+ rb_inflate_inflate(VALUE obj, VALUE src)
1561
1756
  {
1562
1757
  struct zstream *z = get_zstream(obj);
1563
1758
  VALUE dst;
@@ -1594,8 +1789,7 @@ rb_inflate_inflate(obj, src)
1594
1789
  * preserved in output buffer.
1595
1790
  */
1596
1791
  static VALUE
1597
- rb_inflate_addstr(obj, src)
1598
- VALUE obj, src;
1792
+ rb_inflate_addstr(VALUE obj, VALUE src)
1599
1793
  {
1600
1794
  struct zstream *z = get_zstream(obj);
1601
1795
 
@@ -1626,14 +1820,13 @@ rb_inflate_addstr(obj, src)
1626
1820
  * following data of full flush point is preserved in the buffer.
1627
1821
  */
1628
1822
  static VALUE
1629
- rb_inflate_sync(obj, src)
1630
- VALUE obj, src;
1823
+ rb_inflate_sync(VALUE obj, VALUE src)
1631
1824
  {
1632
1825
  struct zstream *z = get_zstream(obj);
1633
1826
 
1634
1827
  OBJ_INFECT(obj, src);
1635
1828
  StringValue(src);
1636
- return zstream_sync(z, RSTRING(src)->ptr, RSTRING(src)->len);
1829
+ return zstream_sync(z, (Bytef*)RSTRING_PTR(src), RSTRING_LEN(src));
1637
1830
  }
1638
1831
 
1639
1832
  /*
@@ -1644,8 +1837,7 @@ rb_inflate_sync(obj, src)
1644
1837
  * <tt>:)</tt>
1645
1838
  */
1646
1839
  static VALUE
1647
- rb_inflate_sync_point_p(obj)
1648
- VALUE obj;
1840
+ rb_inflate_sync_point_p(VALUE obj)
1649
1841
  {
1650
1842
  struct zstream *z = get_zstream(obj);
1651
1843
  int err;
@@ -1661,14 +1853,14 @@ rb_inflate_sync_point_p(obj)
1661
1853
  }
1662
1854
 
1663
1855
  /*
1856
+ * Document-method: Zlib::Inflate#set_dictionary
1857
+ *
1664
1858
  * Sets the preset dictionary and returns +string+. This method is available just
1665
1859
  * only after a Zlib::NeedDict exception was raised. See zlib.h for details.
1666
1860
  *
1667
- * TODO: document better!
1668
1861
  */
1669
1862
  static VALUE
1670
- rb_inflate_set_dictionary(obj, dic)
1671
- VALUE obj, dic;
1863
+ rb_inflate_set_dictionary(VALUE obj, VALUE dic)
1672
1864
  {
1673
1865
  struct zstream *z = get_zstream(obj);
1674
1866
  VALUE src = dic;
@@ -1677,7 +1869,7 @@ rb_inflate_set_dictionary(obj, dic)
1677
1869
  OBJ_INFECT(obj, dic);
1678
1870
  StringValue(src);
1679
1871
  err = inflateSetDictionary(&z->stream,
1680
- RSTRING(src)->ptr, RSTRING(src)->len);
1872
+ (Bytef*)RSTRING_PTR(src), RSTRING_LENINT(src));
1681
1873
  if (err != Z_OK) {
1682
1874
  raise_zlib_error(err, z->stream.msg);
1683
1875
  }
@@ -1731,7 +1923,7 @@ rb_inflate_set_dictionary(obj, dic)
1731
1923
  #define OS_CODE OS_UNIX
1732
1924
  #endif
1733
1925
 
1734
- static ID id_write, id_read, id_flush, id_seek, id_close;
1926
+ static ID id_write, id_read, id_readpartial, id_flush, id_seek, id_close, id_path, id_input;
1735
1927
  static VALUE cGzError, cNoFooter, cCRCError, cLengthError;
1736
1928
 
1737
1929
 
@@ -1748,33 +1940,41 @@ struct gzfile {
1748
1940
  VALUE comment; /* for header; must be a String */
1749
1941
  unsigned long crc;
1750
1942
  int lineno;
1751
- int ungetc;
1943
+ long ungetc;
1752
1944
  void (*end)(struct gzfile *);
1945
+ rb_encoding *enc;
1946
+ rb_encoding *enc2;
1947
+ rb_econv_t *ec;
1948
+ int ecflags;
1949
+ VALUE ecopts;
1950
+ char *cbuf;
1951
+ VALUE path;
1753
1952
  };
1953
+ #define GZFILE_CBUF_CAPA 10
1754
1954
 
1755
1955
  #define GZFILE_FLAG_SYNC ZSTREAM_FLAG_UNUSED
1756
1956
  #define GZFILE_FLAG_HEADER_FINISHED (ZSTREAM_FLAG_UNUSED << 1)
1757
1957
  #define GZFILE_FLAG_FOOTER_FINISHED (ZSTREAM_FLAG_UNUSED << 2)
1758
1958
 
1759
1959
  #define GZFILE_IS_FINISHED(gz) \
1760
- (ZSTREAM_IS_FINISHED(&gz->z) && (gz)->z.buf_filled == 0)
1960
+ (ZSTREAM_IS_FINISHED(&(gz)->z) && (gz)->z.buf_filled == 0)
1761
1961
 
1762
1962
  #define GZFILE_READ_SIZE 2048
1763
1963
 
1764
1964
 
1765
1965
  static void
1766
- gzfile_mark(gz)
1767
- struct gzfile *gz;
1966
+ gzfile_mark(struct gzfile *gz)
1768
1967
  {
1769
1968
  rb_gc_mark(gz->io);
1770
1969
  rb_gc_mark(gz->orig_name);
1771
1970
  rb_gc_mark(gz->comment);
1772
1971
  zstream_mark(&gz->z);
1972
+ rb_gc_mark(gz->ecopts);
1973
+ rb_gc_mark(gz->path);
1773
1974
  }
1774
1975
 
1775
1976
  static void
1776
- gzfile_free(gz)
1777
- struct gzfile *gz;
1977
+ gzfile_free(struct gzfile *gz)
1778
1978
  {
1779
1979
  struct zstream *z = &gz->z;
1780
1980
 
@@ -1784,14 +1984,17 @@ gzfile_free(gz)
1784
1984
  }
1785
1985
  zstream_finalize(z);
1786
1986
  }
1787
- free(gz);
1987
+ if (gz->cbuf) {
1988
+ xfree(gz->cbuf);
1989
+ }
1990
+ xfree(gz);
1788
1991
  }
1789
1992
 
1790
1993
  static VALUE
1791
1994
  gzfile_new(klass, funcs, endfunc)
1792
1995
  VALUE klass;
1793
1996
  const struct zstream_funcs *funcs;
1794
- void (*endfunc) _((struct gzfile *));
1997
+ void (*endfunc)(struct gzfile *);
1795
1998
  {
1796
1999
  VALUE obj;
1797
2000
  struct gzfile *gz;
@@ -1808,6 +2011,13 @@ gzfile_new(klass, funcs, endfunc)
1808
2011
  gz->lineno = 0;
1809
2012
  gz->ungetc = 0;
1810
2013
  gz->end = endfunc;
2014
+ gz->enc = rb_default_external_encoding();
2015
+ gz->enc2 = 0;
2016
+ gz->ec = NULL;
2017
+ gz->ecflags = 0;
2018
+ gz->ecopts = Qnil;
2019
+ gz->cbuf = 0;
2020
+ gz->path = Qnil;
1811
2021
 
1812
2022
  return obj;
1813
2023
  }
@@ -1816,19 +2026,24 @@ gzfile_new(klass, funcs, endfunc)
1816
2026
  #define gzfile_reader_new(gz) gzfile_new((gz),&inflate_funcs,gzfile_reader_end)
1817
2027
 
1818
2028
  static void
1819
- gzfile_reset(gz)
1820
- struct gzfile *gz;
2029
+ gzfile_reset(struct gzfile *gz)
1821
2030
  {
1822
2031
  zstream_reset(&gz->z);
1823
2032
  gz->crc = crc32(0, Z_NULL, 0);
1824
2033
  gz->lineno = 0;
1825
2034
  gz->ungetc = 0;
2035
+ /* TODO: Encodings
2036
+ *
2037
+ if (gz->ec) {
2038
+ rb_econv_close(gz->ec);
2039
+ gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
2040
+ gz->ecflags, gz->ecopts);
2041
+ }
2042
+ */
1826
2043
  }
1827
2044
 
1828
2045
  static void
1829
- gzfile_close(gz, closeflag)
1830
- struct gzfile *gz;
1831
- int closeflag;
2046
+ gzfile_close(struct gzfile *gz, int closeflag)
1832
2047
  {
1833
2048
  VALUE io = gz->io;
1834
2049
 
@@ -1842,8 +2057,7 @@ gzfile_close(gz, closeflag)
1842
2057
  }
1843
2058
 
1844
2059
  static void
1845
- gzfile_write_raw(gz)
1846
- struct gzfile *gz;
2060
+ gzfile_write_raw(struct gzfile *gz)
1847
2061
  {
1848
2062
  VALUE str;
1849
2063
 
@@ -1858,58 +2072,73 @@ gzfile_write_raw(gz)
1858
2072
  }
1859
2073
 
1860
2074
  static VALUE
1861
- gzfile_read_raw(gz)
1862
- struct gzfile *gz;
2075
+ gzfile_read_raw_partial(VALUE arg)
1863
2076
  {
2077
+ struct gzfile *gz = (struct gzfile*)arg;
1864
2078
  VALUE str;
1865
2079
 
1866
- str = rb_funcall(gz->io, id_read, 1, INT2FIX(GZFILE_READ_SIZE));
1867
- if (!NIL_P(str)) {
1868
- Check_Type(str, T_STRING);
1869
- }
2080
+ str = rb_funcall(gz->io, id_readpartial, 1, INT2FIX(GZFILE_READ_SIZE));
2081
+ Check_Type(str, T_STRING);
1870
2082
  return str;
1871
2083
  }
1872
2084
 
2085
+ static VALUE
2086
+ gzfile_read_raw_rescue(VALUE arg)
2087
+ {
2088
+ struct gzfile *gz = (struct gzfile*)arg;
2089
+ VALUE str = Qnil;
2090
+ if (rb_obj_is_kind_of(rb_errinfo(), rb_eNoMethodError)) {
2091
+ str = rb_funcall(gz->io, id_read, 1, INT2FIX(GZFILE_READ_SIZE));
2092
+ if (!NIL_P(str)) {
2093
+ Check_Type(str, T_STRING);
2094
+ }
2095
+ }
2096
+ return str; /* return nil when EOFError */
2097
+ }
2098
+
2099
+ static VALUE
2100
+ gzfile_read_raw(struct gzfile *gz)
2101
+ {
2102
+ return rb_rescue2(gzfile_read_raw_partial, (VALUE)gz,
2103
+ gzfile_read_raw_rescue, (VALUE)gz,
2104
+ rb_eEOFError, rb_eNoMethodError, (VALUE)0);
2105
+ }
2106
+
1873
2107
  static int
1874
- gzfile_read_raw_ensure(gz, size)
1875
- struct gzfile *gz;
1876
- int size;
2108
+ gzfile_read_raw_ensure(struct gzfile *gz, long size)
1877
2109
  {
1878
2110
  VALUE str;
1879
2111
 
1880
- while (NIL_P(gz->z.input) || RSTRING(gz->z.input)->len < size) {
2112
+ while (NIL_P(gz->z.input) || RSTRING_LEN(gz->z.input) < size) {
1881
2113
  str = gzfile_read_raw(gz);
1882
- if (NIL_P(str)) return Qfalse;
2114
+ if (NIL_P(str)) return 0;
1883
2115
  zstream_append_input2(&gz->z, str);
1884
2116
  }
1885
- return Qtrue;
2117
+ return 1;
1886
2118
  }
1887
2119
 
1888
2120
  static char *
1889
- gzfile_read_raw_until_zero(gz, offset)
1890
- struct gzfile *gz;
1891
- long offset;
2121
+ gzfile_read_raw_until_zero(struct gzfile *gz, long offset)
1892
2122
  {
1893
2123
  VALUE str;
1894
2124
  char *p;
1895
2125
 
1896
2126
  for (;;) {
1897
- p = memchr(RSTRING(gz->z.input)->ptr + offset, '\0',
1898
- RSTRING(gz->z.input)->len - offset);
2127
+ p = memchr(RSTRING_PTR(gz->z.input) + offset, '\0',
2128
+ RSTRING_LEN(gz->z.input) - offset);
1899
2129
  if (p) break;
1900
2130
  str = gzfile_read_raw(gz);
1901
2131
  if (NIL_P(str)) {
1902
2132
  rb_raise(cGzError, "unexpected end of file");
1903
2133
  }
1904
- offset = RSTRING(gz->z.input)->len;
2134
+ offset = RSTRING_LEN(gz->z.input);
1905
2135
  zstream_append_input2(&gz->z, str);
1906
2136
  }
1907
2137
  return p;
1908
2138
  }
1909
2139
 
1910
2140
  static unsigned int
1911
- gzfile_get16(src)
1912
- const unsigned char *src;
2141
+ gzfile_get16(const unsigned char *src)
1913
2142
  {
1914
2143
  unsigned int n;
1915
2144
  n = *(src++) & 0xff;
@@ -1918,8 +2147,7 @@ gzfile_get16(src)
1918
2147
  }
1919
2148
 
1920
2149
  static unsigned long
1921
- gzfile_get32(src)
1922
- const unsigned char *src;
2150
+ gzfile_get32(const unsigned char *src)
1923
2151
  {
1924
2152
  unsigned long n;
1925
2153
  n = *(src++) & 0xff;
@@ -1930,9 +2158,7 @@ gzfile_get32(src)
1930
2158
  }
1931
2159
 
1932
2160
  static void
1933
- gzfile_set32(n, dst)
1934
- unsigned long n;
1935
- unsigned char *dst;
2161
+ gzfile_set32(unsigned long n, unsigned char *dst)
1936
2162
  {
1937
2163
  *(dst++) = n & 0xff;
1938
2164
  *(dst++) = (n >> 8) & 0xff;
@@ -1941,10 +2167,39 @@ gzfile_set32(n, dst)
1941
2167
  }
1942
2168
 
1943
2169
  static void
1944
- gzfile_make_header(gz)
1945
- struct gzfile *gz;
2170
+ gzfile_raise(struct gzfile *gz, VALUE klass, const char *message)
2171
+ {
2172
+ VALUE exc = rb_exc_new2(klass, message);
2173
+ if (!NIL_P(gz->z.input)) {
2174
+ rb_ivar_set(exc, id_input, rb_str_dup(gz->z.input));
2175
+ }
2176
+ rb_exc_raise(exc);
2177
+ }
2178
+
2179
+ /*
2180
+ * Document-method: Zlib::GzipFile::Error#inspect
2181
+ *
2182
+ * Constructs a String of the GzipFile Error
2183
+ */
2184
+ static VALUE
2185
+ gzfile_error_inspect(VALUE error)
2186
+ {
2187
+ VALUE str = rb_call_super(0, 0);
2188
+ VALUE input = rb_attr_get(error, id_input);
2189
+
2190
+ if (!NIL_P(input)) {
2191
+ rb_str_resize(str, RSTRING_LEN(str)-1);
2192
+ rb_str_cat2(str, ", input=");
2193
+ rb_str_append(str, rb_str_inspect(input));
2194
+ rb_str_cat2(str, ">");
2195
+ }
2196
+ return str;
2197
+ }
2198
+
2199
+ static void
2200
+ gzfile_make_header(struct gzfile *gz)
1946
2201
  {
1947
- unsigned char buf[10]; /* the size of gzip header */
2202
+ Bytef buf[10]; /* the size of gzip header */
1948
2203
  unsigned char flags = 0, extraflags = 0;
1949
2204
 
1950
2205
  if (!NIL_P(gz->orig_name)) {
@@ -1968,28 +2223,27 @@ gzfile_make_header(gz)
1968
2223
  buf[1] = GZ_MAGIC2;
1969
2224
  buf[2] = GZ_METHOD_DEFLATE;
1970
2225
  buf[3] = flags;
1971
- gzfile_set32(gz->mtime, &buf[4]);
2226
+ gzfile_set32((unsigned long)gz->mtime, &buf[4]);
1972
2227
  buf[8] = extraflags;
1973
2228
  buf[9] = gz->os_code;
1974
2229
  zstream_append_buffer(&gz->z, buf, sizeof(buf));
1975
2230
 
1976
2231
  if (!NIL_P(gz->orig_name)) {
1977
2232
  zstream_append_buffer2(&gz->z, gz->orig_name);
1978
- zstream_append_buffer(&gz->z, "\0", 1);
2233
+ zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
1979
2234
  }
1980
2235
  if (!NIL_P(gz->comment)) {
1981
2236
  zstream_append_buffer2(&gz->z, gz->comment);
1982
- zstream_append_buffer(&gz->z, "\0", 1);
2237
+ zstream_append_buffer(&gz->z, (Bytef*)"\0", 1);
1983
2238
  }
1984
2239
 
1985
2240
  gz->z.flags |= GZFILE_FLAG_HEADER_FINISHED;
1986
2241
  }
1987
2242
 
1988
2243
  static void
1989
- gzfile_make_footer(gz)
1990
- struct gzfile *gz;
2244
+ gzfile_make_footer(struct gzfile *gz)
1991
2245
  {
1992
- unsigned char buf[8]; /* 8 is the size of gzip footer */
2246
+ Bytef buf[8]; /* 8 is the size of gzip footer */
1993
2247
 
1994
2248
  gzfile_set32(gz->crc, buf);
1995
2249
  gzfile_set32(gz->z.stream.total_in, &buf[4]);
@@ -1998,21 +2252,20 @@ gzfile_make_footer(gz)
1998
2252
  }
1999
2253
 
2000
2254
  static void
2001
- gzfile_read_header(gz)
2002
- struct gzfile *gz;
2255
+ gzfile_read_header(struct gzfile *gz)
2003
2256
  {
2004
2257
  const unsigned char *head;
2005
2258
  long len;
2006
2259
  char flags, *p;
2007
2260
 
2008
2261
  if (!gzfile_read_raw_ensure(gz, 10)) { /* 10 is the size of gzip header */
2009
- rb_raise(cGzError, "not in gzip format");
2262
+ gzfile_raise(gz, cGzError, "not in gzip format");
2010
2263
  }
2011
2264
 
2012
- head = RSTRING(gz->z.input)->ptr;
2265
+ head = (unsigned char*)RSTRING_PTR(gz->z.input);
2013
2266
 
2014
2267
  if (head[0] != GZ_MAGIC1 || head[1] != GZ_MAGIC2) {
2015
- rb_raise(cGzError, "not in gzip format");
2268
+ gzfile_raise(gz, cGzError, "not in gzip format");
2016
2269
  }
2017
2270
  if (head[2] != GZ_METHOD_DEFLATE) {
2018
2271
  rb_raise(cGzError, "unsupported compression method %d", head[2]);
@@ -2047,46 +2300,51 @@ gzfile_read_header(gz)
2047
2300
  if (!gzfile_read_raw_ensure(gz, 2)) {
2048
2301
  rb_raise(cGzError, "unexpected end of file");
2049
2302
  }
2050
- len = gzfile_get16(RSTRING(gz->z.input)->ptr);
2303
+ len = gzfile_get16((Bytef*)RSTRING_PTR(gz->z.input));
2051
2304
  if (!gzfile_read_raw_ensure(gz, 2 + len)) {
2052
2305
  rb_raise(cGzError, "unexpected end of file");
2053
2306
  }
2054
2307
  zstream_discard_input(&gz->z, 2 + len);
2055
2308
  }
2056
2309
  if (flags & GZ_FLAG_ORIG_NAME) {
2310
+ if (!gzfile_read_raw_ensure(gz, 1)) {
2311
+ rb_raise(cGzError, "unexpected end of file");
2312
+ }
2057
2313
  p = gzfile_read_raw_until_zero(gz, 0);
2058
- len = p - RSTRING(gz->z.input)->ptr;
2059
- gz->orig_name = rb_str_new(RSTRING(gz->z.input)->ptr, len);
2314
+ len = p - RSTRING_PTR(gz->z.input);
2315
+ gz->orig_name = rb_str_new(RSTRING_PTR(gz->z.input), len);
2060
2316
  OBJ_TAINT(gz->orig_name); /* for safe */
2061
2317
  zstream_discard_input(&gz->z, len + 1);
2062
2318
  }
2063
2319
  if (flags & GZ_FLAG_COMMENT) {
2320
+ if (!gzfile_read_raw_ensure(gz, 1)) {
2321
+ rb_raise(cGzError, "unexpected end of file");
2322
+ }
2064
2323
  p = gzfile_read_raw_until_zero(gz, 0);
2065
- len = p - RSTRING(gz->z.input)->ptr;
2066
- gz->comment = rb_str_new(RSTRING(gz->z.input)->ptr, len);
2324
+ len = p - RSTRING_PTR(gz->z.input);
2325
+ gz->comment = rb_str_new(RSTRING_PTR(gz->z.input), len);
2067
2326
  OBJ_TAINT(gz->comment); /* for safe */
2068
2327
  zstream_discard_input(&gz->z, len + 1);
2069
2328
  }
2070
2329
 
2071
- if (gz->z.input != Qnil && RSTRING(gz->z.input)->len > 0) {
2330
+ if (gz->z.input != Qnil && RSTRING_LEN(gz->z.input) > 0) {
2072
2331
  zstream_run(&gz->z, 0, 0, Z_SYNC_FLUSH);
2073
2332
  }
2074
2333
  }
2075
2334
 
2076
2335
  static void
2077
- gzfile_check_footer(gz)
2078
- struct gzfile *gz;
2336
+ gzfile_check_footer(struct gzfile *gz)
2079
2337
  {
2080
2338
  unsigned long crc, length;
2081
2339
 
2082
2340
  gz->z.flags |= GZFILE_FLAG_FOOTER_FINISHED;
2083
2341
 
2084
2342
  if (!gzfile_read_raw_ensure(gz, 8)) { /* 8 is the size of gzip footer */
2085
- rb_raise(cNoFooter, "footer is not found");
2343
+ gzfile_raise(gz, cNoFooter, "footer is not found");
2086
2344
  }
2087
2345
 
2088
- crc = gzfile_get32(RSTRING(gz->z.input)->ptr);
2089
- length = gzfile_get32(RSTRING(gz->z.input)->ptr + 4);
2346
+ crc = gzfile_get32((Bytef*)RSTRING_PTR(gz->z.input));
2347
+ length = gzfile_get32((Bytef*)RSTRING_PTR(gz->z.input) + 4);
2090
2348
 
2091
2349
  gz->z.stream.total_in += 8; /* to rewind correctly */
2092
2350
  zstream_discard_input(&gz->z, 8);
@@ -2094,23 +2352,20 @@ gzfile_check_footer(gz)
2094
2352
  if (gz->crc != crc) {
2095
2353
  rb_raise(cCRCError, "invalid compressed data -- crc error");
2096
2354
  }
2097
- if ((gz->z.stream.total_out & 0xFFFFFFFFUL) != length) {
2355
+ if ((uint32_t)gz->z.stream.total_out != length) {
2098
2356
  rb_raise(cLengthError, "invalid compressed data -- length error");
2099
2357
  }
2100
2358
  }
2101
2359
 
2102
2360
  static void
2103
- gzfile_write(gz, str, len)
2104
- struct gzfile *gz;
2105
- Bytef *str;
2106
- uInt len;
2361
+ gzfile_write(struct gzfile *gz, Bytef *str, long len)
2107
2362
  {
2108
2363
  if (!(gz->z.flags & GZFILE_FLAG_HEADER_FINISHED)) {
2109
2364
  gzfile_make_header(gz);
2110
2365
  }
2111
2366
 
2112
2367
  if (len > 0 || (gz->z.flags & GZFILE_FLAG_SYNC)) {
2113
- gz->crc = crc32(gz->crc, str, len);
2368
+ gz->crc = checksum_long(crc32, gz->crc, str, len);
2114
2369
  zstream_run(&gz->z, str, len, (gz->z.flags & GZFILE_FLAG_SYNC)
2115
2370
  ? Z_SYNC_FLUSH : Z_NO_FLUSH);
2116
2371
  }
@@ -2118,8 +2373,7 @@ gzfile_write(gz, str, len)
2118
2373
  }
2119
2374
 
2120
2375
  static long
2121
- gzfile_read_more(gz)
2122
- struct gzfile *gz;
2376
+ gzfile_read_more(struct gzfile *gz)
2123
2377
  {
2124
2378
  volatile VALUE str;
2125
2379
 
@@ -2131,8 +2385,8 @@ gzfile_read_more(gz)
2131
2385
  }
2132
2386
  break;
2133
2387
  }
2134
- if (RSTRING(str)->len > 0) { /* prevent Z_BUF_ERROR */
2135
- zstream_run(&gz->z, RSTRING(str)->ptr, RSTRING(str)->len,
2388
+ if (RSTRING_LEN(str) > 0) { /* prevent Z_BUF_ERROR */
2389
+ zstream_run(&gz->z, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str),
2136
2390
  Z_SYNC_FLUSH);
2137
2391
  }
2138
2392
  if (gz->z.buf_filled > 0) break;
@@ -2141,31 +2395,47 @@ gzfile_read_more(gz)
2141
2395
  }
2142
2396
 
2143
2397
  static void
2144
- gzfile_calc_crc(gz, str)
2145
- struct gzfile *gz;
2146
- VALUE str;
2398
+ gzfile_calc_crc(struct gzfile *gz, VALUE str)
2147
2399
  {
2148
- if (RSTRING(str)->len <= gz->ungetc) {
2149
- gz->ungetc -= RSTRING(str)->len;
2400
+ if (RSTRING_LEN(str) <= gz->ungetc) {
2401
+ gz->ungetc -= RSTRING_LEN(str);
2150
2402
  }
2151
2403
  else {
2152
- gz->crc = crc32(gz->crc, RSTRING(str)->ptr + gz->ungetc,
2153
- RSTRING(str)->len - gz->ungetc);
2404
+ gz->crc = checksum_long(crc32, gz->crc, (Bytef*)RSTRING_PTR(str) + gz->ungetc,
2405
+ RSTRING_LEN(str) - gz->ungetc);
2154
2406
  gz->ungetc = 0;
2155
2407
  }
2156
2408
  }
2157
2409
 
2158
2410
  static VALUE
2159
- gzfile_read(gz, len)
2160
- struct gzfile *gz;
2161
- int len;
2411
+ gzfile_newstr(struct gzfile *gz, VALUE str)
2162
2412
  {
2163
- VALUE dst;
2413
+ if (!gz->enc2) {
2414
+ rb_enc_associate(str, gz->enc);
2415
+ OBJ_TAINT(str); /* for safe */
2416
+ return str;
2417
+ }
2418
+ /* TODO: Encodings
2419
+ *
2420
+ if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
2421
+ str = rb_econv_str_convert(gz->ec, str, ECONV_PARTIAL_INPUT);
2422
+ rb_enc_associate(str, gz->enc);
2423
+ OBJ_TAINT(str);
2424
+ return str;
2425
+ }
2426
+ return rb_str_conv_enc_opts(str, gz->enc2, gz->enc,
2427
+ gz->ecflags, gz->ecopts);
2428
+ */
2429
+ return str;
2430
+ }
2164
2431
 
2432
+ static long
2433
+ gzfile_fill(struct gzfile *gz, long len)
2434
+ {
2165
2435
  if (len < 0)
2166
- rb_raise(rb_eArgError, "negative length %d given", len);
2436
+ rb_raise(rb_eArgError, "negative length %ld given", len);
2167
2437
  if (len == 0)
2168
- return rb_str_new(0, 0);
2438
+ return 0;
2169
2439
  while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
2170
2440
  gzfile_read_more(gz);
2171
2441
  }
@@ -2173,51 +2443,155 @@ gzfile_read(gz, len)
2173
2443
  if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2174
2444
  gzfile_check_footer(gz);
2175
2445
  }
2176
- return Qnil;
2446
+ return -1;
2177
2447
  }
2448
+ return len < gz->z.buf_filled ? len : gz->z.buf_filled;
2449
+ }
2450
+
2451
+ static VALUE
2452
+ gzfile_read(struct gzfile *gz, long len)
2453
+ {
2454
+ VALUE dst;
2178
2455
 
2456
+ len = gzfile_fill(gz, len);
2457
+ if (len == 0) return rb_str_new(0, 0);
2458
+ if (len < 0) return Qnil;
2179
2459
  dst = zstream_shift_buffer(&gz->z, len);
2180
2460
  gzfile_calc_crc(gz, dst);
2181
-
2182
- OBJ_TAINT(dst); /* for safe */
2183
2461
  return dst;
2184
2462
  }
2185
2463
 
2186
2464
  static VALUE
2187
- gzfile_read_all(gz)
2188
- struct gzfile *gz;
2465
+ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
2189
2466
  {
2190
2467
  VALUE dst;
2191
2468
 
2192
- while (!ZSTREAM_IS_FINISHED(&gz->z)) {
2469
+ if (len < 0)
2470
+ rb_raise(rb_eArgError, "negative length %ld given", len);
2471
+
2472
+ if (!NIL_P(outbuf))
2473
+ OBJ_TAINT(outbuf);
2474
+
2475
+ if (len == 0) {
2476
+ if (NIL_P(outbuf))
2477
+ return rb_str_new(0, 0);
2478
+ else {
2479
+ rb_str_resize(outbuf, 0);
2480
+ return outbuf;
2481
+ }
2482
+ }
2483
+ while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled == 0) {
2193
2484
  gzfile_read_more(gz);
2194
2485
  }
2195
2486
  if (GZFILE_IS_FINISHED(gz)) {
2196
2487
  if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2197
2488
  gzfile_check_footer(gz);
2198
2489
  }
2199
- return rb_str_new(0, 0);
2490
+ if (!NIL_P(outbuf))
2491
+ rb_str_resize(outbuf, 0);
2492
+ rb_raise(rb_eEOFError, "end of file reached");
2200
2493
  }
2201
2494
 
2202
- dst = zstream_detach_buffer(&gz->z);
2495
+ dst = zstream_shift_buffer(&gz->z, len);
2203
2496
  gzfile_calc_crc(gz, dst);
2204
2497
 
2498
+ if (!NIL_P(outbuf)) {
2499
+ rb_str_resize(outbuf, RSTRING_LEN(dst));
2500
+ memcpy(RSTRING_PTR(outbuf), RSTRING_PTR(dst), RSTRING_LEN(dst));
2501
+ dst = outbuf;
2502
+ }
2205
2503
  OBJ_TAINT(dst); /* for safe */
2206
2504
  return dst;
2207
2505
  }
2208
2506
 
2209
- static void
2210
- gzfile_ungetc(gz, c)
2211
- struct gzfile *gz;
2212
- int c;
2507
+ static VALUE
2508
+ gzfile_read_all(struct gzfile *gz)
2509
+ {
2510
+ VALUE dst;
2511
+
2512
+ while (!ZSTREAM_IS_FINISHED(&gz->z)) {
2513
+ gzfile_read_more(gz);
2514
+ }
2515
+ if (GZFILE_IS_FINISHED(gz)) {
2516
+ if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2517
+ gzfile_check_footer(gz);
2518
+ }
2519
+ return rb_str_new(0, 0);
2520
+ }
2521
+
2522
+ dst = zstream_detach_buffer(&gz->z);
2523
+ gzfile_calc_crc(gz, dst);
2524
+ OBJ_TAINT(dst);
2525
+ return gzfile_newstr(gz, dst);
2526
+ }
2527
+
2528
+ static VALUE
2529
+ gzfile_getc(struct gzfile *gz)
2530
+ {
2531
+ VALUE buf, dst = 0;
2532
+ int len;
2533
+
2534
+ len = rb_enc_mbmaxlen(gz->enc);
2535
+ while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
2536
+ gzfile_read_more(gz);
2537
+ }
2538
+ if (GZFILE_IS_FINISHED(gz)) {
2539
+ if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
2540
+ gzfile_check_footer(gz);
2541
+ }
2542
+ return Qnil;
2543
+ }
2544
+
2545
+ /* TODO: Encodings
2546
+ *
2547
+ if (gz->ec && rb_enc_dummy_p(gz->enc2)) {
2548
+ const unsigned char *ss, *sp, *se;
2549
+ unsigned char *ds, *dp, *de;
2550
+ rb_econv_result_t res;
2551
+
2552
+ if (!gz->cbuf) {
2553
+ gz->cbuf = ALLOC_N(char, GZFILE_CBUF_CAPA);
2554
+ }
2555
+ ss = sp = (const unsigned char*)RSTRING_PTR(gz->z.buf);
2556
+ se = sp + gz->z.buf_filled;
2557
+ ds = dp = (unsigned char *)gz->cbuf;
2558
+ de = (unsigned char *)ds + GZFILE_CBUF_CAPA;
2559
+ res = rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
2560
+ rb_econv_check_error(gz->ec);
2561
+ dst = zstream_shift_buffer(&gz->z, sp - ss);
2562
+ gzfile_calc_crc(gz, dst);
2563
+ dst = rb_str_new(gz->cbuf, dp - ds);
2564
+ rb_enc_associate(dst, gz->enc);
2565
+ OBJ_TAINT(dst);
2566
+ return dst;
2567
+ }
2568
+ else {
2569
+ */
2570
+ buf = gz->z.buf;
2571
+ len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
2572
+ dst = gzfile_read(gz, len);
2573
+ return gzfile_newstr(gz, dst);
2574
+ /* TODO: Encodings
2575
+ }
2576
+ */
2577
+ }
2578
+
2579
+ static void
2580
+ gzfile_ungets(struct gzfile *gz, const Bytef *b, long len)
2581
+ {
2582
+ zstream_buffer_ungets(&gz->z, b, len);
2583
+ gz->ungetc+=len;
2584
+ }
2585
+
2586
+ static void
2587
+ gzfile_ungetbyte(struct gzfile *gz, int c)
2213
2588
  {
2214
- zstream_buffer_ungetc(&gz->z, c);
2589
+ zstream_buffer_ungetbyte(&gz->z, c);
2215
2590
  gz->ungetc++;
2216
2591
  }
2217
2592
 
2218
2593
  static VALUE
2219
- gzfile_writer_end_run(arg)
2220
- VALUE arg;
2594
+ gzfile_writer_end_run(VALUE arg)
2221
2595
  {
2222
2596
  struct gzfile *gz = (struct gzfile *)arg;
2223
2597
 
@@ -2225,7 +2599,7 @@ gzfile_writer_end_run(arg)
2225
2599
  gzfile_make_header(gz);
2226
2600
  }
2227
2601
 
2228
- zstream_run(&gz->z, "", 0, Z_FINISH);
2602
+ zstream_run(&gz->z, (Bytef*)"", 0, Z_FINISH);
2229
2603
  gzfile_make_footer(gz);
2230
2604
  gzfile_write_raw(gz);
2231
2605
 
@@ -2233,8 +2607,7 @@ gzfile_writer_end_run(arg)
2233
2607
  }
2234
2608
 
2235
2609
  static void
2236
- gzfile_writer_end(gz)
2237
- struct gzfile *gz;
2610
+ gzfile_writer_end(struct gzfile *gz)
2238
2611
  {
2239
2612
  if (ZSTREAM_IS_CLOSING(&gz->z)) return;
2240
2613
  gz->z.flags |= ZSTREAM_FLAG_CLOSING;
@@ -2243,8 +2616,7 @@ gzfile_writer_end(gz)
2243
2616
  }
2244
2617
 
2245
2618
  static VALUE
2246
- gzfile_reader_end_run(arg)
2247
- VALUE arg;
2619
+ gzfile_reader_end_run(VALUE arg)
2248
2620
  {
2249
2621
  struct gzfile *gz = (struct gzfile *)arg;
2250
2622
 
@@ -2257,8 +2629,7 @@ gzfile_reader_end_run(arg)
2257
2629
  }
2258
2630
 
2259
2631
  static void
2260
- gzfile_reader_end(gz)
2261
- struct gzfile *gz;
2632
+ gzfile_reader_end(struct gzfile *gz)
2262
2633
  {
2263
2634
  if (ZSTREAM_IS_CLOSING(&gz->z)) return;
2264
2635
  gz->z.flags |= ZSTREAM_FLAG_CLOSING;
@@ -2267,14 +2638,13 @@ gzfile_reader_end(gz)
2267
2638
  }
2268
2639
 
2269
2640
  static void
2270
- gzfile_reader_rewind(gz)
2271
- struct gzfile *gz;
2641
+ gzfile_reader_rewind(struct gzfile *gz)
2272
2642
  {
2273
2643
  long n;
2274
2644
 
2275
2645
  n = gz->z.stream.total_in;
2276
2646
  if (!NIL_P(gz->z.input)) {
2277
- n += RSTRING(gz->z.input)->len;
2647
+ n += RSTRING_LEN(gz->z.input);
2278
2648
  }
2279
2649
 
2280
2650
  rb_funcall(gz->io, id_seek, 2, rb_int2inum(-n), INT2FIX(1));
@@ -2282,8 +2652,7 @@ gzfile_reader_rewind(gz)
2282
2652
  }
2283
2653
 
2284
2654
  static VALUE
2285
- gzfile_reader_get_unused(gz)
2286
- struct gzfile *gz;
2655
+ gzfile_reader_get_unused(struct gzfile *gz)
2287
2656
  {
2288
2657
  VALUE str;
2289
2658
 
@@ -2300,8 +2669,7 @@ gzfile_reader_get_unused(gz)
2300
2669
  }
2301
2670
 
2302
2671
  static struct gzfile *
2303
- get_gzfile(obj)
2304
- VALUE obj;
2672
+ get_gzfile(VALUE obj)
2305
2673
  {
2306
2674
  struct gzfile *gz;
2307
2675
 
@@ -2323,12 +2691,51 @@ get_gzfile(obj)
2323
2691
  * Zlib::GzipReader for reading, and Zlib::GzipWriter for writing.
2324
2692
  *
2325
2693
  * GzipReader should be used by associating an IO, or IO-like, object.
2694
+ *
2695
+ * == Method Catalogue
2696
+ *
2697
+ * - ::wrap
2698
+ * - ::open (Zlib::GzipReader::open and Zlib::GzipWriter::open)
2699
+ * - #close
2700
+ * - #closed?
2701
+ * - #comment
2702
+ * - comment= (Zlib::GzipWriter#comment=)
2703
+ * - #crc
2704
+ * - eof? (Zlib::GzipReader#eof?)
2705
+ * - #finish
2706
+ * - #level
2707
+ * - lineno (Zlib::GzipReader#lineno)
2708
+ * - lineno= (Zlib::GzipReader#lineno=)
2709
+ * - #mtime
2710
+ * - mtime= (Zlib::GzipWriter#mtime=)
2711
+ * - #orig_name
2712
+ * - orig_name (Zlib::GzipWriter#orig_name=)
2713
+ * - #os_code
2714
+ * - path (when the underlying IO supports #path)
2715
+ * - #sync
2716
+ * - #sync=
2717
+ * - #to_io
2718
+ *
2719
+ * (due to internal structure, documentation may appear under Zlib::GzipReader
2720
+ * or Zlib::GzipWriter)
2326
2721
  */
2327
2722
 
2328
2723
 
2724
+ typedef struct {
2725
+ int argc;
2726
+ VALUE *argv;
2727
+ VALUE klass;
2728
+ } new_wrap_arg_t;
2729
+
2329
2730
  static VALUE
2330
- gzfile_ensure_close(obj)
2331
- VALUE obj;
2731
+ new_wrap(VALUE tmp)
2732
+ {
2733
+ new_wrap_arg_t *arg = (new_wrap_arg_t *)tmp;
2734
+ return rb_class_new_instance(arg->argc, arg->argv, arg->klass);
2735
+ }
2736
+
2737
+ static VALUE
2738
+ gzfile_ensure_close(VALUE obj)
2332
2739
  {
2333
2740
  struct gzfile *gz;
2334
2741
 
@@ -2339,16 +2746,26 @@ gzfile_ensure_close(obj)
2339
2746
  return Qnil;
2340
2747
  }
2341
2748
 
2342
- /*
2343
- * See Zlib::GzipReader#wrap and Zlib::GzipWriter#wrap.
2344
- */
2345
2749
  static VALUE
2346
- rb_gzfile_s_wrap(argc, argv, klass)
2347
- int argc;
2348
- VALUE *argv;
2349
- VALUE klass;
2750
+ gzfile_wrap(int argc, VALUE *argv, VALUE klass, int close_io_on_error)
2350
2751
  {
2351
- VALUE obj = rb_class_new_instance(argc, argv, klass);
2752
+ VALUE obj;
2753
+
2754
+ if (close_io_on_error) {
2755
+ int state = 0;
2756
+ new_wrap_arg_t arg;
2757
+ arg.argc = argc;
2758
+ arg.argv = argv;
2759
+ arg.klass = klass;
2760
+ obj = rb_protect(new_wrap, (VALUE)&arg, &state);
2761
+ if (state) {
2762
+ rb_io_close(argv[0]);
2763
+ rb_jump_tag(state);
2764
+ }
2765
+ }
2766
+ else {
2767
+ obj = rb_class_new_instance(argc, argv, klass);
2768
+ }
2352
2769
 
2353
2770
  if (rb_block_given_p()) {
2354
2771
  return rb_ensure(rb_yield, obj, gzfile_ensure_close, obj);
@@ -2359,14 +2776,30 @@ rb_gzfile_s_wrap(argc, argv, klass)
2359
2776
  }
2360
2777
 
2361
2778
  /*
2779
+ * Document-method: Zlib::GzipFile.wrap
2780
+ *
2781
+ * call-seq: Zlib::GzipFile.wrap(io) { |gz| ... }
2782
+ *
2783
+ * Creates a GzipFile object associated with +io+, and
2784
+ * executes the block with the newly created GzipFile object,
2785
+ * just like File.open. The GzipFile object will be closed
2786
+ * automatically after executing the block. If you want to keep
2787
+ * the associated IO object opening, you may call
2788
+ * +Zlib::GzipFile#finish+ method in the block.
2789
+ */
2790
+ static VALUE
2791
+ rb_gzfile_s_wrap(int argc, VALUE *argv, VALUE klass)
2792
+ {
2793
+ return gzfile_wrap(argc, argv, klass, 0);
2794
+ }
2795
+
2796
+ /*
2797
+ * Document-method: Zlib::GzipFile.open
2798
+ *
2362
2799
  * See Zlib::GzipReader#open and Zlib::GzipWriter#open.
2363
2800
  */
2364
2801
  static VALUE
2365
- gzfile_s_open(argc, argv, klass, mode)
2366
- int argc;
2367
- VALUE *argv;
2368
- VALUE klass;
2369
- const char *mode;
2802
+ gzfile_s_open(int argc, VALUE *argv, VALUE klass, const char *mode)
2370
2803
  {
2371
2804
  VALUE io, filename;
2372
2805
 
@@ -2374,70 +2807,74 @@ gzfile_s_open(argc, argv, klass, mode)
2374
2807
  rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
2375
2808
  }
2376
2809
  filename = argv[0];
2377
- SafeStringValue(filename);
2378
- io = rb_file_open(RSTRING(filename)->ptr, mode);
2379
-
2810
+ io = rb_file_open_str(filename, mode);
2380
2811
  argv[0] = io;
2381
- return rb_gzfile_s_wrap(argc, argv, klass);
2812
+ return gzfile_wrap(argc, argv, klass, 1);
2382
2813
  }
2383
2814
 
2384
2815
  /*
2816
+ * Document-method: Zlib::GzipFile#to_io
2817
+ *
2385
2818
  * Same as IO.
2386
2819
  */
2387
2820
  static VALUE
2388
- rb_gzfile_to_io(obj)
2389
- VALUE obj;
2821
+ rb_gzfile_to_io(VALUE obj)
2390
2822
  {
2391
2823
  return get_gzfile(obj)->io;
2392
2824
  }
2393
2825
 
2394
2826
  /*
2827
+ * Document-method: Zlib::GzipFile#crc
2828
+ *
2395
2829
  * Returns CRC value of the uncompressed data.
2396
2830
  */
2397
2831
  static VALUE
2398
- rb_gzfile_crc(obj)
2399
- VALUE obj;
2832
+ rb_gzfile_crc(VALUE obj)
2400
2833
  {
2401
2834
  return rb_uint2inum(get_gzfile(obj)->crc);
2402
2835
  }
2403
2836
 
2404
2837
  /*
2838
+ * Document-method: Zlib::GzipFile#mtime
2839
+ *
2405
2840
  * Returns last modification time recorded in the gzip file header.
2406
2841
  */
2407
2842
  static VALUE
2408
- rb_gzfile_mtime(obj)
2409
- VALUE obj;
2843
+ rb_gzfile_mtime(VALUE obj)
2410
2844
  {
2411
2845
  return rb_time_new(get_gzfile(obj)->mtime, (time_t)0);
2412
2846
  }
2413
2847
 
2414
2848
  /*
2849
+ * Document-method: Zlib::GzipFile#level
2850
+ *
2415
2851
  * Returns compression level.
2416
2852
  */
2417
2853
  static VALUE
2418
- rb_gzfile_level(obj)
2419
- VALUE obj;
2854
+ rb_gzfile_level(VALUE obj)
2420
2855
  {
2421
2856
  return INT2FIX(get_gzfile(obj)->level);
2422
2857
  }
2423
2858
 
2424
2859
  /*
2860
+ * Document-method: Zlib::GzipFile#os_code
2861
+ *
2425
2862
  * Returns OS code number recorded in the gzip file header.
2426
2863
  */
2427
2864
  static VALUE
2428
- rb_gzfile_os_code(obj)
2429
- VALUE obj;
2865
+ rb_gzfile_os_code(VALUE obj)
2430
2866
  {
2431
2867
  return INT2FIX(get_gzfile(obj)->os_code);
2432
2868
  }
2433
2869
 
2434
2870
  /*
2871
+ * Document-method: Zlib::GzipFile#orig_name
2872
+ *
2435
2873
  * Returns original filename recorded in the gzip file header, or +nil+ if
2436
2874
  * original filename is not present.
2437
2875
  */
2438
2876
  static VALUE
2439
- rb_gzfile_orig_name(obj)
2440
- VALUE obj;
2877
+ rb_gzfile_orig_name(VALUE obj)
2441
2878
  {
2442
2879
  VALUE str = get_gzfile(obj)->orig_name;
2443
2880
  if (!NIL_P(str)) {
@@ -2448,12 +2885,13 @@ rb_gzfile_orig_name(obj)
2448
2885
  }
2449
2886
 
2450
2887
  /*
2888
+ * Document-method: Zlib::GzipFile#comment
2889
+ *
2451
2890
  * Returns comments recorded in the gzip file header, or nil if the comments
2452
2891
  * is not present.
2453
2892
  */
2454
2893
  static VALUE
2455
- rb_gzfile_comment(obj)
2456
- VALUE obj;
2894
+ rb_gzfile_comment(VALUE obj)
2457
2895
  {
2458
2896
  VALUE str = get_gzfile(obj)->comment;
2459
2897
  if (!NIL_P(str)) {
@@ -2464,21 +2902,23 @@ rb_gzfile_comment(obj)
2464
2902
  }
2465
2903
 
2466
2904
  /*
2467
- * ???
2905
+ * Document-method: Zlib::GzipFile#lineno
2906
+ *
2907
+ * The line number of the last row read from this file.
2468
2908
  */
2469
2909
  static VALUE
2470
- rb_gzfile_lineno(obj)
2471
- VALUE obj;
2910
+ rb_gzfile_lineno(VALUE obj)
2472
2911
  {
2473
2912
  return INT2NUM(get_gzfile(obj)->lineno);
2474
2913
  }
2475
2914
 
2476
2915
  /*
2477
- * ???
2916
+ * Document-method: Zlib::GzipReader#lineno=
2917
+ *
2918
+ * Specify line number of the last row read from this file.
2478
2919
  */
2479
2920
  static VALUE
2480
- rb_gzfile_set_lineno(obj, lineno)
2481
- VALUE obj, lineno;
2921
+ rb_gzfile_set_lineno(VALUE obj, VALUE lineno)
2482
2922
  {
2483
2923
  struct gzfile *gz = get_gzfile(obj);
2484
2924
  gz->lineno = NUM2INT(lineno);
@@ -2486,11 +2926,13 @@ rb_gzfile_set_lineno(obj, lineno)
2486
2926
  }
2487
2927
 
2488
2928
  /*
2489
- * ???
2929
+ * Document-method: Zlib::GzipWriter#mtime=
2930
+ *
2931
+ * Specify the modification time (+mtime+) in the gzip header.
2932
+ * Using a Fixnum or Integer
2490
2933
  */
2491
2934
  static VALUE
2492
- rb_gzfile_set_mtime(obj, mtime)
2493
- VALUE obj, mtime;
2935
+ rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
2494
2936
  {
2495
2937
  struct gzfile *gz = get_gzfile(obj);
2496
2938
  VALUE val;
@@ -2504,17 +2946,18 @@ rb_gzfile_set_mtime(obj, mtime)
2504
2946
  }
2505
2947
  else {
2506
2948
  val = rb_Integer(mtime);
2507
- gz->mtime = FIXNUM_P(val) ? FIX2INT(val) : rb_big2ulong(val);
2949
+ gz->mtime = FIXNUM_P(val) ? FIX2UINT(val) : rb_big2ulong(val);
2508
2950
  }
2509
2951
  return mtime;
2510
2952
  }
2511
2953
 
2512
2954
  /*
2513
- * ???
2955
+ * Document-method: Zlib::GzipFile#orig_name=
2956
+ *
2957
+ * Specify the original name (+str+) in the gzip header.
2514
2958
  */
2515
2959
  static VALUE
2516
- rb_gzfile_set_orig_name(obj, str)
2517
- VALUE obj, str;
2960
+ rb_gzfile_set_orig_name(VALUE obj, VALUE str)
2518
2961
  {
2519
2962
  struct gzfile *gz = get_gzfile(obj);
2520
2963
  VALUE s;
@@ -2524,20 +2967,21 @@ rb_gzfile_set_orig_name(obj, str)
2524
2967
  rb_raise(cGzError, "header is already written");
2525
2968
  }
2526
2969
  s = rb_str_dup(rb_str_to_str(str));
2527
- p = memchr(RSTRING(s)->ptr, '\0', RSTRING(s)->len);
2970
+ p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
2528
2971
  if (p) {
2529
- rb_str_resize(s, p - RSTRING(s)->ptr);
2972
+ rb_str_resize(s, p - RSTRING_PTR(s));
2530
2973
  }
2531
2974
  gz->orig_name = s;
2532
2975
  return str;
2533
2976
  }
2534
2977
 
2535
2978
  /*
2536
- * ???
2979
+ * Document-method: Zlib::GzipFile#comment=
2980
+ *
2981
+ * Specify the comment (+str+) in the gzip header.
2537
2982
  */
2538
2983
  static VALUE
2539
- rb_gzfile_set_comment(obj, str)
2540
- VALUE obj, str;
2984
+ rb_gzfile_set_comment(VALUE obj, VALUE str)
2541
2985
  {
2542
2986
  struct gzfile *gz = get_gzfile(obj);
2543
2987
  VALUE s;
@@ -2547,21 +2991,22 @@ rb_gzfile_set_comment(obj, str)
2547
2991
  rb_raise(cGzError, "header is already written");
2548
2992
  }
2549
2993
  s = rb_str_dup(rb_str_to_str(str));
2550
- p = memchr(RSTRING(s)->ptr, '\0', RSTRING(s)->len);
2994
+ p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
2551
2995
  if (p) {
2552
- rb_str_resize(s, p - RSTRING(s)->ptr);
2996
+ rb_str_resize(s, p - RSTRING_PTR(s));
2553
2997
  }
2554
2998
  gz->comment = s;
2555
2999
  return str;
2556
3000
  }
2557
3001
 
2558
3002
  /*
3003
+ * Document-method: Zlib::GzipFile#close
3004
+ *
2559
3005
  * Closes the GzipFile object. This method calls close method of the
2560
3006
  * associated IO object. Returns the associated IO object.
2561
3007
  */
2562
3008
  static VALUE
2563
- rb_gzfile_close(obj)
2564
- VALUE obj;
3009
+ rb_gzfile_close(VALUE obj)
2565
3010
  {
2566
3011
  struct gzfile *gz = get_gzfile(obj);
2567
3012
  VALUE io;
@@ -2572,13 +3017,14 @@ rb_gzfile_close(obj)
2572
3017
  }
2573
3018
 
2574
3019
  /*
3020
+ * Document-method: Zlib::GzipFile#finish
3021
+ *
2575
3022
  * Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never
2576
3023
  * calls the close method of the associated IO object. Returns the associated IO
2577
3024
  * object.
2578
3025
  */
2579
3026
  static VALUE
2580
- rb_gzfile_finish(obj)
2581
- VALUE obj;
3027
+ rb_gzfile_finish(VALUE obj)
2582
3028
  {
2583
3029
  struct gzfile *gz = get_gzfile(obj);
2584
3030
  VALUE io;
@@ -2589,11 +3035,13 @@ rb_gzfile_finish(obj)
2589
3035
  }
2590
3036
 
2591
3037
  /*
2592
- * Same as IO.
3038
+ * Document-method: Zlib::GzipFile#closed?
3039
+ *
3040
+ * Same as IO#closed?
3041
+ *
2593
3042
  */
2594
3043
  static VALUE
2595
- rb_gzfile_closed_p(obj)
2596
- VALUE obj;
3044
+ rb_gzfile_closed_p(VALUE obj)
2597
3045
  {
2598
3046
  struct gzfile *gz;
2599
3047
  Data_Get_Struct(obj, struct gzfile, gz);
@@ -2601,27 +3049,32 @@ rb_gzfile_closed_p(obj)
2601
3049
  }
2602
3050
 
2603
3051
  /*
2604
- * ???
3052
+ * Document-method: Zlib::GzipFile#eof?
3053
+ *
3054
+ * Returns +true+ or +false+ whether the stream has reached the end.
2605
3055
  */
2606
3056
  static VALUE
2607
- rb_gzfile_eof_p(obj)
2608
- VALUE obj;
3057
+ rb_gzfile_eof_p(VALUE obj)
2609
3058
  {
2610
3059
  struct gzfile *gz = get_gzfile(obj);
2611
3060
  return GZFILE_IS_FINISHED(gz) ? Qtrue : Qfalse;
2612
3061
  }
2613
3062
 
2614
3063
  /*
2615
- * Same as IO.
3064
+ * Document-method: Zlib::GzipFile#sync
3065
+ *
3066
+ * Same as IO#sync
3067
+ *
2616
3068
  */
2617
3069
  static VALUE
2618
- rb_gzfile_sync(obj)
2619
- VALUE obj;
3070
+ rb_gzfile_sync(VALUE obj)
2620
3071
  {
2621
3072
  return (get_gzfile(obj)->z.flags & GZFILE_FLAG_SYNC) ? Qtrue : Qfalse;
2622
3073
  }
2623
3074
 
2624
3075
  /*
3076
+ * Document-method: Zlib::GzipFile#sync=
3077
+ *
2625
3078
  * call-seq: sync = flag
2626
3079
  *
2627
3080
  * Same as IO. If flag is +true+, the associated IO object must respond to the
@@ -2629,8 +3082,7 @@ rb_gzfile_sync(obj)
2629
3082
  * decreases sharply.
2630
3083
  */
2631
3084
  static VALUE
2632
- rb_gzfile_set_sync(obj, mode)
2633
- VALUE obj, mode;
3085
+ rb_gzfile_set_sync(VALUE obj, VALUE mode)
2634
3086
  {
2635
3087
  struct gzfile *gz = get_gzfile(obj);
2636
3088
 
@@ -2644,26 +3096,60 @@ rb_gzfile_set_sync(obj, mode)
2644
3096
  }
2645
3097
 
2646
3098
  /*
2647
- * ???
3099
+ * Document-method: Zlib::GzipFile#total_in
3100
+ *
3101
+ * Total number of input bytes read so far.
2648
3102
  */
2649
3103
  static VALUE
2650
- rb_gzfile_total_in(obj)
2651
- VALUE obj;
3104
+ rb_gzfile_total_in(VALUE obj)
2652
3105
  {
2653
3106
  return rb_uint2inum(get_gzfile(obj)->z.stream.total_in);
2654
3107
  }
2655
3108
 
2656
3109
  /*
2657
- * ???
3110
+ * Document-method: Zlib::GzipFile#total_out
3111
+ *
3112
+ * Total number of output bytes output so far.
2658
3113
  */
2659
3114
  static VALUE
2660
- rb_gzfile_total_out(obj)
2661
- VALUE obj;
3115
+ rb_gzfile_total_out(VALUE obj)
2662
3116
  {
2663
3117
  struct gzfile *gz = get_gzfile(obj);
2664
3118
  return rb_uint2inum(gz->z.stream.total_out - gz->z.buf_filled);
2665
3119
  }
2666
3120
 
3121
+ /*
3122
+ * Document-method: Zlib::GzipFile#path
3123
+ *
3124
+ * call-seq: path
3125
+ *
3126
+ * Returns the path string of the associated IO-like object. This
3127
+ * method is only defined when the IO-like object responds to #path().
3128
+ */
3129
+ static VALUE
3130
+ rb_gzfile_path(VALUE obj)
3131
+ {
3132
+ struct gzfile *gz;
3133
+ Data_Get_Struct(obj, struct gzfile, gz);
3134
+ return gz->path;
3135
+ }
3136
+
3137
+ static void
3138
+ rb_gzfile_ecopts(struct gzfile *gz, VALUE opts)
3139
+ {
3140
+ /* TODO: Encodings
3141
+ *
3142
+ if (!NIL_P(opts)) {
3143
+ rb_io_extract_encoding_option(opts, &gz->enc, &gz->enc2, NULL);
3144
+ }
3145
+ if (gz->enc2) {
3146
+ gz->ecflags = rb_econv_prepare_opts(opts, &opts);
3147
+ gz->ec = rb_econv_open_opts(gz->enc2->name, gz->enc->name,
3148
+ gz->ecflags, opts);
3149
+ gz->ecopts = opts;
3150
+ }
3151
+ */
3152
+ }
2667
3153
 
2668
3154
  /* ------------------------------------------------------------------------- */
2669
3155
 
@@ -2671,9 +3157,9 @@ rb_gzfile_total_out(obj)
2671
3157
  * Document-class: Zlib::GzipWriter
2672
3158
  *
2673
3159
  * Zlib::GzipWriter is a class for writing gzipped files. GzipWriter should
2674
- * be used with an instance of IO, or IO-like, object.
3160
+ * be used with an instance of IO, or IO-like, object.
2675
3161
  *
2676
- * For example:
3162
+ * Following two example generate the same result.
2677
3163
  *
2678
3164
  * Zlib::GzipWriter.open('hoge.gz') do |gz|
2679
3165
  * gz.write 'jugemu jugemu gokou no surikire...'
@@ -2685,8 +3171,14 @@ rb_gzfile_total_out(obj)
2685
3171
  * gz.close
2686
3172
  * end
2687
3173
  *
2688
- * # TODO: test these. Are they equivalent? Can GzipWriter.new take a
2689
- * # block?
3174
+ * To make like gzip(1) does, run following:
3175
+ *
3176
+ * orig = 'hoge.txt'
3177
+ * Zlib::GzipWriter.open('hoge.gz') do |gz|
3178
+ * gz.mtime = File.mtime(orig)
3179
+ * gz.orig_name = orig
3180
+ * gz.write IO.binread(orig)
3181
+ * end
2690
3182
  *
2691
3183
  * NOTE: Due to the limitation of Ruby's finalizer, you must explicitly close
2692
3184
  * GzipWriter objects by Zlib::GzipWriter#close etc. Otherwise, GzipWriter
@@ -2695,8 +3187,7 @@ rb_gzfile_total_out(obj)
2695
3187
  */
2696
3188
 
2697
3189
  static VALUE
2698
- rb_gzwriter_s_allocate(klass)
2699
- VALUE klass;
3190
+ rb_gzwriter_s_allocate(VALUE klass)
2700
3191
  {
2701
3192
  return gzfile_writer_new(klass);
2702
3193
  }
@@ -2706,13 +3197,10 @@ rb_gzwriter_s_allocate(klass)
2706
3197
  *
2707
3198
  * Opens a file specified by +filename+ for writing gzip compressed data, and
2708
3199
  * returns a GzipWriter object associated with that file. Further details of
2709
- * this method are found in Zlib::GzipWriter.new and Zlib::GzipWriter#wrap.
3200
+ * this method are found in Zlib::GzipWriter.new and Zlib::GzipFile.wrap.
2710
3201
  */
2711
3202
  static VALUE
2712
- rb_gzwriter_s_open(argc, argv, klass)
2713
- int argc;
2714
- VALUE *argv;
2715
- VALUE klass;
3203
+ rb_gzwriter_s_open(int argc, VALUE *argv, VALUE klass)
2716
3204
  {
2717
3205
  return gzfile_s_open(argc, argv, klass, "wb");
2718
3206
  }
@@ -2726,15 +3214,17 @@ rb_gzwriter_s_open(argc, argv, klass)
2726
3214
  * +write+ method that behaves same as write method in IO class.
2727
3215
  */
2728
3216
  static VALUE
2729
- rb_gzwriter_initialize(argc, argv, obj)
2730
- int argc;
2731
- VALUE *argv;
2732
- VALUE obj;
3217
+ rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
2733
3218
  {
2734
3219
  struct gzfile *gz;
2735
- VALUE io, level, strategy;
3220
+ VALUE io, level, strategy, opt = Qnil;
2736
3221
  int err;
2737
3222
 
3223
+ if (argc > 1) {
3224
+ opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
3225
+ if (!NIL_P(opt)) argc--;
3226
+ }
3227
+
2738
3228
  rb_scan_args(argc, argv, "12", &io, &level, &strategy);
2739
3229
  Data_Get_Struct(obj, struct gzfile, gz);
2740
3230
 
@@ -2747,6 +3237,12 @@ rb_gzwriter_initialize(argc, argv, obj)
2747
3237
  }
2748
3238
  gz->io = io;
2749
3239
  ZSTREAM_READY(&gz->z);
3240
+ rb_gzfile_ecopts(gz, opt);
3241
+
3242
+ if (rb_respond_to(io, id_path)) {
3243
+ gz->path = rb_funcall(gz->io, id_path, 0);
3244
+ rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
3245
+ }
2750
3246
 
2751
3247
  return obj;
2752
3248
  }
@@ -2759,10 +3255,7 @@ rb_gzwriter_initialize(argc, argv, obj)
2759
3255
  * +flush+ is omitted. It is no use giving flush <tt>Zlib::NO_FLUSH</tt>.
2760
3256
  */
2761
3257
  static VALUE
2762
- rb_gzwriter_flush(argc, argv, obj)
2763
- int argc;
2764
- VALUE *argv;
2765
- VALUE obj;
3258
+ rb_gzwriter_flush(int argc, VALUE *argv, VALUE obj)
2766
3259
  {
2767
3260
  struct gzfile *gz = get_gzfile(obj);
2768
3261
  VALUE v_flush;
@@ -2772,7 +3265,7 @@ rb_gzwriter_flush(argc, argv, obj)
2772
3265
 
2773
3266
  flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
2774
3267
  if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */
2775
- zstream_run(&gz->z, "", 0, flush);
3268
+ zstream_run(&gz->z, (Bytef*)"", 0, flush);
2776
3269
  }
2777
3270
 
2778
3271
  gzfile_write_raw(gz);
@@ -2786,29 +3279,29 @@ rb_gzwriter_flush(argc, argv, obj)
2786
3279
  * Same as IO.
2787
3280
  */
2788
3281
  static VALUE
2789
- rb_gzwriter_write(obj, str)
2790
- VALUE obj, str;
3282
+ rb_gzwriter_write(VALUE obj, VALUE str)
2791
3283
  {
2792
3284
  struct gzfile *gz = get_gzfile(obj);
2793
3285
 
2794
- if (TYPE(str) != T_STRING) {
3286
+ if (TYPE(str) != T_STRING)
2795
3287
  str = rb_obj_as_string(str);
3288
+ if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
3289
+ str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
2796
3290
  }
2797
- gzfile_write(gz, RSTRING(str)->ptr, RSTRING(str)->len);
2798
- return INT2FIX(RSTRING(str)->len);
3291
+ gzfile_write(gz, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
3292
+ return INT2FIX(RSTRING_LEN(str));
2799
3293
  }
2800
3294
 
2801
3295
  /*
2802
3296
  * Same as IO.
2803
3297
  */
2804
3298
  static VALUE
2805
- rb_gzwriter_putc(obj, ch)
2806
- VALUE obj, ch;
3299
+ rb_gzwriter_putc(VALUE obj, VALUE ch)
2807
3300
  {
2808
3301
  struct gzfile *gz = get_gzfile(obj);
2809
3302
  char c = NUM2CHR(ch);
2810
3303
 
2811
- gzfile_write(gz, &c, 1);
3304
+ gzfile_write(gz, (Bytef*)&c, 1);
2812
3305
  return ch;
2813
3306
  }
2814
3307
 
@@ -2854,9 +3347,6 @@ rb_gzwriter_putc(obj, ch)
2854
3347
  * gz.close
2855
3348
  * end
2856
3349
  *
2857
- * # TODO: test these. Are they equivalent? Can GzipReader.new take a
2858
- * # block?
2859
- *
2860
3350
  * == Method Catalogue
2861
3351
  *
2862
3352
  * The following methods in Zlib::GzipReader are just like their counterparts
@@ -2894,29 +3384,29 @@ rb_gzwriter_putc(obj, ch)
2894
3384
  */
2895
3385
 
2896
3386
  static VALUE
2897
- rb_gzreader_s_allocate(klass)
2898
- VALUE klass;
3387
+ rb_gzreader_s_allocate(VALUE klass)
2899
3388
  {
2900
3389
  return gzfile_reader_new(klass);
2901
3390
  }
2902
3391
 
2903
3392
  /*
3393
+ * Document-method: Zlib::GzipReader.open
3394
+ *
2904
3395
  * call-seq: Zlib::GzipReader.open(filename) {|gz| ... }
2905
3396
  *
2906
3397
  * Opens a file specified by +filename+ as a gzipped file, and returns a
2907
3398
  * GzipReader object associated with that file. Further details of this method
2908
- * are in Zlib::GzipReader.new and ZLib::GzipReader.wrap.
3399
+ * are in Zlib::GzipReader.new and ZLib::GzipFile.wrap.
2909
3400
  */
2910
3401
  static VALUE
2911
- rb_gzreader_s_open(argc, argv, klass)
2912
- int argc;
2913
- VALUE *argv;
2914
- VALUE klass;
3402
+ rb_gzreader_s_open(int argc, VALUE *argv, VALUE klass)
2915
3403
  {
2916
3404
  return gzfile_s_open(argc, argv, klass, "rb");
2917
3405
  }
2918
3406
 
2919
3407
  /*
3408
+ * Document-method: Zlib::GzipReader.new
3409
+ *
2920
3410
  * call-seq: Zlib::GzipReader.new(io)
2921
3411
  *
2922
3412
  * Creates a GzipReader object associated with +io+. The GzipReader object reads
@@ -2927,13 +3417,14 @@ rb_gzreader_s_open(argc, argv, klass)
2927
3417
  * exception.
2928
3418
  */
2929
3419
  static VALUE
2930
- rb_gzreader_initialize(obj, io)
2931
- VALUE obj, io;
3420
+ rb_gzreader_initialize(int argc, VALUE *argv, VALUE obj)
2932
3421
  {
3422
+ VALUE io, opt = Qnil;
2933
3423
  struct gzfile *gz;
2934
3424
  int err;
2935
3425
 
2936
3426
  Data_Get_Struct(obj, struct gzfile, gz);
3427
+ rb_scan_args(argc, argv, "1:", &io, &opt);
2937
3428
 
2938
3429
  /* this is undocumented feature of zlib */
2939
3430
  err = inflateInit2(&gz->z.stream, -MAX_WBITS);
@@ -2943,17 +3434,24 @@ rb_gzreader_initialize(obj, io)
2943
3434
  gz->io = io;
2944
3435
  ZSTREAM_READY(&gz->z);
2945
3436
  gzfile_read_header(gz);
3437
+ rb_gzfile_ecopts(gz, opt);
3438
+
3439
+ if (rb_respond_to(io, id_path)) {
3440
+ gz->path = rb_funcall(gz->io, id_path, 0);
3441
+ rb_define_singleton_method(obj, "path", rb_gzfile_path, 0);
3442
+ }
2946
3443
 
2947
3444
  return obj;
2948
3445
  }
2949
3446
 
2950
3447
  /*
3448
+ * Document-method: Zlib::GzipReader#rewind
3449
+ *
2951
3450
  * Resets the position of the file pointer to the point created the GzipReader
2952
3451
  * object. The associated IO object needs to respond to the +seek+ method.
2953
3452
  */
2954
3453
  static VALUE
2955
- rb_gzreader_rewind(obj)
2956
- VALUE obj;
3454
+ rb_gzreader_rewind(VALUE obj)
2957
3455
  {
2958
3456
  struct gzfile *gz = get_gzfile(obj);
2959
3457
  gzfile_reader_rewind(gz);
@@ -2961,12 +3459,13 @@ rb_gzreader_rewind(obj)
2961
3459
  }
2962
3460
 
2963
3461
  /*
3462
+ * Document-method: Zlib::GzipReader#unused
3463
+ *
2964
3464
  * Returns the rest of the data which had read for parsing gzip format, or
2965
3465
  * +nil+ if the whole gzip file is not parsed yet.
2966
3466
  */
2967
3467
  static VALUE
2968
- rb_gzreader_unused(obj)
2969
- VALUE obj;
3468
+ rb_gzreader_unused(VALUE obj)
2970
3469
  {
2971
3470
  struct gzfile *gz;
2972
3471
  Data_Get_Struct(obj, struct gzfile, gz);
@@ -2974,17 +3473,16 @@ rb_gzreader_unused(obj)
2974
3473
  }
2975
3474
 
2976
3475
  /*
3476
+ * Document-method: Zlib::GzipReader#read
3477
+ *
2977
3478
  * See Zlib::GzipReader documentation for a description.
2978
3479
  */
2979
3480
  static VALUE
2980
- rb_gzreader_read(argc, argv, obj)
2981
- int argc;
2982
- VALUE *argv;
2983
- VALUE obj;
3481
+ rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
2984
3482
  {
2985
3483
  struct gzfile *gz = get_gzfile(obj);
2986
3484
  VALUE vlen;
2987
- int len;
3485
+ long len;
2988
3486
 
2989
3487
  rb_scan_args(argc, argv, "01", &vlen);
2990
3488
  if (NIL_P(vlen)) {
@@ -2993,37 +3491,98 @@ rb_gzreader_read(argc, argv, obj)
2993
3491
 
2994
3492
  len = NUM2INT(vlen);
2995
3493
  if (len < 0) {
2996
- rb_raise(rb_eArgError, "negative length %d given", len);
3494
+ rb_raise(rb_eArgError, "negative length %ld given", len);
2997
3495
  }
2998
3496
  return gzfile_read(gz, len);
2999
3497
  }
3000
3498
 
3001
3499
  /*
3500
+ * Document-method: Zlib::GzipReader#readpartial
3501
+ *
3502
+ * call-seq:
3503
+ * gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
3504
+ *
3505
+ * Reads at most <i>maxlen</i> bytes from the gziped stream but
3506
+ * it blocks only if <em>gzipreader</em> has no data immediately available.
3507
+ * If the optional <i>outbuf</i> argument is present,
3508
+ * it must reference a String, which will receive the data.
3509
+ * It raises <code>EOFError</code> on end of file.
3510
+ */
3511
+ static VALUE
3512
+ rb_gzreader_readpartial(int argc, VALUE *argv, VALUE obj)
3513
+ {
3514
+ struct gzfile *gz = get_gzfile(obj);
3515
+ VALUE vlen, outbuf;
3516
+ long len;
3517
+
3518
+ rb_scan_args(argc, argv, "11", &vlen, &outbuf);
3519
+
3520
+ len = NUM2INT(vlen);
3521
+ if (len < 0) {
3522
+ rb_raise(rb_eArgError, "negative length %ld given", len);
3523
+ }
3524
+ if (!NIL_P(outbuf))
3525
+ Check_Type(outbuf, T_STRING);
3526
+ return gzfile_readpartial(gz, len, outbuf);
3527
+ }
3528
+
3529
+ /*
3530
+ * Document-method: Zlib::GzipReader#getc
3531
+ *
3002
3532
  * See Zlib::GzipReader documentation for a description.
3003
3533
  */
3004
3534
  static VALUE
3005
- rb_gzreader_getc(obj)
3006
- VALUE obj;
3535
+ rb_gzreader_getc(VALUE obj)
3536
+ {
3537
+ struct gzfile *gz = get_gzfile(obj);
3538
+
3539
+ return gzfile_getc(gz);
3540
+ }
3541
+
3542
+ /*
3543
+ * Document-method: Zlib::GzipReader#readchar
3544
+ *
3545
+ * See Zlib::GzipReader documentation for a description.
3546
+ */
3547
+ static VALUE
3548
+ rb_gzreader_readchar(VALUE obj)
3549
+ {
3550
+ VALUE dst;
3551
+ dst = rb_gzreader_getc(obj);
3552
+ if (NIL_P(dst)) {
3553
+ rb_raise(rb_eEOFError, "end of file reached");
3554
+ }
3555
+ return dst;
3556
+ }
3557
+
3558
+ /*
3559
+ * Document-method: Zlib::GzipReader#getbyte
3560
+ *
3561
+ * See Zlib::GzipReader documentation for a description.
3562
+ */
3563
+ static VALUE
3564
+ rb_gzreader_getbyte(VALUE obj)
3007
3565
  {
3008
3566
  struct gzfile *gz = get_gzfile(obj);
3009
3567
  VALUE dst;
3010
3568
 
3011
3569
  dst = gzfile_read(gz, 1);
3012
3570
  if (!NIL_P(dst)) {
3013
- dst = INT2FIX((unsigned int)(RSTRING(dst)->ptr[0]) & 0xff);
3571
+ dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
3014
3572
  }
3015
3573
  return dst;
3016
3574
  }
3017
3575
 
3018
3576
  /*
3577
+ * Document-method: Zlib::GzipReader#readbyte
3578
+ *
3019
3579
  * See Zlib::GzipReader documentation for a description.
3020
3580
  */
3021
3581
  static VALUE
3022
- rb_gzreader_readchar(obj)
3023
- VALUE obj;
3582
+ rb_gzreader_readbyte(VALUE obj)
3024
3583
  {
3025
3584
  VALUE dst;
3026
- dst = rb_gzreader_getc(obj);
3585
+ dst = rb_gzreader_getbyte(obj);
3027
3586
  if (NIL_P(dst)) {
3028
3587
  rb_raise(rb_eEOFError, "end of file reached");
3029
3588
  }
@@ -3031,13 +3590,17 @@ rb_gzreader_readchar(obj)
3031
3590
  }
3032
3591
 
3033
3592
  /*
3593
+ * Document-method: Zlib::GzipReader#each_char
3594
+ *
3034
3595
  * See Zlib::GzipReader documentation for a description.
3035
3596
  */
3036
3597
  static VALUE
3037
- rb_gzreader_each_byte(obj)
3038
- VALUE obj;
3598
+ rb_gzreader_each_char(VALUE obj)
3039
3599
  {
3040
3600
  VALUE c;
3601
+
3602
+ RETURN_ENUMERATOR(obj, 0, 0);
3603
+
3041
3604
  while (!NIL_P(c = rb_gzreader_getc(obj))) {
3042
3605
  rb_yield(c);
3043
3606
  }
@@ -3045,20 +3608,59 @@ rb_gzreader_each_byte(obj)
3045
3608
  }
3046
3609
 
3047
3610
  /*
3611
+ * Document-method: Zlib::GzipReader#each_byte
3612
+ *
3048
3613
  * See Zlib::GzipReader documentation for a description.
3049
3614
  */
3050
3615
  static VALUE
3051
- rb_gzreader_ungetc(obj, ch)
3052
- VALUE obj, ch;
3616
+ rb_gzreader_each_byte(VALUE obj)
3617
+ {
3618
+ VALUE c;
3619
+
3620
+ RETURN_ENUMERATOR(obj, 0, 0);
3621
+
3622
+ while (!NIL_P(c = rb_gzreader_getbyte(obj))) {
3623
+ rb_yield(c);
3624
+ }
3625
+ return Qnil;
3626
+ }
3627
+
3628
+ /*
3629
+ * Document-method: Zlib::GzipReader#ungetc
3630
+ *
3631
+ * See Zlib::GzipReader documentation for a description.
3632
+ */
3633
+ static VALUE
3634
+ rb_gzreader_ungetc(VALUE obj, VALUE s)
3635
+ {
3636
+ struct gzfile *gz;
3637
+
3638
+ if (FIXNUM_P(s))
3639
+ return rb_gzreader_ungetbyte(obj, s);
3640
+ gz = get_gzfile(obj);
3641
+ StringValue(s);
3642
+ if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
3643
+ s = rb_str_conv_enc(s, rb_enc_get(s), gz->enc2);
3644
+ }
3645
+ gzfile_ungets(gz, (const Bytef*)RSTRING_PTR(s), RSTRING_LEN(s));
3646
+ return Qnil;
3647
+ }
3648
+
3649
+ /*
3650
+ * Document-method: Zlib::GzipReader#ungetbyte
3651
+ *
3652
+ * See Zlib::GzipReader documentation for a description.
3653
+ */
3654
+ static VALUE
3655
+ rb_gzreader_ungetbyte(VALUE obj, VALUE ch)
3053
3656
  {
3054
3657
  struct gzfile *gz = get_gzfile(obj);
3055
- gzfile_ungetc(gz, NUM2CHR(ch));
3658
+ gzfile_ungetbyte(gz, NUM2CHR(ch));
3056
3659
  return Qnil;
3057
3660
  }
3058
3661
 
3059
3662
  static void
3060
- gzreader_skip_linebreaks(gz)
3061
- struct gzfile *gz;
3663
+ gzreader_skip_linebreaks(struct gzfile *gz)
3062
3664
  {
3063
3665
  VALUE str;
3064
3666
  char *p;
@@ -3069,7 +3671,7 @@ gzreader_skip_linebreaks(gz)
3069
3671
  gzfile_read_more(gz);
3070
3672
  }
3071
3673
  n = 0;
3072
- p = RSTRING(gz->z.buf)->ptr;
3674
+ p = RSTRING_PTR(gz->z.buf);
3073
3675
 
3074
3676
  while (n++, *(p++) == '\n') {
3075
3677
  if (n >= gz->z.buf_filled) {
@@ -3080,7 +3682,7 @@ gzreader_skip_linebreaks(gz)
3080
3682
  gzfile_read_more(gz);
3081
3683
  }
3082
3684
  n = 0;
3083
- p = RSTRING(gz->z.buf)->ptr;
3685
+ p = RSTRING_PTR(gz->z.buf);
3084
3686
  }
3085
3687
  }
3086
3688
 
@@ -3089,53 +3691,102 @@ gzreader_skip_linebreaks(gz)
3089
3691
  }
3090
3692
 
3091
3693
  static void
3092
- rscheck(rsptr, rslen, rs)
3093
- char *rsptr;
3094
- long rslen;
3095
- VALUE rs;
3694
+ rscheck(const char *rsptr, long rslen, VALUE rs)
3096
3695
  {
3097
- if (RSTRING(rs)->ptr != rsptr && RSTRING(rs)->len != rslen)
3696
+ if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
3098
3697
  rb_raise(rb_eRuntimeError, "rs modified");
3099
3698
  }
3100
3699
 
3700
+ static long
3701
+ gzreader_charboundary(struct gzfile *gz, long n)
3702
+ {
3703
+ char *s = RSTRING_PTR(gz->z.buf);
3704
+ char *e = s + gz->z.buf_filled;
3705
+ char *p = rb_enc_left_char_head(s, s + n, e, gz->enc);
3706
+ long l = p - s;
3707
+ if (l < n) {
3708
+ n = rb_enc_precise_mbclen(p, e, gz->enc);
3709
+ if (ONIGENC_MBCLEN_NEEDMORE_P(n)) {
3710
+ if ((l = gzfile_fill(gz, l + ONIGENC_MBCLEN_NEEDMORE_LEN(n))) > 0) {
3711
+ return l;
3712
+ }
3713
+ }
3714
+ else if (ONIGENC_MBCLEN_CHARFOUND_P(n)) {
3715
+ return l + ONIGENC_MBCLEN_CHARFOUND_LEN(n);
3716
+ }
3717
+ }
3718
+ return n;
3719
+ }
3720
+
3101
3721
  static VALUE
3102
- gzreader_gets(argc, argv, obj)
3103
- int argc;
3104
- VALUE *argv;
3105
- VALUE obj;
3722
+ gzreader_gets(int argc, VALUE *argv, VALUE obj)
3106
3723
  {
3107
3724
  struct gzfile *gz = get_gzfile(obj);
3108
3725
  volatile VALUE rs;
3109
3726
  VALUE dst;
3110
- char *rsptr, *p, *res;
3111
- long rslen, n;
3727
+ const char *rsptr;
3728
+ char *p, *res;
3729
+ long rslen, n, limit = -1;
3112
3730
  int rspara;
3731
+ rb_encoding *enc = gz->enc;
3732
+ int maxlen = rb_enc_mbmaxlen(enc);
3113
3733
 
3114
3734
  if (argc == 0) {
3115
3735
  rs = rb_rs;
3116
3736
  }
3117
3737
  else {
3118
- rb_scan_args(argc, argv, "1", &rs);
3119
- if (!NIL_P(rs)) {
3120
- Check_Type(rs, T_STRING);
3738
+ VALUE lim, tmp;
3739
+
3740
+ rb_scan_args(argc, argv, "11", &rs, &lim);
3741
+ if (!NIL_P(lim)) {
3742
+ if (!NIL_P(rs)) StringValue(rs);
3743
+ }
3744
+ else if (!NIL_P(rs)) {
3745
+ tmp = rb_check_string_type(rs);
3746
+ if (NIL_P(tmp)) {
3747
+ lim = rs;
3748
+ rs = rb_rs;
3749
+ }
3750
+ else {
3751
+ rs = tmp;
3752
+ }
3753
+ }
3754
+ if (!NIL_P(lim)) {
3755
+ limit = NUM2LONG(lim);
3756
+ if (limit == 0) return rb_str_new(0,0);
3121
3757
  }
3122
3758
  }
3123
3759
 
3124
3760
  if (NIL_P(rs)) {
3125
- dst = gzfile_read_all(gz);
3126
- if (RSTRING(dst)->len != 0) gz->lineno++;
3127
- else
3128
- return Qnil;
3761
+ if (limit < 0) {
3762
+ dst = gzfile_read_all(gz);
3763
+ if (RSTRING_LEN(dst) == 0) return Qnil;
3764
+ }
3765
+ else if ((n = gzfile_fill(gz, limit)) <= 0) {
3766
+ return Qnil;
3767
+ }
3768
+ else {
3769
+ if (maxlen > 1 && n >= limit && !GZFILE_IS_FINISHED(gz)) {
3770
+ n = gzreader_charboundary(gz, n);
3771
+ }
3772
+ else {
3773
+ n = limit;
3774
+ }
3775
+ dst = zstream_shift_buffer(&gz->z, n);
3776
+ gzfile_calc_crc(gz, dst);
3777
+ dst = gzfile_newstr(gz, dst);
3778
+ }
3779
+ gz->lineno++;
3129
3780
  return dst;
3130
3781
  }
3131
3782
 
3132
- if (RSTRING(rs)->len == 0) {
3783
+ if (RSTRING_LEN(rs) == 0) {
3133
3784
  rsptr = "\n\n";
3134
3785
  rslen = 2;
3135
3786
  rspara = 1;
3136
3787
  } else {
3137
- rsptr = RSTRING(rs)->ptr;
3138
- rslen = RSTRING(rs)->len;
3788
+ rsptr = RSTRING_PTR(rs);
3789
+ rslen = RSTRING_LEN(rs);
3139
3790
  rspara = 0;
3140
3791
  }
3141
3792
 
@@ -3151,18 +3802,25 @@ gzreader_gets(argc, argv, obj)
3151
3802
  gzfile_read_more(gz);
3152
3803
  }
3153
3804
 
3154
- p = RSTRING(gz->z.buf)->ptr;
3805
+ p = RSTRING_PTR(gz->z.buf);
3155
3806
  n = rslen;
3156
3807
  for (;;) {
3808
+ long filled;
3157
3809
  if (n > gz->z.buf_filled) {
3158
3810
  if (ZSTREAM_IS_FINISHED(&gz->z)) break;
3159
3811
  gzfile_read_more(gz);
3160
- p = RSTRING(gz->z.buf)->ptr + n - rslen;
3812
+ p = RSTRING_PTR(gz->z.buf) + n - rslen;
3161
3813
  }
3162
3814
  if (!rspara) rscheck(rsptr, rslen, rs);
3163
- res = memchr(p, rsptr[0], (gz->z.buf_filled - n + 1));
3815
+ filled = gz->z.buf_filled;
3816
+ if (limit > 0 && filled >= limit) {
3817
+ filled = limit;
3818
+ }
3819
+ res = memchr(p, rsptr[0], (filled - n + 1));
3164
3820
  if (!res) {
3165
- n = gz->z.buf_filled + 1;
3821
+ n = filled;
3822
+ if (limit > 0 && filled >= limit) break;
3823
+ n++;
3166
3824
  } else {
3167
3825
  n += (long)(res - p);
3168
3826
  p = res;
@@ -3170,6 +3828,9 @@ gzreader_gets(argc, argv, obj)
3170
3828
  p++, n++;
3171
3829
  }
3172
3830
  }
3831
+ if (maxlen > 1 && n == limit && (gz->z.buf_filled > n || !ZSTREAM_IS_FINISHED(&gz->z))) {
3832
+ n = gzreader_charboundary(gz, n);
3833
+ }
3173
3834
 
3174
3835
  gz->lineno++;
3175
3836
  dst = gzfile_read(gz, n);
@@ -3177,17 +3838,16 @@ gzreader_gets(argc, argv, obj)
3177
3838
  gzreader_skip_linebreaks(gz);
3178
3839
  }
3179
3840
 
3180
- return dst;
3841
+ return gzfile_newstr(gz, dst);
3181
3842
  }
3182
3843
 
3183
3844
  /*
3845
+ * Document-method: Zlib::GzipReader#gets
3846
+ *
3184
3847
  * See Zlib::GzipReader documentation for a description.
3185
3848
  */
3186
3849
  static VALUE
3187
- rb_gzreader_gets(argc, argv, obj)
3188
- int argc;
3189
- VALUE *argv;
3190
- VALUE obj;
3850
+ rb_gzreader_gets(int argc, VALUE *argv, VALUE obj)
3191
3851
  {
3192
3852
  VALUE dst;
3193
3853
  dst = gzreader_gets(argc, argv, obj);
@@ -3198,13 +3858,12 @@ rb_gzreader_gets(argc, argv, obj)
3198
3858
  }
3199
3859
 
3200
3860
  /*
3861
+ * Document-method: Zlib::GzipReader#readline
3862
+ *
3201
3863
  * See Zlib::GzipReader documentation for a description.
3202
3864
  */
3203
3865
  static VALUE
3204
- rb_gzreader_readline(argc, argv, obj)
3205
- int argc;
3206
- VALUE *argv;
3207
- VALUE obj;
3866
+ rb_gzreader_readline(int argc, VALUE *argv, VALUE obj)
3208
3867
  {
3209
3868
  VALUE dst;
3210
3869
  dst = rb_gzreader_gets(argc, argv, obj);
@@ -3215,15 +3874,17 @@ rb_gzreader_readline(argc, argv, obj)
3215
3874
  }
3216
3875
 
3217
3876
  /*
3877
+ * Document-method: Zlib::GzipReader#each
3878
+ *
3218
3879
  * See Zlib::GzipReader documentation for a description.
3219
3880
  */
3220
3881
  static VALUE
3221
- rb_gzreader_each(argc, argv, obj)
3222
- int argc;
3223
- VALUE *argv;
3224
- VALUE obj;
3882
+ rb_gzreader_each(int argc, VALUE *argv, VALUE obj)
3225
3883
  {
3226
3884
  VALUE str;
3885
+
3886
+ RETURN_ENUMERATOR(obj, 0, 0);
3887
+
3227
3888
  while (!NIL_P(str = gzreader_gets(argc, argv, obj))) {
3228
3889
  rb_yield(str);
3229
3890
  }
@@ -3231,13 +3892,12 @@ rb_gzreader_each(argc, argv, obj)
3231
3892
  }
3232
3893
 
3233
3894
  /*
3895
+ * Document-method: Zlib::GzipReader#readlines
3896
+ *
3234
3897
  * See Zlib::GzipReader documentation for a description.
3235
3898
  */
3236
3899
  static VALUE
3237
- rb_gzreader_readlines(argc, argv, obj)
3238
- int argc;
3239
- VALUE *argv;
3240
- VALUE obj;
3900
+ rb_gzreader_readlines(int argc, VALUE *argv, VALUE obj)
3241
3901
  {
3242
3902
  VALUE str, dst;
3243
3903
  dst = rb_ary_new();
@@ -3252,6 +3912,8 @@ rb_gzreader_readlines(argc, argv, obj)
3252
3912
 
3253
3913
 
3254
3914
  /*
3915
+ * Document-module: Zlib
3916
+ *
3255
3917
  * The Zlib module contains several classes for compressing and decompressing
3256
3918
  * streams, and for working with "gzip" files.
3257
3919
  *
@@ -3330,7 +3992,8 @@ rb_gzreader_readlines(argc, argv, obj)
3330
3992
  * Zlib::OS_UNKNOWN
3331
3993
  * The return values of Zlib::GzipFile#os_code method.
3332
3994
  */
3333
- void Init_zlib()
3995
+ void
3996
+ Init_zlib()
3334
3997
  {
3335
3998
  VALUE mZlib, cZStream, cDeflate, cInflate;
3336
3999
  #if GZIP_SUPPORT
@@ -3350,10 +4013,14 @@ void Init_zlib()
3350
4013
 
3351
4014
  rb_define_module_function(mZlib, "zlib_version", rb_zlib_version, 0);
3352
4015
  rb_define_module_function(mZlib, "adler32", rb_zlib_adler32, -1);
4016
+ rb_define_module_function(mZlib, "adler32_combine", rb_zlib_adler32_combine, 3);
3353
4017
  rb_define_module_function(mZlib, "crc32", rb_zlib_crc32, -1);
4018
+ rb_define_module_function(mZlib, "crc32_combine", rb_zlib_crc32_combine, 3);
3354
4019
  rb_define_module_function(mZlib, "crc_table", rb_zlib_crc_table, 0);
3355
4020
 
4021
+ /* The Ruby/zlib version string. */
3356
4022
  rb_define_const(mZlib, "VERSION", rb_str_new2(RUBY_ZLIB_VERSION));
4023
+ /* The string which represents the version of zlib.h */
3357
4024
  rb_define_const(mZlib, "ZLIB_VERSION", rb_str_new2(ZLIB_VERSION));
3358
4025
 
3359
4026
  cZStream = rb_define_class_under(mZlib, "ZStream", rb_cObject);
@@ -3376,12 +4043,19 @@ void Init_zlib()
3376
4043
  rb_define_method(cZStream, "flush_next_in", rb_zstream_flush_next_in, 0);
3377
4044
  rb_define_method(cZStream, "flush_next_out", rb_zstream_flush_next_out, 0);
3378
4045
 
4046
+ /* Integer representing date types which
4047
+ * ZStream#data_type method returns */
3379
4048
  rb_define_const(mZlib, "BINARY", INT2FIX(Z_BINARY));
4049
+ /* Integer representing date types which
4050
+ * ZStream#data_type method returns */
3380
4051
  rb_define_const(mZlib, "ASCII", INT2FIX(Z_ASCII));
4052
+ /* Integer representing date types which
4053
+ * ZStream#data_type method returns */
3381
4054
  rb_define_const(mZlib, "UNKNOWN", INT2FIX(Z_UNKNOWN));
3382
4055
 
3383
4056
  cDeflate = rb_define_class_under(mZlib, "Deflate", cZStream);
3384
4057
  rb_define_singleton_method(cDeflate, "deflate", rb_deflate_s_deflate, -1);
4058
+ rb_define_singleton_method(mZlib, "deflate", rb_deflate_s_deflate, -1);
3385
4059
  rb_define_alloc_func(cDeflate, rb_deflate_s_allocate);
3386
4060
  rb_define_method(cDeflate, "initialize", rb_deflate_initialize, -1);
3387
4061
  rb_define_method(cDeflate, "initialize_copy", rb_deflate_init_copy, 1);
@@ -3393,6 +4067,7 @@ void Init_zlib()
3393
4067
 
3394
4068
  cInflate = rb_define_class_under(mZlib, "Inflate", cZStream);
3395
4069
  rb_define_singleton_method(cInflate, "inflate", rb_inflate_s_inflate, 1);
4070
+ rb_define_singleton_method(mZlib, "inflate", rb_inflate_s_inflate, 1);
3396
4071
  rb_define_alloc_func(cInflate, rb_inflate_s_allocate);
3397
4072
  rb_define_method(cInflate, "initialize", rb_inflate_initialize, -1);
3398
4073
  rb_define_method(cInflate, "inflate", rb_inflate_inflate, 1);
@@ -3401,35 +4076,90 @@ void Init_zlib()
3401
4076
  rb_define_method(cInflate, "sync_point?", rb_inflate_sync_point_p, 0);
3402
4077
  rb_define_method(cInflate, "set_dictionary", rb_inflate_set_dictionary, 1);
3403
4078
 
4079
+ /* compression level 0
4080
+ *
4081
+ * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
3404
4082
  rb_define_const(mZlib, "NO_COMPRESSION", INT2FIX(Z_NO_COMPRESSION));
4083
+ /* compression level 1
4084
+ *
4085
+ * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
3405
4086
  rb_define_const(mZlib, "BEST_SPEED", INT2FIX(Z_BEST_SPEED));
4087
+ /* compression level 9
4088
+ *
4089
+ * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
3406
4090
  rb_define_const(mZlib, "BEST_COMPRESSION", INT2FIX(Z_BEST_COMPRESSION));
4091
+ /* compression level -1
4092
+ *
4093
+ * Which is an argument for Deflate.new, Deflate#deflate, and so on. */
3407
4094
  rb_define_const(mZlib, "DEFAULT_COMPRESSION",
3408
4095
  INT2FIX(Z_DEFAULT_COMPRESSION));
3409
4096
 
4097
+ /* compression method 1
4098
+ *
4099
+ * Which is an argument for Deflate.new and Deflate#params. */
3410
4100
  rb_define_const(mZlib, "FILTERED", INT2FIX(Z_FILTERED));
4101
+ /* compression method 2
4102
+ *
4103
+ * Which is an argument for Deflate.new and Deflate#params. */
3411
4104
  rb_define_const(mZlib, "HUFFMAN_ONLY", INT2FIX(Z_HUFFMAN_ONLY));
4105
+ /* compression method 0
4106
+ *
4107
+ * Which is an argument for Deflate.new and Deflate#params. */
3412
4108
  rb_define_const(mZlib, "DEFAULT_STRATEGY", INT2FIX(Z_DEFAULT_STRATEGY));
3413
4109
 
4110
+ /* The default value of windowBits which is an argument for
4111
+ * Deflate.new and Inflate.new.
4112
+ */
3414
4113
  rb_define_const(mZlib, "MAX_WBITS", INT2FIX(MAX_WBITS));
4114
+ /* Default value is 8
4115
+ *
4116
+ * The integer representing memory levels.
4117
+ * Which are an argument for Deflate.new, Deflate#params, and so on. */
3415
4118
  rb_define_const(mZlib, "DEF_MEM_LEVEL", INT2FIX(DEF_MEM_LEVEL));
4119
+ /* Maximum level is 9
4120
+ *
4121
+ * The integers representing memory levels which are an argument for
4122
+ * Deflate.new, Deflate#params, and so on. */
3416
4123
  rb_define_const(mZlib, "MAX_MEM_LEVEL", INT2FIX(MAX_MEM_LEVEL));
3417
4124
 
4125
+ /* Output control - 0
4126
+ *
4127
+ * The integers to control the output of the deflate stream, which are
4128
+ * an argument for Deflate#deflate and so on. */
3418
4129
  rb_define_const(mZlib, "NO_FLUSH", INT2FIX(Z_NO_FLUSH));
4130
+ /* Output control - 2
4131
+ *
4132
+ * The integers to control the output of the deflate stream, which are
4133
+ * an argument for Deflate#deflate and so on. */
3419
4134
  rb_define_const(mZlib, "SYNC_FLUSH", INT2FIX(Z_SYNC_FLUSH));
4135
+ /* Output control - 3
4136
+ *
4137
+ * The integers to control the output of the deflate stream, which are
4138
+ * an argument for Deflate#deflate and so on. */
3420
4139
  rb_define_const(mZlib, "FULL_FLUSH", INT2FIX(Z_FULL_FLUSH));
4140
+ /* Oputput control - 4
4141
+ *
4142
+ * The integers to control the output of the deflate stream, which are
4143
+ * an argument for Deflate#deflate and so on. */
3421
4144
  rb_define_const(mZlib, "FINISH", INT2FIX(Z_FINISH));
3422
4145
 
3423
4146
  #if GZIP_SUPPORT
3424
4147
  id_write = rb_intern("write");
3425
4148
  id_read = rb_intern("read");
4149
+ id_readpartial = rb_intern("readpartial");
3426
4150
  id_flush = rb_intern("flush");
3427
4151
  id_seek = rb_intern("seek");
3428
4152
  id_close = rb_intern("close");
4153
+ id_path = rb_intern("path");
4154
+ id_input = rb_intern("@input");
3429
4155
 
3430
4156
  cGzipFile = rb_define_class_under(mZlib, "GzipFile", rb_cObject);
3431
4157
  cGzError = rb_define_class_under(cGzipFile, "Error", cZError);
3432
4158
 
4159
+ /* input gzipped string */
4160
+ rb_define_attr(cGzError, "input", 1, 0);
4161
+ rb_define_method(cGzError, "inspect", gzfile_error_inspect, 0);
4162
+
3433
4163
  cNoFooter = rb_define_class_under(cGzipFile, "NoFooter", cGzError);
3434
4164
  cCRCError = rb_define_class_under(cGzipFile, "CRCError", cGzError);
3435
4165
  cLengthError = rb_define_class_under(cGzipFile,"LengthError",cGzError);
@@ -3477,36 +4207,59 @@ void Init_zlib()
3477
4207
 
3478
4208
  rb_define_singleton_method(cGzipReader, "open", rb_gzreader_s_open,-1);
3479
4209
  rb_define_alloc_func(cGzipReader, rb_gzreader_s_allocate);
3480
- rb_define_method(cGzipReader, "initialize", rb_gzreader_initialize, 1);
4210
+ rb_define_method(cGzipReader, "initialize", rb_gzreader_initialize, -1);
3481
4211
  rb_define_method(cGzipReader, "rewind", rb_gzreader_rewind, 0);
3482
4212
  rb_define_method(cGzipReader, "unused", rb_gzreader_unused, 0);
3483
4213
  rb_define_method(cGzipReader, "read", rb_gzreader_read, -1);
4214
+ rb_define_method(cGzipReader, "readpartial", rb_gzreader_readpartial, -1);
3484
4215
  rb_define_method(cGzipReader, "getc", rb_gzreader_getc, 0);
4216
+ rb_define_method(cGzipReader, "getbyte", rb_gzreader_getbyte, 0);
3485
4217
  rb_define_method(cGzipReader, "readchar", rb_gzreader_readchar, 0);
4218
+ rb_define_method(cGzipReader, "readbyte", rb_gzreader_readbyte, 0);
3486
4219
  rb_define_method(cGzipReader, "each_byte", rb_gzreader_each_byte, 0);
4220
+ rb_define_method(cGzipReader, "each_char", rb_gzreader_each_char, 0);
4221
+ rb_define_method(cGzipReader, "bytes", rb_gzreader_each_byte, 0);
3487
4222
  rb_define_method(cGzipReader, "ungetc", rb_gzreader_ungetc, 1);
4223
+ rb_define_method(cGzipReader, "ungetbyte", rb_gzreader_ungetbyte, 1);
3488
4224
  rb_define_method(cGzipReader, "gets", rb_gzreader_gets, -1);
3489
4225
  rb_define_method(cGzipReader, "readline", rb_gzreader_readline, -1);
3490
4226
  rb_define_method(cGzipReader, "each", rb_gzreader_each, -1);
3491
4227
  rb_define_method(cGzipReader, "each_line", rb_gzreader_each, -1);
4228
+ rb_define_method(cGzipReader, "lines", rb_gzreader_each, -1);
3492
4229
  rb_define_method(cGzipReader, "readlines", rb_gzreader_readlines, -1);
3493
4230
 
4231
+ /* From GzipFile#os_code - code of current host */
3494
4232
  rb_define_const(mZlib, "OS_CODE", INT2FIX(OS_CODE));
4233
+ /* From GzipFile#os_code - 0x00 */
3495
4234
  rb_define_const(mZlib, "OS_MSDOS", INT2FIX(OS_MSDOS));
4235
+ /* From GzipFile#os_code - 0x01 */
3496
4236
  rb_define_const(mZlib, "OS_AMIGA", INT2FIX(OS_AMIGA));
4237
+ /* From GzipFile#os_code - 0x02 */
3497
4238
  rb_define_const(mZlib, "OS_VMS", INT2FIX(OS_VMS));
4239
+ /* From GzipFile#os_code - 0x03 */
3498
4240
  rb_define_const(mZlib, "OS_UNIX", INT2FIX(OS_UNIX));
4241
+ /* From GzipFile#os_code - 0x05 */
3499
4242
  rb_define_const(mZlib, "OS_ATARI", INT2FIX(OS_ATARI));
4243
+ /* From GzipFile#os_code - 0x06 */
3500
4244
  rb_define_const(mZlib, "OS_OS2", INT2FIX(OS_OS2));
4245
+ /* From GzipFile#os_code - 0x07 */
3501
4246
  rb_define_const(mZlib, "OS_MACOS", INT2FIX(OS_MACOS));
4247
+ /* From GzipFile#os_code - 0x0a */
3502
4248
  rb_define_const(mZlib, "OS_TOPS20", INT2FIX(OS_TOPS20));
4249
+ /* From GzipFile#os_code - 0x0b */
3503
4250
  rb_define_const(mZlib, "OS_WIN32", INT2FIX(OS_WIN32));
3504
4251
 
4252
+ /* From GzipFile#os_code - 0x04 */
3505
4253
  rb_define_const(mZlib, "OS_VMCMS", INT2FIX(OS_VMCMS));
4254
+ /* From GzipFile#os_code - 0x08 */
3506
4255
  rb_define_const(mZlib, "OS_ZSYSTEM", INT2FIX(OS_ZSYSTEM));
4256
+ /* From GzipFile#os_code - 0x09 */
3507
4257
  rb_define_const(mZlib, "OS_CPM", INT2FIX(OS_CPM));
4258
+ /* From GzipFile#os_code - 0x0c */
3508
4259
  rb_define_const(mZlib, "OS_QDOS", INT2FIX(OS_QDOS));
4260
+ /* From GzipFile#os_code - 0x0d */
3509
4261
  rb_define_const(mZlib, "OS_RISCOS", INT2FIX(OS_RISCOS));
4262
+ /* From GzipFile#os_code - 0xff */
3510
4263
  rb_define_const(mZlib, "OS_UNKNOWN", INT2FIX(OS_UNKNOWN));
3511
4264
 
3512
4265
  #endif /* GZIP_SUPPORT */
@@ -3533,6 +4286,77 @@ void Init_zlib()
3533
4286
  *
3534
4287
  */
3535
4288
 
4289
+ /*
4290
+ * Document-class: Zlib::StreamEnd
4291
+ *
4292
+ * Subclass of Zlib::Error
4293
+ *
4294
+ * When zlib returns a Z_STREAM_END
4295
+ * is return if the end of the compressed data has been reached
4296
+ * and all uncompressed out put has been produced.
4297
+ *
4298
+ */
4299
+
4300
+ /*
4301
+ * Document-class: Zlib::NeedDict
4302
+ *
4303
+ * Subclass of Zlib::Error
4304
+ *
4305
+ * When zlib returns a Z_NEED_DICT
4306
+ * if a preset dictionary is needed at this point.
4307
+ *
4308
+ * Used by Zlib::Inflate.inflate and <tt>Zlib.inflate</tt>
4309
+ */
4310
+
4311
+ /*
4312
+ * Document-class: Zlib::VersionError
4313
+ *
4314
+ * Subclass of Zlib::Error
4315
+ *
4316
+ * When zlib returns a Z_VERSION_ERROR,
4317
+ * usually if the zlib library version is incompatible with the
4318
+ * version assumed by the caller.
4319
+ *
4320
+ */
4321
+
4322
+ /*
4323
+ * Document-class: Zlib::MemError
4324
+ *
4325
+ * Subclass of Zlib::Error
4326
+ *
4327
+ * When zlib returns a Z_MEM_ERROR,
4328
+ * usually if there was not enough memory.
4329
+ *
4330
+ */
4331
+
4332
+ /*
4333
+ * Document-class: Zlib::StreamError
4334
+ *
4335
+ * Subclass of Zlib::Error
4336
+ *
4337
+ * When zlib returns a Z_STREAM_ERROR,
4338
+ * usually if the stream state was inconsistent.
4339
+ *
4340
+ */
4341
+
4342
+ /*
4343
+ * Document-class: Zlib::BufError
4344
+ *
4345
+ * Subclass of Zlib::Error when zlib returns a Z_BUF_ERROR.
4346
+ *
4347
+ * Usually if no progress is possible.
4348
+ *
4349
+ */
4350
+
4351
+ /*
4352
+ * Document-class: Zlib::DataError
4353
+ *
4354
+ * Subclass of Zlib::Error when zlib returns a Z_DATA_ERROR.
4355
+ *
4356
+ * Usually if a stream was prematurely freed.
4357
+ *
4358
+ */
4359
+
3536
4360
  /*
3537
4361
  * Document-class: Zlib::GzipFile::Error
3538
4362
  *
@@ -3542,21 +4366,21 @@ void Init_zlib()
3542
4366
  /*
3543
4367
  * Document-class: Zlib::GzipFile::NoFooter
3544
4368
  *
3545
- * Raised when gzip file footer is not found.
4369
+ * Raised when gzip file footer is not found.
3546
4370
  */
3547
4371
 
3548
4372
  /*
3549
4373
  * Document-class: Zlib::GzipFile::CRCError
3550
4374
  *
3551
4375
  * Raised when the CRC checksum recorded in gzip file footer is not equivalent
3552
- * to the CRC checksum of the actual uncompressed data.
4376
+ * to the CRC checksum of the actual uncompressed data.
3553
4377
  */
3554
4378
 
3555
4379
  /*
3556
4380
  * Document-class: Zlib::GzipFile::LengthError
3557
4381
  *
3558
4382
  * Raised when the data length recorded in the gzip file footer is not equivalent
3559
- * to the length of the actual uncompressed data.
4383
+ * to the length of the actual uncompressed data.
3560
4384
  */
3561
4385
 
3562
4386